示例#1
8
func rowsToStrings(rows *sql.Rows) [][]string {
	cols, err := rows.Columns()
	if err != nil {
		panic(err)
	}
	pretty := [][]string{cols}
	results := make([]interface{}, len(cols))
	for i := range results {
		results[i] = new(interface{})
	}
	for rows.Next() {
		if err := rows.Scan(results[:]...); err != nil {
			panic(err)
		}
		cur := make([]string, len(cols))
		for i := range results {
			val := *results[i].(*interface{})
			var str string
			if val == nil {
				str = "NULL"
			} else {
				switch v := val.(type) {
				case []byte:
					str = string(v)
				default:
					str = fmt.Sprintf("%v", v)
				}
			}
			cur[i] = str
		}
		pretty = append(pretty, cur)
	}
	return pretty
}
示例#2
2
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
}
示例#3
0
文件: query.go 项目: katyhuff/cyan
func AllAgents(db *sql.DB, simid []byte, proto string) (ags []AgentInfo, err error) {
	s := `SELECT AgentId,Kind,Spec,Prototype,ParentId,EnterTime,ExitTime,Lifetime FROM
				Agents
			WHERE Agents.SimId = ?`

	var rows *sql.Rows
	if proto != "" {
		s += ` AND Agents.Prototype = ?`
		rows, err = db.Query(s, simid, proto)
	} else {
		rows, err = db.Query(s, simid)
	}
	if err != nil {
		return nil, err
	}

	for rows.Next() {
		ai := AgentInfo{}
		var exit sql.NullInt64
		if err := rows.Scan(&ai.Id, &ai.Kind, &ai.Impl, &ai.Proto, &ai.Parent, &ai.Enter, &exit, &ai.Lifetime); err != nil {
			return nil, err
		}
		if !exit.Valid {
			exit.Int64 = -1
		}
		ai.Exit = int(exit.Int64)
		ags = append(ags, ai)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return ags, nil
}
示例#4
0
func Test_Query(t *testing.T) {
	conn, err := sql.Open("mysql", TestConnParam)
	unitest.NotError(t, err)
	defer conn.Close()

	var res *sql.Rows

	res, err = conn.Query("SELECT * FROM test ORDER BY id ASC")
	unitest.NotError(t, err)
	defer res.Close()

	i := 0
	for res.Next() {
		var (
			id    int64
			value string
		)

		err := res.Scan(&id, &value)
		unitest.NotError(t, err)

		unitest.Pass(t, id == int64(i))
		unitest.Pass(t, value == strconv.Itoa(i))
		i++
	}

	unitest.Pass(t, i == 10)
}
示例#5
0
文件: scan.go 项目: rjp/crud
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.")
}
示例#6
0
func (persister *Persister) GetServiceAgentList(cond string) ([]ServiceAgent, error) {
	var rows *sql.Rows
	var err error
	if cond == "" {
		rows, err = persister.Db.Query("SELECT service_host,docker_host,docker_port,is_active,perf_factor,ping_interval_secs,last_ping,exec_command,exec_args,portbinding_min,portbinding_max,portbindings FROM serviceagents")
	} else {
		rows, err = persister.Db.Query("SELECT service_host,docker_host,docker_port,is_active,perf_factor,ping_interval_secs,last_ping,exec_command,exec_args,portbinding_min,portbinding_max,portbindings FROM serviceagents where " + cond)
	}
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var serviceagents []ServiceAgent
	i := 0
	for rows.Next() {
		serviceagent := ServiceAgent{}
		var timevalue interface{}
		rows.Scan(&serviceagent.ServiceHost, &serviceagent.DockerHost, &serviceagent.DockerPort, &serviceagent.IsActive, &serviceagent.PerfFactor, &serviceagent.KeepAlive, &timevalue, &serviceagent.ExecCommand, &serviceagent.ExecArgs, &serviceagent.Portbind_min, &serviceagent.Portbind_max, &serviceagent.Portbindings)
		switch timevalue.(type) {
		case string:
			serviceagent.LastPing, err = time.Parse("2006-01-02 15:04:05 ", timevalue.(string))
		case time.Time:
			serviceagent.LastPing = timevalue.(time.Time)
		}

		if err != nil {
			log.Println("error reading row ", err)
		}
		serviceagents = append(serviceagents, serviceagent)
		i = i + 1
	}
	return serviceagents, nil
}
示例#7
0
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
}
示例#8
0
func sqlToMaps(ctx *Ctx, sqlString string, sqlParams ...interface{}) (ret []map[string]interface{}, err error) {
	ret = []map[string]interface{}{}
	var rows *sql.Rows
	rows, err = ctx.db.Query(sqlString, sqlParams...)
	defer rows.Close()
	if err != nil {
		return
	}
	columns, err := rows.Columns()
	if err != nil {
		return
	}
	count := len(columns)
	values := make([]interface{}, count)
	valuePtrs := make([]interface{}, count)
	for i := 0; i < count; i++ {
		valuePtrs[i] = &values[i]
	}
	for rows.Next() {
		retRow := map[string]interface{}{}
		rows.Scan(valuePtrs...)
		for i, col := range columns {
			val := values[i]
			switch val.(type) {
			case []uint8:
				retRow[col] = string(val.([]uint8))
			default:
				retRow[col] = val
			}
		}
		ret = append(ret, retRow)
	}
	return
}
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
}
示例#10
0
文件: mysql.go 项目: micro/config-srv
func (m *mysql) AuditLog(from, to, limit, offset int64, reverse bool) ([]*proto.ChangeLog, error) {
	var r *sql.Rows
	var err error

	if from == 0 && to == 0 {
		q := "readLog"
		if reverse {
			q += "Desc"
		}
		r, err = st[q].Query(limit, offset)
	} else {
		q := "readBetween"
		if reverse {
			q += "Desc"
		}
		r, err = st[q].Query(from, to, limit, offset)
	}

	if err != nil {
		return nil, err
	}
	defer r.Close()

	var logs []*proto.ChangeLog

	for r.Next() {
		var id int

		log := &proto.ChangeLog{
			Change: &proto.Change{
				ChangeSet: &proto2.ChangeSet{},
			},
		}
		if err := r.Scan(
			&id,
			&log.Action,
			&log.Change.Id,
			&log.Change.Path,
			&log.Change.Author,
			&log.Change.Comment,
			&log.Change.Timestamp,
			&log.Change.ChangeSet.Timestamp,
			&log.Change.ChangeSet.Checksum,
			&log.Change.ChangeSet.Data,
			&log.Change.ChangeSet.Source,
		); err != nil {
			if err == sql.ErrNoRows {
				return nil, errors.New("not found")
			}
			return nil, err
		}
		logs = append(logs, log)

	}
	if r.Err() != nil {
		return nil, err
	}

	return logs, nil
}
示例#11
0
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()
}
示例#12
0
文件: main.go 项目: Gwillink/textql
func displayResult(rows *sql.Rows) {
	cols, cols_err := rows.Columns()

	if cols_err != nil {
		log.Fatalln(cols_err)
	}

	rawResult := make([][]byte, len(cols))
	result := make([]string, len(cols))

	dest := make([]interface{}, len(cols))
	for i, _ := range cols {
		dest[i] = &rawResult[i]
	}

	for rows.Next() {
		rows.Scan(dest...)

		for i, raw := range rawResult {
			result[i] = string(raw)
		}

		for j, v := range result {
			fmt.Printf("%s", v)
			if j != len(result)-1 {
				fmt.Printf(", ")
			}
		}
		fmt.Printf("\n")
	}
}
示例#13
0
文件: card.go 项目: caneroj1/cardsAPI
// getCardsWithWhereQuery returns all of the cards that match a certain WHERE query.
func getCardsWithWhereQuery(query string, params ...interface{}) []Card {
	var cards []Card
	var err error

	sqlQ := "select cardbody, cardtype, cardblanks, classic, id, createdon, rating, raters, approved, createdby from %s " + query
	var rows *sql.Rows
	if len(params) == 0 {
		rows = database.GetByQuery(sqlQ)
	} else {
		rows = database.GetByQuery(sqlQ, params...)
	}
	defer rows.Close()

	var card Card
	for rows.Next() {
		err = rows.Scan(&card.CardBody, &card.CardType,
			&card.CardBlanks, &card.Classic, &card.ID,
			&card.CreatedOn, &card.Rating, &card.Raters,
			&card.Approved, &card.CreatedBy)
		if err != nil {
			log.Fatal(err)
		}

		cards = append(cards, card)
	}

	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}

	return cards
}
示例#14
0
// 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
}
示例#15
0
// Query all expired uploads - uploads thus not having any records which are currently active
func (tx *Transaction) QueryExpiredUploads() (result []string, 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"
			GROUP BY "u"."id"
			HAVING MAX("u"."expiration") < NOW()`)
		if err != nil {
			return
		}

		defer rows.Close()

		for rows.Next() {
			var id string

			err = rows.Scan(&id)
			if err != nil {
				return
			}

			result = append(result, id)
		}

		return
	})

	return
}
示例#16
0
// sqlRowsToStrings turns 'rows' into a list of rows, each of which
// is a  list of column values.
// 'rows' should be closed by the caller.
// If 'format' is not nil, the values with column name
// found in the map are run through the corresponding callback.
// It returns the header row followed by all data rows.
// If both the header row and list of rows are empty, it means no row
// information was returned (eg: statement was not a query).
func sqlRowsToStrings(rows *sql.Rows, format fmtMap) ([]string, [][]string, error) {
	cols, err := rows.Columns()
	if err != nil {
		return nil, nil, fmt.Errorf("rows.Columns() error: %s", err)
	}

	if len(cols) == 0 {
		return nil, nil, nil
	}

	vals := make([]interface{}, len(cols))
	for i := range vals {
		vals[i] = new(interface{})
	}

	allRows := [][]string{}
	for rows.Next() {
		rowStrings := make([]string, len(cols))
		if err := rows.Scan(vals...); err != nil {
			return nil, nil, fmt.Errorf("scan error: %s", err)
		}
		for i, v := range vals {
			if f, ok := format[cols[i]]; ok {
				rowStrings[i] = f(*v.(*interface{}))
			} else {
				rowStrings[i] = formatVal(*v.(*interface{}))
			}
		}
		allRows = append(allRows, rowStrings)
	}

	return cols, allRows, nil
}
示例#17
0
func (gkDbCon *GkDbConDef) getNextChatArchivesId() (int32, *gkerr.GkErrDef) {
	var stmt *sql.Stmt
	var err error

	stmt, err = gkDbCon.sqlDb.Prepare("select nextval('chat_archives_seq')")
	if err != nil {
		return 0, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
	}

	defer stmt.Close()

	var rows *sql.Rows

	rows, err = stmt.Query()
	if err != nil {
		return 0, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
	}

	defer rows.Close()

	var id int32

	if rows.Next() {
		err = rows.Scan(&id)
		if err != nil {
			return 0, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
		}
	} else {
		return 0, gkerr.GenGkErr("select users", nil, ERROR_ID_NO_ROWS_FOUND)
	}

	return id, nil
}
示例#18
0
//	sql_ := fmt.Sprintf(`SELECT "Json" %s where `+p.wheresql, p.getFrom())
//	var rows *sql.Rows
//	if rows, p.Err = p._query(sql_, p.whereargs...); p.NotErr() {
//		defer rows.Close()
//		for rows.Next() {
//			var v []byte
//			rows.Scan(&v)
//			obj := reflect.New(p.model.Type).Interface()
//			json.Unmarshal(v, obj)
//			slicev = reflect.Append(slicev, reflect.ValueOf(obj).Elem())
//		}
//		resultv.Elem().Set(slicev.Slice(0, slicev.Len()))
//	}
//	return p
//}
func (p *Scope) PageJson(lst T, page, perPage int) (pager db.Paging) {
	p.checkModel(lst)
	pf := filter.NewPageFilter(page, perPage)
	p.Limit(pf.Skip(), perPage)
	pager.Total = p.Count(lst)
	//	log.Println(pager.Total)
	resultv := reflect.ValueOf(lst)
	if resultv.Kind() != reflect.Ptr || resultv.Elem().Kind() != reflect.Slice {
		panic("out argument must be a slice address")
	}
	slicev := resultv.Elem()
	wsa := p.buildWhere()
	pas := p.buildPage()
	sql_ := fmt.Sprintf(`SELECT "Json" %s `+wsa.Sql+" "+pas.Sql, p.getFrom())
	var rows *sql.Rows
	if rows, p.Err = p._query(sql_, wsa.Args...); p.NotErr() {
		defer rows.Close()
		for rows.Next() {
			var v []byte
			rows.Scan(&v)
			obj := reflect.New(p.model.Type).Interface()
			json.Unmarshal(v, obj)
			slicev = reflect.Append(slicev, reflect.ValueOf(obj).Elem())
		}
		resultv.Elem().Set(slicev.Slice(0, slicev.Len()))
	}
	pager.Items = lst
	//	log.Println(lst)
	return
}
示例#19
0
func (gkDbCon *GkDbConDef) getMaxChatId() (int32, *gkerr.GkErrDef) {
	var stmt *sql.Stmt
	var maxId int32 = 0
	var err error

	stmt, err = gkDbCon.sqlDb.Prepare("select max(id) from chat_archives")
	if err != nil {
		return 0, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
	}

	defer stmt.Close()

	var rows *sql.Rows

	rows, err = stmt.Query()
	if err != nil {
		return 0, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
	}

	defer rows.Close()

	if rows.Next() {
		err = rows.Scan(&maxId)
		if err != nil {
			return 0, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
		}
	}

	return maxId, nil
}
示例#20
0
func sqlToStringsMaps(ctx *Ctx, sqlString string, sqlParams ...interface{}) (ret []map[string]string, err error) {
	ret = []map[string]string{}
	var rows *sql.Rows
	rows, err = ctx.db.Query(sqlString, sqlParams...)
	defer rows.Close()
	if err != nil {
		return
	}
	columns, err := rows.Columns()
	if err != nil {
		return
	}
	count := len(columns)
	values := make([]sql.NullString, count) // Без NullString невозможно определить, когда NULL
	valuePtrs := make([]interface{}, count)
	for i := 0; i < count; i++ {
		valuePtrs[i] = &values[i]
	}
	for rows.Next() {
		retRow := map[string]string{}
		rows.Scan(valuePtrs...)
		for i, col := range columns {
			retRow[col] = values[i].String
		}
		ret = append(ret, retRow)
	}
	return
}
示例#21
0
func (p *Scope) AllJson(lst T) *Scope {
	p.checkModel(lst)
	p.Select(p.orm.mapper("Json"))
	p.From(p.model.Name)
	resultv := reflect.ValueOf(lst)
	if resultv.Kind() != reflect.Ptr || resultv.Elem().Kind() != reflect.Slice {
		panic("out argument must be a slice address")
	}
	slicev := resultv.Elem()

	sa := p.builder.SqlSelect()

	var rows *sql.Rows
	if rows, p.Err = p._query2(sa); p.NotErr() {
		defer rows.Close()
		for rows.Next() {
			var v []byte
			rows.Scan(&v)
			obj := reflect.New(p.model.Type).Interface()
			json.Unmarshal(v, obj)
			slicev = reflect.Append(slicev, reflect.ValueOf(obj).Elem())
		}
		resultv.Elem().Set(slicev.Slice(0, slicev.Len()))
	}
	return p
}
示例#22
0
文件: data_site.go 项目: GeoNet/mtr
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
}
示例#23
0
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")
		}
	}

}
示例#24
0
func validate_multi_second_select(dbt *DBTest, rows *sql.Rows) {
	if _, ok := rows.Sibling(); false == ok {
		dbt.Fatal("rows should have a another sibling.")
	}

	if false == rows.Next() {
		dbt.Fatalf("should be one row exists.\n")
	}

	if err := rows.Scan(&id, &fv, &id2); err != nil {
		dbt.Fatalf("should not get error :%s\n", err.Error())
	}

	if 323890472 != id {
		dbt.Fatalf("expect 323890472, but got %d\n", id)
	}

	if math.Abs(42342.43-float64(fv)) > 0.01 {
		dbt.Fatalf("expect 42342.432, but not got %+v\n", fv)
	}

	if rows.Next() {
		dbt.Fatal("rows should not have more than one row.")
	}

	if 298723987 != id2 {
		dbt.Fatalf("expect 298723987, but got %d\n", id2)
	}
}
示例#25
0
文件: field_model.go 项目: GeoNet/mtr
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
}
示例#26
0
// scan a single row of data into a struct.
func (data *structData) scanRow(rows *sql.Rows, dst interface{}, columns []string) error {
	// check if there is data waiting
	if !rows.Next() {
		if err := rows.Err(); err != nil {
			return err
		}
		return sql.ErrNoRows
	}

	// get a list of targets
	targets, err := Targets(dst, columns)
	if err != nil {
		return err
	}

	// perform the scan
	if err := rows.Scan(targets...); err != nil {
		return err
	}

	// post-process and copy the target values into the struct
	if err := WriteTargets(dst, columns, targets); err != nil {
		return err
	}

	return rows.Err()
}
示例#27
0
文件: main.go 项目: pzduniak/db
/*
	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
}
示例#28
0
//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
}
示例#29
0
func populateTechSupports(rows *sql.Rows, ch chan []TechSupport) {
	var t TechSupport
	var ts []TechSupport
	for rows.Next() {
		err := rows.Scan(
			&t.ID,
			&t.VehicleMake,
			&t.VehicleModel,
			&t.VehicleYear,
			&t.PurchaseDate,
			&t.PurchasedFrom,
			&t.DealerName,
			&t.ProductCode,
			&t.DateCode,
			&t.Issue,
			&t.Contact.ID,
			&t.BrandID,
		)
		if err != nil {
			ch <- ts
		}
		ts = append(ts, t)
	}
	defer rows.Close()
	ch <- ts
	return
}
示例#30
0
// ListSecrets returns an iterator function that walks through all secrets in the database.
// The iterator takes an integer argument, which is the maximum number of results to return per iteration.
// If a key name is specified, the results are limited to secrets shared with that key.
func (p *DB) ListSecrets(key *string) func(int) ([]secrets.Secret, error) {
	pos := 0

	return func(n int) (res []secrets.Secret, err error) {
		if err := p.refresh(); err != nil {
			return nil, err
		}

		var rows *sql.Rows

		if key != nil {
			rows, err = p.conn.Table("secrets").Select(
				"secrets.id, secrets.name, secrets.message, secrets.nonce, secrets.pubkey, secrets.key_id").Joins(
				"left join keys on secrets.key_id = keys.id").Where(
				"keys.name = ?", *key).Order("id asc").Limit(n).Offset(pos).Rows()
		} else {
			rows, err = p.conn.Table("secrets").Select("id, name, message, nonce, pubkey, key_id").Order("id asc").Limit(n).Offset(pos).Rows()
		}

		for rows.Next() {
			out := new(secrets.Secret)
			err = rows.Scan(&out.ID, &out.Name, &out.Message, &out.Nonce, &out.Pubkey, &out.KeyID)
			if err != nil {
				return
			}
			res = append(res, *out)
		}
		err = rows.Close()
		pos += len(res)
		return
	}
}