Esempio n. 1
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
}
func DBGetPermissions(dbConn *sql.DB) ([]Permission, error) {
	slice := []Permission{}
	//logit.Info.Println("secdb:GetPermissions: called")
	var rows *sql.Rows
	var err error

	queryStr := fmt.Sprintf("select name, description from secperm order by name")

	rows, err = dbConn.Query(queryStr)

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

	for rows.Next() {
		perm := Permission{}
		perm.Selected = false
		if err = rows.Scan(
			&perm.Name,
			&perm.Description); err != nil {
			return slice, err
		}
		slice = append(slice, perm)
	}
	if err = rows.Err(); err != nil {
		return slice, err
	}
	return slice, nil
}
Esempio n. 3
0
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
}
Esempio n. 4
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()
}
func (s *StoreSqlite) scanUserFromRows(rows *sql.Rows, user *User) error {
	if rows.Err() != nil {
		return rows.Err()
	}
	if user == nil {
		return ErrInvalidUser
	}
	var params []interface{}
	columns, err := rows.Columns()
	if err != nil {
		return err
	}
	for i := range columns {
		col := columns[i]
		switch strings.ToLower(col) {
		case "id":
			params = append(params, &user.UserID)
		case "name":
			params = append(params, &user.Name)
		case "email":
			params = append(params, &user.Email)
		case "key":
			params = append(params, &user.Key)
		}
	}
	return rows.Scan(params...)
}
Esempio n. 6
0
func scanCards(rows *sql.Rows, r router) ([]Card, error) {
	cards := []Card{}

	defer rows.Close()

	for rows.Next() {
		var blob []byte
		var card Card

		if err := rows.Scan(&blob); err != nil {
			return cards, err
		}

		err := json.Unmarshal(blob, &card)

		if err != nil {
			return cards, err
		}

		cards = append(cards, card)
	}
	if err := rows.Err(); err != nil {
		return cards, err
	}
	for i, _ := range cards {
		cards[i].Fill(r)
	}
	return cards, nil
}
Esempio n. 7
0
File: tca.go Progetto: xix19/fabric
func (tca *TCA) getCertificateSets(enrollmentID string) ([]*TCertSet, error) {
	var sets = []*TCertSet{}
	var err error

	var rows *sql.Rows
	rows, err = tca.retrieveCertificateSets(enrollmentID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var enrollID string
	var timestamp int64
	var nonce []byte
	var kdfKey []byte

	for rows.Next() {
		if err = rows.Scan(&enrollID, &timestamp, &nonce, &kdfKey); err != nil {
			return nil, err
		}
		sets = append(sets, &TCertSet{Ts: timestamp, EnrollmentID: enrollID, Key: kdfKey})
	}
	if err = rows.Err(); err != nil {
		return nil, err
	}

	return sets, nil
}
Esempio n. 8
0
File: main.go Progetto: andrebq/exp
func (db *StatsDB) streamRows(result *sql.Rows, out chan Stats) {
	var err error
	defer result.Close()
LOOP:
	for result.Next() && result.Err() == nil {
		var stat Stats
		var info string
		stat.Info = make(map[string]string)
		err = result.Scan(&stat.Id, &stat.System, &stat.SubSystem, &stat.Message, &stat.Context, &stat.ServerTime, &stat.ClientTime, &stat.Error, &info)
		if err != nil {
			printf("error scanning database: %v", err)
			break
		}
		dec := json.NewDecoder(bytes.NewBufferString(info))
		err = dec.Decode(&stat.Info)
		if err != nil {
			printf("error decoding info from record: %v", err)
			break
		}
		select {
		case out <- stat:
		case <-time.After(time.Second * 10):
			break LOOP
		}
	}
	close(out)
}
func GetAllContainers(dbConn *sql.DB) ([]Container, error) {
	var rows *sql.Rows
	var err error
	queryStr := fmt.Sprintf("select c.id, c.name, c.clusterid, c.serverid, c.role, c.image, to_char(c.createdt, 'MM-DD-YYYY HH24:MI:SS'), p.id, p.name, s.name from project p, server s , container c where c.projectid = p.id  and c.serverid = s.id order by c.name")
	logit.Info.Println("admindb:GetAllContainers:" + queryStr)
	rows, err = dbConn.Query(queryStr)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var clustername string
	containers := make([]Container, 0)
	for rows.Next() {
		container := Container{}
		if err = rows.Scan(&container.ID, &container.Name, &container.ClusterID, &container.ServerID, &container.Role, &container.Image, &container.CreateDate, &container.ProjectID, &container.ProjectName, &container.ServerName); err != nil {
			return nil, err
		}

		logit.Info.Println("cluster id is [" + container.ClusterID + "]")
		if container.ClusterID != "-1" {
			clustername, err = GetClusterName(dbConn, container.ClusterID)
			if err != nil {
				logit.Info.Println("admindb:GetAllContainers:error " + err.Error())
				return nil, err
			}
			container.ClusterName = clustername
		}
		containers = append(containers, container)
	}
	if err = rows.Err(); err != nil {
		return nil, err
	}
	return containers, nil
}
Esempio n. 10
0
func GetDbListTemplate(queryMap map[string]string, dbCountFunc DbCountFunc, dbRowsFunc DbRowsFunc, dbListFunc DbListFunc) {

	var rows *sql.Rows
	var err error

	err = dbCountFunc(&queryMap)

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

	// get rows
	rows, err = dbRowsFunc(&queryMap)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	// create list
	for rows.Next() {
		err = dbListFunc(rows)
		if err != nil {
			log.Fatal(err)
		}
	}
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}

}
// GetHealthCheck return the current set of healthcheck metrics that are persisted
func GetHealthCheck(dbConn *sql.DB) ([]types.HealthCheck, error) {
	var rows *sql.Rows
	var err error
	rows, err = dbConn.Query(
		"select ID, ProjectName, ProjectID, ContainerName, ContainerID, " +
			"ContainerRole, ContainerImage, Status, to_char(UpdateDt, 'MM-DD-YYYY HH24:MI:SS') " +
			"from healthcheck order by ProjectName, ContainerName")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var checks []types.HealthCheck
	checks = make([]types.HealthCheck, 0)
	for rows.Next() {
		check := types.HealthCheck{}
		if err = rows.Scan(
			&check.ID,
			&check.ProjectName,
			&check.ProjectID,
			&check.ContainerName,
			&check.ContainerID,
			&check.ContainerRole,
			&check.ContainerImage,
			&check.Status, &check.UpdateDate); err != nil {
			return nil, err
		}

		checks = append(checks, check)
	}
	if err = rows.Err(); err != nil {
		return nil, err
	}
	return checks, nil
}
Esempio n. 12
0
func getPushCount(customerId, tenantId string) int {
	count := 0
	var rows *sql.Rows
	var err error
	//查询customer下的所有租户调用次数
	if tenantId == "*" {
		rows, err = db.MySQL.Query(GET_CUSTOMER_PUSH_COUNT, customerId)
	} else {
		rows, err = db.MySQL.Query(GET_PUSH_COUNT, customerId, tenantId)
	}

	if rows != nil {
		defer rows.Close()
	}

	if err != nil {
		logger.Error(err)
		return count
	}
	if err = rows.Err(); err != nil {
		logger.Error(err)
		return count
	}
	//取出count
	for rows.Next() {
		if err = rows.Scan(&count); err != nil {
			//logger.Error(err)
			return count
		}
		return count
	}
	return count
}
Esempio n. 13
0
func ScanAuthors(rows *sql.Rows) ([]*Author, error) {
	var err error
	var vv []*Author

	var v0 string
	var v1 string
	var v2 string

	for rows.Next() {
		err = rows.Scan(
			&v0,
			&v1,
			&v2,
		)
		if err != nil {
			return vv, err
		}

		v := &Author{}
		v.Name = v0
		v.Email = v1
		v.Username = v2

		vv = append(vv, v)
	}
	return vv, rows.Err()
}
Esempio n. 14
0
func (l *Lib) List(limit, offset int) (pics []*Pic, err error) {
	s := "SELECT id,sum,name,added,taken,orient FROM files ORDER BY taken DESC,added DESC"
	var rows *sql.Rows
	if limit > 0 {
		s += " LIMIT ? OFFSET ?"
		rows, err = l.db.Query(s, limit, offset)
	} else {
		rows, err = l.db.Query(s)
	}

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

	var added, taken int64
	for rows.Next() {
		p := &Pic{lib: l}
		err := rows.Scan(&p.id, &p.Sum, &p.Name, &added, &taken, &p.Orient)
		if err != nil {
			return nil, err
		}
		p.Id = p.id
		p.Taken = time.Unix(taken, 0)
		p.Added = time.Unix(added, 0)
		pics = append(pics, p)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return pics, nil
}
Esempio n. 15
0
// queryInvocations is a common handler for implementing paging over Invocations
func queryInvocations(rows *sql.Rows, pageSize int) (result gohst.Invocations, err error) {
	defer rows.Close()
	var tmp gohst.Invocation
	var tags string
	inc := 0
	if pageSize == 0 {
		inc = -1
	}
	for rows.Next() && inc < pageSize {
		err = rows.Scan(&tmp.Id, &tmp.ExitCode, &tmp.Timestamp,
			&tmp.Host, &tmp.User, &tmp.Shell, &tmp.Directory, &tmp.Command, &tags)
		if err != nil {
			log.Println(err)
			return
		}
		tmp.Tags = strings.Split(tags[1:len(tags)-1], ", ")
		result = append(result, tmp)
		if pageSize > 0 {
			inc++
		}
	}
	err = rows.Err()
	if err != nil {
		log.Println(err)
	}
	return
}
Esempio n. 16
0
File: util.go Progetto: vimdude/db
func (self *t) qlFetchRow(dst interface{}, rows *sql.Rows) error {

	dstv := reflect.ValueOf(dst)

	if dstv.IsNil() || dstv.Kind() != reflect.Ptr {
		return db.ErrExpectingPointer
	}

	item_v := dstv.Elem()

	columns, err := sqlutil.GetRowColumns(rows)

	if err != nil {
		return err
	}

	next := rows.Next()

	if next == false {
		if err = rows.Err(); err != nil {
			return err
		}
		return db.ErrNoMoreRows
	}

	item, err := self.qlFetchResult(item_v.Type(), rows, columns)

	if err != nil {
		return err
	}

	item_v.Set(reflect.Indirect(item))

	return nil
}
Esempio n. 17
0
File: main.go Progetto: andrebq/exp
func (db *StatsDB) streamBuckets(result *sql.Rows, out chan Bucket) {
	var err error
	defer result.Close()
LOOP:
	for result.Next() && result.Err() == nil {
		var bucket Bucket
		var info string
		bucket.Info = make(map[string]interface{})
		err = result.Scan(&bucket.Id, &bucket.ServerTime, &bucket.Bucket, &info)
		if err != nil {
			printf("error scanning database: %v", err)
			break LOOP
		}
		dec := json.NewDecoder(bytes.NewBufferString(info))
		err = dec.Decode(&bucket.Info)
		if err != nil {
			printf("error decoding info from record: %v", err)
			break LOOP
		}
		select {
		case out <- bucket:
		case <-time.After(time.Second * 10):
			break LOOP
		}
	}
	close(out)
}
func GetAllServersByClassByCount(dbConn *sql.DB) ([]Server, error) {
	//select s.id, s.name, s.serverclass, count(n) from server s left join node n on  s.id = n.serverid  group by s.id order by s.serverclass, count(n);

	logit.Info.Println("admindb:GetAllServerByClassByCount:called")
	var rows *sql.Rows
	var err error
	rows, err = dbConn.Query("select s.id, s.name, s.ipaddress, s.dockerbip, s.pgdatapath, s.serverclass, to_char(s.createdt, 'MM-DD-YYYY HH24:MI:SS'), count(n) from server s left join container n on s.id = n.serverid group by s.id  order by s.serverclass, count(n)")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	servers := make([]Server, 0)
	for rows.Next() {
		server := Server{}
		if err = rows.Scan(&server.ID, &server.Name,
			&server.IPAddress, &server.DockerBridgeIP, &server.PGDataPath, &server.ServerClass, &server.CreateDate, &server.NodeCount); err != nil {
			return nil, err
		}
		servers = append(servers, server)
	}
	if err = rows.Err(); err != nil {
		return nil, err
	}
	return servers, nil
}
Esempio n. 19
0
File: models.go Progetto: moshee/gas
// Recursively populate dest with the data from rows, using t as a template to
// generate a flat slice of destinations to rows.Scan into. After that, the
// values from the flat slice will be recursively copied into dest by doing a
// linear search through the slice, matching against the current row's primary
// key, appending new values to dest, its children's children, etc. as needed.
//
// TODO: use iterative or something instead of like 4 different recursive
// functions
func queryJoinSlice(t reflect.Type, dest interface{}, rows *sql.Rows) error {
	dests, idIndexes, err := getDests(t)
	if err != nil {
		return err
	}
	//dump(dests)

	columns, err := rows.Columns()
	if err != nil {
		return err
	}

	dv := reflect.ValueOf(dest)

	//dump(dests)
	for rows.Next() {
		if err = rows.Scan(dests...); err != nil {
			return err
		}
		//dump(dests)
		err = insertIntoTree(dv, dests, idIndexes, columns)
		if err != nil {
			return err
		}
		if err = rows.Err(); err != nil {
			return err
		}
	}

	return nil
}
func GetAllSettingsMap(dbConn *sql.DB) (map[string]string, error) {
	logit.Info.Println("admindb:GetAllSettingsMap: called")
	m := make(map[string]string)

	var rows *sql.Rows
	var err error
	rows, err = dbConn.Query("select name, value, to_char(updatedt, 'MM-DD-YYYY HH24:MI:SS') from settings order by name")
	if err != nil {
		return m, err
	}
	defer rows.Close()
	//settings := make([]Setting, 0)
	for rows.Next() {
		setting := Setting{}
		if err = rows.Scan(
			&setting.Name,
			&setting.Value,
			&setting.UpdateDate); err != nil {
			return m, err
		}
		m[setting.Name] = setting.Value
		//settings = append(settings, setting)
	}
	if err = rows.Err(); err != nil {
		return m, err
	}
	return m, nil
}
Esempio n. 21
0
func (c *Connection) getSchemaColumns(schema string, table string) ([]*SchemaColumn, error) {
	var rows *sql.Rows
	var err error
	if rows, err = c.ctrDB.Query(`
		SELECT
			COLUMN_NAME, COLLATION_NAME, CHARACTER_SET_NAME,
			COLUMN_COMMENT, COLUMN_TYPE, COLUMN_KEY
		FROM
			COLUMNS
		WHERE
			TABLE_SCHEMA = ? AND TABLE_NAME = ?`, schema, table); err != nil {
		return nil, err
	}

	defer rows.Close()

	var cols []*SchemaColumn
	for rows.Next() {
		col := &SchemaColumn{}
		if err = rows.Scan(&col.COLUMN_NAME, &col.COLLATION_NAME, &col.CHARACTER_SET_NAME, &col.COLUMN_COMMENT,
			&col.COLUMN_TYPE, &col.COLUMN_KEY); err != nil {
			return nil, err
		}

		cols = append(cols, col)
	}

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

	return cols, nil
}
func GetContainerUser(dbConn *sql.DB, containername string, usename string) (ContainerUser, error) {
	var rows *sql.Rows
	var user ContainerUser
	var err error
	queryStr := fmt.Sprintf("select id, passwd, to_char(updatedt, 'MM-DD-YYYY HH24:MI:SS') from containeruser where usename = '%s' and containername = '%s'", usename, containername)
	logit.Info.Println("admindb:GetContainerUser:" + queryStr)
	rows, err = dbConn.Query(queryStr)
	if err != nil {
		return user, err
	}
	defer rows.Close()
	for rows.Next() {
		user.Rolname = usename
		user.Containername = containername
		if err = rows.Scan(&user.ID, &user.Passwd, &user.UpdateDate); err != nil {
			return user, err
		}
	}
	if err = rows.Err(); err != nil {
		return user, err
	}
	var unencrypted string
	unencrypted, err = sec.DecryptPassword(user.Passwd)
	if err != nil {
		return user, err
	}
	user.Passwd = unencrypted
	return user, nil
}
Esempio n. 23
0
// 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
}
Esempio n. 24
0
// Queries the database for sensors and transforms them
// to struct format
func getSensorsFromDb(sensor_ids []uint64) ([]Sensor, error) {
	// Select all sensors
	var rows *sql.Rows
	var err error
	if sensor_ids == nil {
		rows, err = DB.Query("SELECT * FROM sensors LIMIT 50")
	} else if len(sensor_ids) == 1 {
		rows, err = DB.Query("SELECT * FROM sensors WHERE id=$1", sensor_ids[0])
	} else {
		sql := "SELECT * FROM sensors WHERE id in (?" + strings.Repeat(",?", len(sensor_ids)-1) + ")"
		rows, err = DB.Query(sql, sensor_ids)
	}
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	var sensors []Sensor
	for rows.Next() {
		var sensor Sensor
		err := rows.Scan(&(sensor.Id), &(sensor.Type), &(sensor.Name), &(sensor.CreatedAt), &(sensor.UpdatedAt))
		if err != nil {
			fmt.Println(err)
			continue
		}
		sensors = append(sensors, sensor)
	}
	if err := rows.Err(); err != nil {
		fmt.Println(err)
	}

	return sensors, err
}
Esempio n. 25
0
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
}
Esempio n. 26
0
func rows2MapsArray(rows *sql.Rows) (maps []map[string]interface{}, err error) {
	cols, err := rows.Columns()
	if err != nil {
		return nil, err
	}
	vals := make([]interface{}, len(cols)) // values
	ptrs := make([]interface{}, len(cols)) // Pointers to values
	for i := range vals {
		ptrs[i] = &vals[i] // Initialize pointer
	}

	maps = []map[string]interface{}{}
	for rows.Next() {
		if err := rows.Scan(ptrs...); err != nil { // Scan will fill in 'vals' using 'ptrs'
			return nil, err
		}
		job := map[string]interface{}{}
		for i, col := range cols {
			if b, isBytes := vals[i].([]byte); isBytes {
				job[col] = string(b) // Convert []byte to string. No one wants []byte values.
			} else {
				job[col] = vals[i]
			}
		}
		maps = append(maps, job)
	}
	if err = rows.Err(); err != nil {
		return nil, err
	}
	return maps, nil
}
Esempio n. 27
0
func TestLongData(t *testing.T) {
	runTests(t, dsn, func(dbt *DBTest) {
		var maxAllowedPacketSize int
		err := dbt.db.QueryRow("select @@max_allowed_packet").Scan(&maxAllowedPacketSize)
		if err != nil {
			dbt.Fatal(err)
		}
		maxAllowedPacketSize--

		// don't get too ambitious
		if maxAllowedPacketSize > 1<<25 {
			maxAllowedPacketSize = 1 << 25
		}

		dbt.mustExec("CREATE TABLE test (value LONGBLOB)")

		in := strings.Repeat(`a`, maxAllowedPacketSize+1)
		var out string
		var rows *sql.Rows

		// Long text data
		const nonDataQueryLen = 28 // length query w/o value
		inS := in[:maxAllowedPacketSize-nonDataQueryLen]
		dbt.mustExec("INSERT INTO test VALUES('" + inS + "')")
		rows = dbt.mustQuery("SELECT value FROM test")
		if rows.Next() {
			rows.Scan(&out)
			if inS != out {
				dbt.Fatalf("LONGBLOB: length in: %d, length out: %d", len(inS), len(out))
			}
			if rows.Next() {
				dbt.Error("LONGBLOB: unexpexted row")
			}
		} else {
			dbt.Fatalf("LONGBLOB: no data")
		}

		// Empty table
		dbt.mustExec("TRUNCATE TABLE test")

		// Long binary data
		dbt.mustExec("INSERT INTO test VALUES(?)", in)
		rows = dbt.mustQuery("SELECT value FROM test WHERE 1=?", 1)
		if rows.Next() {
			rows.Scan(&out)
			if in != out {
				dbt.Fatalf("LONGBLOB: length in: %d, length out: %d", len(in), len(out))
			}
			if rows.Next() {
				dbt.Error("LONGBLOB: unexpexted row")
			}
		} else {
			if err = rows.Err(); err != nil {
				dbt.Fatalf("LONGBLOB: no data (err: %s)", err.Error())
			} else {
				dbt.Fatal("LONGBLOB: no data (err: <nil>)")
			}
		}
	})
}
Esempio n. 28
0
func readAll(t *testing.T, rows *sql.Rows) [][]string {
	cols, err := rows.Columns()
	if err != nil {
		t.Fatal(err)
	}
	var results [][]string
	results = append(results, cols)

	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
}
Esempio n. 29
0
func ScanUsers(rs *sql.Rows) ([]User, error) {
	log.Info("ScanUsers Id 000")
	structs := make([]User, 0, 16)
	log.Info("ScanUsers Id 111")
	var err error
	for rs.Next() {
		log.Info("ScanUsers Id 3333")
		var s User
		// var s = new(User)
		if err = rs.Scan(
			&s.Id,
			&s.Idp_user_id,
			&s.Name,
			&s.Last_updated,
			&s.Status,
			&s.User_attributes,
		); err != nil {
			continue
		}
		if err == nil {
			log.Info("ScanUsers Id 111") // + string(s.Id))
			structs = append(structs, s)
		}
	}
	if err = rs.Err(); err != nil {
		return nil, err
	}
	return structs, nil
}
Esempio n. 30
0
File: index.go Progetto: zqzca/back
func pagination(ex db.Executor, page int, perPage int) (*[]dashboardEntry, error) {
	var entries []dashboardEntry
	var err error
	var rows *sql.Rows

	offset := perPage * page

	if rows, err = ex.Query(paginationSQL, offset, perPage); err != nil {
		return &entries, err
	}
	defer rows.Close()

	for rows.Next() {
		var e dashboardEntry

		err = rows.Scan(
			&e.Name, &e.ThumbnailID, &e.Slug, &e.CreatedAt,
		)

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

		entries = append(entries, e)
	}

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

	return &entries, err
}