func readAll(t *testing.T, rows *sql.Rows) resultSlice { defer rows.Close() cols, err := rows.Columns() if err != nil { t.Fatal(err) } colStrs := make([]*string, len(cols)) for i := range cols { colStrs[i] = &cols[i] } results := resultSlice{colStrs} for rows.Next() { strs := make([]*string, len(cols)) vals := make([]interface{}, len(cols)) for i := range vals { vals[i] = &strs[i] } if err := rows.Scan(vals...); err != nil { t.Fatal(err) } results = append(results, strs) } if err := rows.Err(); err != nil { t.Fatal(err) } return results }
/* ScanAll accepts a pointer to a slice of a type and fills it with repeated calls to Scan. ScanAll only works if you're trying to extract a single object from each row of the query results. Additionally, it closes the passed sql.Rows object. ScanAll effectively replaces this code // old code defer rows.Close() objs := []Object{} for rows.Next() { var obj Object Scan(rows, &obj) objs = append(objs, obj) } With simply // new code objs := []Object{} ScanAll(rows, &objs) */ func ScanAll(rows *sql.Rows, slicePtr interface{}) error { defer rows.Close() sliceVal := reflect.ValueOf(slicePtr).Elem() if sliceVal.Kind() != reflect.Slice { return fmt.Errorf("Argument to crud.ScanAll is not a slice") } elemType := sliceVal.Type().Elem() if elemType.Kind() != reflect.Struct { return fmt.Errorf("Argument to crud.ScanAll must be a slice of structs") } for rows.Next() { newVal := reflect.New(elemType) if er := Scan(rows, newVal.Interface()); er != nil { return er } sliceVal.Set(reflect.Append(sliceVal, newVal.Elem())) } return nil }
func scanItemComment(comment *data.ItemComment, rows *sql.Rows) error { var updateTimeString string err := rows.Scan( &comment.ID, &comment.ItemID, &comment.Author, &comment.Body, &updateTimeString, ) if err != nil { return err } updateTime, err := time.Parse("2006-01-02 15:04:05", updateTimeString) // this assumes UTC as timezone if err != nil { log.Println("ItemComment scanner failed to parse time. " + updateTimeString) return err } comment.UpdateTime = updateTime return nil }
func scanUser(user *data.User, rows *sql.Rows) error { var createTimeString string err := rows.Scan( &user.Username, &user.Password, &user.Salt, &user.Role, &user.TrustLevel, &createTimeString, ) if err != nil { return err } createTime, err := time.Parse("2006-01-02 15:04:05", createTimeString) // this assumes UTC as timezone if err != nil { log.Println("User scanner failed to parse time.") return err } user.CreateTime = createTime return nil }
/* Copies *sql.Rows into the slice of maps or structs given by the pointer dst. */ func (self *T) FetchRow(dst interface{}, rows *sql.Rows) error { dstv := reflect.ValueOf(dst) if dstv.IsNil() || dstv.Kind() != reflect.Ptr { return db.ErrExpectingPointer } itemv := dstv.Elem() columns, err := getRowColumns(rows) if err != nil { return err } next := rows.Next() if next == false { return db.ErrNoMoreRows } item, err := self.fetchResult(itemv.Type(), rows, columns) if err != nil { return err } itemv.Set(reflect.Indirect(item)) return nil }
func sexDomain(dom string) (sexAnswer bool, err error) { var stmt *sql.Stmt stmt, err = db.Prepare(`SELECT dom FROM domains WHERE dom = $1 AND sex = true LIMIT 1`) if err != nil { fmt.Printf("db.Prepare error: %v\n", err) return false, err } var rows *sql.Rows rows, err = stmt.Query(dom) if err != nil { fmt.Printf("stmt.Query error: %v\n", err) return false, err } defer stmt.Close() if rows.Next() { var domain string err = rows.Scan(&domain) if err != nil { fmt.Printf("rows.Scan error: %v\n", err) return false, err } if configuration.Debug == "Yes" { fmt.Println("domain => \"" + domain + "\"") } return true, err } return false, nil }
func bmPreparedQuery(b *testing.B) { stmt, err := db.Prepare("SELECT number, str FROM test") if err != nil { panic(err) } var num int64 var str string var i int64 var rows *sql.Rows for rep := 0; rep < 10000; rep++ { rows, err = stmt.Query() if err != nil { panic(err) } i = 0 for rows.Next() { rows.Scan(&num, &str) if num != i { panic(fmt.Sprintf("Result didn't match: %d!=%d", num, i)) } i++ } if i != 100 { panic(fmt.Sprintf("Rows count doesn't match: %d!=100", i)) } } stmt.Close() }
func (scan *Scan) One(rows *sql.Rows) error { for rows.Next() { return scan.Scan(rows, meta.DirectValueOf(scan.To)) } return errors.New("No matching rows found.") }
func setTimer(rows *sql.Rows) (*Timer, error) { var finishedAt pq.NullTime var createdAt pq.NullTime timer := Timer{} err := rows.Scan(&timer.ID, &timer.User, &timer.Name, &createdAt, &finishedAt) if err != nil { return nil, err } val, err := createdAt.Value() if err != nil { return nil, err } if val != nil { timer.CreatedAt = &createdAt.Time } val, err = finishedAt.Value() if err != nil { return nil, err } if val != nil { timer.FinishedAt = &finishedAt.Time } return &timer, nil }
// Scan values from the database func scan(cols []string, rows *sql.Rows) map[string]interface{} { var rtn = map[string]interface{}{} // Create scanner array var values []interface{} var generic = reflect.TypeOf(values).Elem() for i := 0; i < len(cols); i++ { values = append(values, reflect.New(generic).Interface()) } // Scan! var err = rows.Scan(values...) if err != nil { n.Log("Driver failed to scan values: %s", err.Error()) return nil } // Convert into native types for i := 0; i < len(cols); i++ { var raw_value = *(values[i].(*interface{})) var raw_type = reflect.TypeOf(raw_value) switch { case raw_type == reflect.TypeOf(int64(0)): rtn[cols[i]] = raw_value.(int64) } } return rtn }
//List ... func (vs VictualService) List() []Victual { db, err := sql.Open("postgres", "host=localhost port=5432 user=pober dbname=pober sslmode=disable") checkErr(err) defer db.Close() var rows *sql.Rows rows, err = db.Query("SELECT id, description, brand, source, energyCal, energyJoule, fat, saturatedFat, carbohydrates, sugars, protein, salt, fiber, barCode, weightVolumeRatio FROM dc.victual") checkErr(err) victuals := []Victual{} for rows.Next() { var victual Victual err = rows.Scan(&victual.ID, &victual.Description, &victual.Brand, &victual.Source, &victual.EnergyCal, &victual.EnergyJoule, &victual.Fat, &victual.SaturatedFat, &victual.Carbohydrates, &victual.Sugars, &victual.Protein, &victual.Salt, &victual.Fiber, &victual.BarCode, &victual.WeightVolumeRatio) checkErr(err) victuals = append(victuals, victual) } return victuals }
func findNotesByUser(user *User, query string) []*Note { var err error var rows *sql.Rows if len(query) == 0 { rows, err = db.Query("SELECT * FROM notes WHERE user_id=?", user.ID) } else { queryFmt := fmt.Sprintf("%%%s%%", query) rows, err = db.Query( "SELECT * FROM notes WHERE user_id=? AND (body LIKE ? OR title LIKE ?)", user.ID, queryFmt, queryFmt) } if err != nil { checkErr(err, "findNotesByUser") } else { defer rows.Close() } var notes []*Note for rows.Next() { notes = append(notes, noteFromDbRows(rows)) } return notes }
func getCallRoutes(lastNHours int, failedOnly bool) (callRoutes []*callRoute, err error) { var rows *sql.Rows callRouteSQL := ` SELECT * FROM ( SELECT c.app, c.route, COUNT(c.*) AS count, ROUND(AVG(extract(epoch from (c."end" - c.start))*1000000))::bigint AS avg_duration FROM "` + appmon.DBSchema + `".call c WHERE current_timestamp - c.start < ($1::int * interval '1 hour') AND c."end" IS NOT NULL AND ((NOT $2) OR (http_status_code < 200 OR http_status_code >= 400)) GROUP BY app, route ) q ORDER BY count DESC ` rows, err = appmon.DB.Query(callRouteSQL, lastNHours, failedOnly) if err != nil { return nil, err } for rows.Next() { cr := new(callRoute) err = rows.Scan(&cr.App, &cr.Route, &cr.Count, &cr.AvgDuration) if err != nil { return } callRoutes = append(callRoutes, cr) } return }
func bindComponent(name string, rs *sql.Rows, ctype componentType, manager *Manager) (*Component, error) { var id int64 cols, err := rs.Columns() if err != nil { return nil, err } ifaces := make([]interface{}, len(cols)) ifaceptrs := make([]interface{}, len(cols)) for i := 0; i < len(ifaces); i++ { ifaceptrs[i] = &ifaces[i] } err = rs.Scan(ifaceptrs...) if err != nil { return nil, err } cv := reflect.New(ctype.typ).Elem() for i, field := range cols { if field == "entity_id" { id = ifaces[i].(int64) continue } f := cv.FieldByName(field) if !f.IsValid() { return nil, fmt.Errorf("Field %s is invalid for %s", field, name) } iv := reflect.ValueOf(ifaces[i]) switch iv.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: f.SetInt(iv.Int()) default: f.Set(iv) } } return &Component{entity: id, name: name, isNew: false, manager: manager, data: cv.Addr().Interface()}, nil }
func (d DAO) Select(key interface{}, result interface{}) error { if d.conn == nil { return errors.New("no connection to mysql!") } var err error var rows *sql.Rows sql := fmt.Sprintf("select * from %s where id = %d", d.table, key) rows, err = d.conn.Query(sql) if err != nil { fmt.Println(err) return err } t := reflect.ValueOf(result) e := t.Elem() e = e.Slice(0, e.Len()) i := 0 for rows.Next() && i < e.Len() { j := 0 s := make([]interface{}, 0, 10) for j < e.Index(i).NumField() { s = append(s, e.Index(i).Field(j).Addr().Interface()) j++ //fmt.Println(j) } err = rows.Scan(s...) i++ } return err }
func validate_result_of_sp(dbt *DBTest, rows *sql.Rows) { // final OK packet , indicate last INSERT effected rows // https://dev.mysql.com/doc/internals/en/multi-resultset.html if res, ok := rows.Sibling(); false == ok { dbt.Fatal("there should be a last ok packet.") } else if nil == res { dbt.Fatal("last packet of CALL should return a Result.") } else { if affcted, err := res.RowsAffected(); nil != err { dbt.Fatal("should not return err when RowsAffected") } else if 1 != affcted { dbt.Fatal("Last INSERT STMT in SP should affected one row. ") } if insertId, err := res.LastInsertId(); nil != err { dbt.Fatal("should not return err when LastInsertId") } else if 0 != insertId { dbt.Fatalf("Last INSERT STMT in SP should not return LAST_INSERT_ID:%d ", insertId) } if true == rows.Next() { dbt.Fatal("last packet has no rows, but just affected rows and last insert id") } } }
//Parse an executed query func (dbw *Sqlite3) Parse(rows *sql.Rows) (results Results, err error) { // here im not sure what im getting from the db as it can be anything from the results //therefore i wish i can just put everything in a bucket, and think later. tc, tn := dbw.TotalCount(rows) // multiFields := make([]interface{}, tc) multiFieldsPtrs := make([]interface{}, tc) for i := 0; i < tc; i++ { var multiFields interface{} multiFieldsPtrs[i] = &multiFields } headers := make(map[string]interface{}) headers["fields"] = tn results = append(results, headers) for rows.Next() { err = rows.Scan(multiFieldsPtrs...) checkErrors(err) tempMap := make(map[string]interface{}) for idx, label := range tn { row := *(multiFieldsPtrs[idx].(*interface{})) // if sizeOf(row) < 1 { // skip = true // break // } tempMap[label] = row } results = append(results, tempMap) } return }
// Query multiple rows into a slice. func querySlice(model *model, slice interface{}, rows *sql.Rows) error { // var slice *[]T // sliceVal := *slice var ( sliceVal = reflect.ValueOf(slice).Elem() foundCap = 0 err error ) // first, populate the existing allocated elements in the slice. If it's an // empty slice, this loop will effectively be skipped. for i := 0; i < sliceVal.Len() && rows.Next(); i++ { if foundCap, err = model.scan(sliceVal.Index(i), rows, foundCap); err != nil { return err } } // now start scanning into new values and append to the slice. If we're // already done, this loop will effectively be skipped. // var sliceElemType type = T sliceElemType := sliceVal.Type().Elem() for rows.Next() { val := reflect.New(sliceElemType) if _, err := model.scan(val, rows, foundCap); err != nil { return err } sliceVal.Set(reflect.Append(sliceVal, val.Elem())) } return nil }
func (scan *Scan) ScanToStruct(rows *sql.Rows, record reflect.Value) error { columns, err := rows.Columns() if err != nil { return err } values := make([]interface{}, len(columns)) for i, column := range columns { var field reflect.Value fieldName := scan.SQLColumnDict[column] if scan.ToPointers { field = record.Elem().FieldByName(fieldName) } else { field = record.FieldByName(fieldName) } if field.IsValid() { values[i] = field.Addr().Interface() } else { values[i] = &values[i] } } return rows.Scan(values...) }
func populateApplicationGuides(rows *sql.Rows, ch chan []ApplicationGuide) { var ag ApplicationGuide var ags []ApplicationGuide var catID *int var icon []byte var catName *string for rows.Next() { err := rows.Scan( &ag.ID, &ag.Url, &ag.Website.ID, &ag.FileType, &catID, &icon, &catName, ) if err != nil { ch <- ags } if catID != nil { ag.Category.CategoryID = *catID } if catName != nil { ag.Category.Title = *catName } if icon != nil { ag.Icon = string(icon[:]) } ags = append(ags, ag) } ch <- ags return }
func MItemSelectByID(db *sql.DB, itemID int) (*MItem, error) { q := ` select item_id ,image_id ,type ,name ,detail ,param from m_item where item_id = $1 ` var rows *sql.Rows var err error rows, err = db.Query(q, itemID) if err != nil { return nil, err } for rows.Next() { var mItem MItem if err := rows.Scan(&mItem.ItemID, &mItem.ImageID, &mItem.ItemType, &mItem.Name, &mItem.Detail, &mItem.Param); err != nil { fmt.Println(err) } return &mItem, nil } return nil, errors.New("not found") }
// 根据父节点地区码获取该节点下的地区列表 func FindRegionByParentCode(parentCode string) (regions []*Region, err error) { db := GetMySQL() defer db.Close() regions = []*Region{} var rows *sql.Rows if parentCode == "" { //根节点的情况 rows, err = db.Query("SELECT code,name FROM region WHERE parent_code is null") } else { rows, err = db.Query("SELECT code,name FROM region WHERE parent_code = ?", parentCode) } if err != nil { Log.Error(err.Error()) return regions, err } for rows.Next() { region := new(Region) err := rows.Scan(®ion.Code, ®ion.Name) if err != nil { Log.Warn(err.Error()) return regions, err } regions = append(regions, region) } return regions, nil }
func fieldModelProto(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result { var err error var rows *sql.Rows if rows, err = dbR.Query(`SELECT modelID FROM field.model`); err != nil { return weft.InternalServerError(err) } var fmr mtrpb.FieldModelResult for rows.Next() { var t mtrpb.FieldModel if err = rows.Scan(&t.ModelID); err != nil { return weft.InternalServerError(err) } fmr.Result = append(fmr.Result, &t) } var by []byte if by, err = proto.Marshal(&fmr); err != nil { return weft.InternalServerError(err) } b.Write(by) return &weft.StatusOK }
// 用于FindAll中,具体model在遍历rows时调用(提取的公共代码) func (this *Dao) Scan(rows *sql.Rows, colNum int, colFieldMap map[string]interface{}, selectCol ...string) error { scanInterface := make([]interface{}, 0, colNum) for _, column := range selectCol { scanInterface = append(scanInterface, colFieldMap[column]) } return rows.Scan(scanInterface...) }
func GetResultsTwo(rows *sql.Rows) [][]string { var ( results [][]string //result [][]string id string types string title string message string i int ) results = make([][]string, 1) i = 0 for rows.Next() { err := rows.Scan(&id, &types, &title, &message) if err != nil { //fmt.Println(err) } messages := []string{id, types, title, message} fmt.Println(messages) for index, element := range messages { results[i][index] = element } i++ } return results }
// Query if given upload is expired - an upload thus not having any records which are currently active func (tx *Transaction) QueryExpiredUpload(id string) (result bool, err error) { err = tx.do(func(tx *sql.Tx) (err error) { var rows *sql.Rows rows, err = tx.Query(` SELECT "u"."id" AS "id" FROM "uploads" AS "u" WHERE "u"."id" = $1 GROUP BY "u"."id" HAVING MAX("u"."expiration") < NOW()`, id) if err != nil { return } defer rows.Close() if rows.Next() { result = true } return }) return }
func scanUserDirection(direction *data.UserDirection, rows *sql.Rows) error { var updateTimeString string err := rows.Scan( &direction.Username, &direction.LockUsername, &direction.Command, &direction.Heading, &direction.Lat, &direction.Lng, &updateTimeString, ) if err != nil { return err } updateTime, err := time.Parse("2006-01-02 15:04:05", updateTimeString) // this assumes UTC as timezone if err != nil { log.Println("UserDirection scanner failed to parse time.") return err } direction.UpdateTime = updateTime return nil }
func dataSiteProto(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result { var err error var rows *sql.Rows if rows, err = dbR.Query(`SELECT siteID, latitude, longitude FROM data.site`); err != nil { return weft.InternalServerError(err) } var ts mtrpb.DataSiteResult for rows.Next() { var t mtrpb.DataSite if err = rows.Scan(&t.SiteID, &t.Latitude, &t.Longitude); err != nil { return weft.InternalServerError(err) } ts.Result = append(ts.Result, &t) } var by []byte if by, err = proto.Marshal(&ts); err != nil { return weft.InternalServerError(err) } b.Write(by) return &weft.StatusOK }
func Scan2Struct(rows *sql.Rows, stru interface{}) error { beanVal := reflect.ValueOf(stru) if beanVal.Kind() != reflect.Ptr { return errors.New("Scan2Bean bean not a pointer") } beanVal = beanVal.Elem() cols, err := rows.Columns() if err != nil { return err } dest := make([]interface{}, len(cols)) for i, col := range cols { fldName := convertColName2FldName(col) fldVal := beanVal.FieldByName(fldName) if fldVal.Kind() != reflect.Struct && fldVal.Kind() != reflect.Ptr { dest[i] = fldVal.Addr().Interface() } else if fldVal.Type().String() == "time.Time" { dest[i] = &ReflectScanner{Value: &fldVal} // dest[i] = &TypeTestScanner{} } else { panic(fmt.Sprintf("Scan2Bean %v %v not support", fldName, fldVal.Type().String())) } } return rows.Scan(dest...) }
func scanRqEntry(rows *sql.Rows) (rq_entry *RunQueueEntry, err error) { rq_entry = new(RunQueueEntry) err = rows.Scan( &rq_entry.Id, &rq_entry.ClassName, &rq_entry.timetable_id, &rq_entry.generation_id, &rq_entry.hostname, &rq_entry.hostname_idx, &rq_entry.JobData, &rq_entry.method, &rq_entry.RunStatus, &rq_entry.created, &rq_entry.waiting_ts, &rq_entry.should_init_ts, &rq_entry.init_attempts, &rq_entry.init_ts, &rq_entry.running_ts, &rq_entry.max_finished_ts, &rq_entry.finished_ts, &rq_entry.stopped_employee_id, &rq_entry.token, &rq_entry.retry_attempt, &rq_entry.settings_id) return }