예제 #1
0
/**
 * SetInc
 * @param  fieldname string
 * @param  value int
 * @return rows,error
 */
func (this *Sql) SetInc(field string, value int) (int64, error) {
	sqlstr := " UPDATE " + this.tableName + " "
	sqlstr += " SET "
	field_filted := this.convertValue2String(field)
	sqlstr += field_filted + " = " + field_filted + " + " + this.convertValue2String(value)
	sqlstr += " WHERE "
	sqlstr += this.conditionSql
	//slimSqlLog("SETINC", sqlstr)
	var r sql.Result
	var err error
	if this.tx != nil {
		r, err = this.tx.Exec(sqlstr)
	} else {
		r, err = this.getDbW().Exec(sqlstr)
	}
	if err != nil {
		slimSqlLog("ERROR", sqlstr)
		return 0, err
	} else {
		num, err := r.RowsAffected()
		if err != nil {
			return 0, err
		} else {
			return num, nil
		}
	}
}
예제 #2
0
func NewOrUpdateUser(db *sql.DB, user *User) error {
	var err error
	var res sql.Result
	if user.Id == "" {
		res, err = db.Exec("INSERT INTO users(firstName, lastName) VALUES(?,?)", user.FirstName, user.LastName)
	} else {
		res, err = db.Exec("UPDATE users SET firstName=?, lastName=? WHERE id=?", user.FirstName, user.LastName, user.Id)
	}
	if err != nil {
		return err
	}
	lastId, err := res.LastInsertId()
	if err != nil {
		return err
	}
	rowCnt, err := res.RowsAffected()
	if err != nil {
		return err
	}
	if rowCnt != 1 {
		return errors.New(fmt.Sprintf("Row count (%s) and/or lastId (%s) are wrong.", lastId, rowCnt))
	}

	return nil
}
예제 #3
0
파일: db.go 프로젝트: ying32/YingBlog
/* **
执行更新操作
param1 表名
param2 柱头
parma3 条件
param4 参数
return 影响行数,错误
** */
func (self *MDB) execUpdate(tableName, cols, condition string, args ...interface{}) (int64, error) {
	tx, err := self.Begin()
	if err != nil {
		return 0, err
	}
	if condition == "" || len(args) == 0 {
		return 0, errors.New("条件和参数都不能为空!")
	}
	stmt, err := tx.Prepare(fmt.Sprintf("UPDATE %s SET %s WHERE %s", tableName, cols, condition))
	if err != nil {
		return 0, err
	}
	var result sql.Result
	if result, err = stmt.Exec(args...); err != nil {
		return 0, err
	}
	defer stmt.Close()
	if err = tx.Commit(); err != nil {
		return 0, err
	}
	if affected, err := result.RowsAffected(); err != nil {
		return 0, err
	} else {
		return affected, nil
	}
}
예제 #4
0
파일: mysql.go 프로젝트: lucmichalski/fae
func (this *mysql) Exec(query string, args ...interface{}) (afftectedRows int64,
	lastInsertId int64, err error) {
	if this.db == nil {
		return 0, 0, ErrNotOpen
	}
	if this.breaker.Open() {
		return 0, 0, ErrCircuitOpen
	}

	var result sql.Result
	result, err = this.db.Exec(query, args...)
	if err != nil {
		if this.isSystemError(err) {
			log.Warn("mysql exec breaks: %s", err.Error())
			this.breaker.Fail()
		}

		return 0, 0, err
	}

	afftectedRows, err = result.RowsAffected()
	if err != nil {
		if this.isSystemError(err) {
			log.Warn("mysql exec2 breaks: %s", err.Error())
			this.breaker.Fail()
		}
	} else {
		this.breaker.Succeed()
	}

	lastInsertId, _ = result.LastInsertId()
	return
}
예제 #5
0
//Update ...
func (vs VictualService) Update(victual *Victual) *Victual {
	db, err := sql.Open("postgres", "host=localhost port=5432 user=pober dbname=pober sslmode=disable")
	checkErr(err)
	defer db.Close()

	var statement *sql.Stmt
	statement, err = db.Prepare("UPDATE dc.victual SET description = $1, brand = $2, source = $3, energyCal = $4, energyJoule = $5, fat = $6, saturatedFat = $7, carbohydrates = $8, sugars = $9, protein = $10, salt = $11, fiber = $12, barCode = $13, weightVolumeRatio = $14 WHERE ID = $1")
	checkErr(err)

	var result sql.Result
	result, err = statement.Exec(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)
	var rowsAffected int64
	rowsAffected, err = result.RowsAffected()
	checkErr(err)
	statement.Close()
	if rowsAffected == 1 {
		return victual
	}
	return nil
}
예제 #6
0
파일: generics.go 프로젝트: 0xbadjuju/beam
func check_result(result sql.Result) {
	rows, err := result.RowsAffected()
	check_error(err)
	if rows == 0 {
		fmt.Printf("No rows affected by query")
	}
}
예제 #7
0
파일: query.go 프로젝트: Zocprint/go301
func (database *Database) CreateTables(tableConf *TableConf) {
	db, err := sql.Open(database.Driver, database.dataSource)
	if err != nil {
		panic(err)
	}
	var result sql.Result

	var auto_increment_syntax = "INT AUTO INCREMENT "
	if database.IsPostgres() {
		auto_increment_syntax = "SERIAL "
	}
	fmt.Printf("creating table '%s'... \n", tableConf.Name)
	query := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (id %s PRIMARY KEY, %s varchar(255), %s varchar(255), created_at timestamp DEFAULT CURRENT_TIMESTAMP, updated_at timestamp DEFAULT CURRENT_TIMESTAMP)", tableConf.Name, auto_increment_syntax, tableConf.Hash, tableConf.Url)
	result, err = db.Exec(query)
	if err != nil {
		panic(err)
	}
	result.RowsAffected()

	fmt.Printf("creating table 'goahead_statistics'... \n")
	query = fmt.Sprintf("CREATE TABLE IF NOT EXISTS goahead_statistics (id %s PRIMARY KEY, created_at timestamp DEFAULT CURRENT_TIMESTAMP)", auto_increment_syntax)
	result, err = db.Exec(query)
	if err != nil {
		panic(err)
	}
	result.RowsAffected()
}
예제 #8
0
파일: db.go 프로젝트: colefan/myorm
func (d *DBAlias) BatchExec(sqlbuf string, argsv [][]interface{}) (affectedRows int64, err error) {
	var result sql.Result
	if argsv == nil || len(argsv) == 0 {
		result, err = d.db.Exec(sqlbuf)
		if err == nil {
			affectedRows, err = result.RowsAffected()
		}
		return
	} else {
		var stmt *sql.Stmt
		stmt, err = d.db.Prepare(sqlbuf)
		if err != nil {
			return
		}

		defer stmt.Close()
		affectedRows = 0
		for i, _ := range argsv {
			r, err1 := stmt.Exec(argsv[i]...)
			if err1 != nil {
				err = err1
				return
			}
			num, _ := r.RowsAffected()
			affectedRows += num
		}

	}

	return

}
예제 #9
0
func (this *tableMap) Update2(exec SQLExecutor, where string, data map[string]string, except []string) (rows int64, err error) {
	dialect := this.dbmap.dialect
	updSQL := dialect.UpdateSQL(this.schemaName, this.tableName)
	//
	L := len(data)
	setFields := make([]string, L)
	quote := ""
	noQuotes := array2dict(except)
	var i int
	for key, val := range data {
		if _, ok := noQuotes[key]; ok {
			quote = ""
		} else {
			quote = "'"
		}
		setFields[i] = fmt.Sprintf("%s = %s%s%s", dialect.QuoteField(key), quote, val, quote)
		i++
	}
	//
	query := fmt.Sprintf(updSQL, strings.Join(setFields, ", "), setWhere(where))
	if exec == nil {
		exec = this
	}
	var res sql.Result
	if res, err = exec.Exec(query); err == nil {
		rows, err = res.RowsAffected()
	}
	return
}
예제 #10
0
func (this *tableMap) update(vptr reflect.Value, exec SQLExecutor, execVal []reflect.Value) (rows int64, err error) {
	var (
		bind *bindObj
		res  sql.Result
	)
	if err = triggerRun("PreUpdate", vptr, execVal); err != nil {
		return
	}
	if bind, err = this.bindUpdate(); err != nil {
		return
	}
	if err = bind.bindArgs(vptr.Elem()); err != nil {
		return
	}
	if res, err = exec.Exec(bind.query, bind.argValues...); err != nil {
		return
	}
	if rows, err = res.RowsAffected(); err != nil {
		return
	}
	if err = triggerRun("PostUpdate", vptr, execVal); err != nil {
		return
	}
	return
}
예제 #11
0
파일: mysql551.go 프로젝트: go51/mysql551
func (m *Mysql) Exec(query string, param ...interface{}) (rowsAffected int64, lastInsertId int64) {
	if !m.IsOpen() {
		panic(errors.New("[mysql555]It is not connected to the host"))
	}

	var res sql.Result = nil
	var err error = nil

	if m.IsTransaction() {
		res, err = m.tx.Exec(query, param...)
	} else {
		res, err = m.db.Exec(query, param...)
	}

	if err != nil {
		message := err.Error()
		message = message + "\n" + "[ SQL ] " + query + "\n" + fmt.Sprintf("[ PRM ] %#v\n", param)
		panic(errors.New(message))
	}

	lastInsertId, err = res.LastInsertId()
	if err != nil {
		panic(err)
	}
	rowsAffected, err = res.RowsAffected()
	if err != nil {
		panic(err)
	}

	return
}
예제 #12
0
func fieldMetricTagPut(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()

	var err error
	var result sql.Result

	if result, err = db.Exec(`INSERT INTO field.metric_tag(devicePK, typePK, tagPK)
				SELECT devicePK, typePK, tagPK
				FROM field.device, field.type, mtr.tag
				WHERE deviceID = $1
				AND typeID = $2
				AND tag = $3`,
		v.Get("deviceID"), v.Get("typeID"), v.Get("tag")); err != nil {
		if err, ok := err.(*pq.Error); ok && err.Code == errorUniqueViolation {
			// ignore unique constraint errors
			return &weft.StatusOK
		} else {
			return weft.InternalServerError(err)
		}
	}

	var i int64
	if i, err = result.RowsAffected(); err != nil {
		return weft.InternalServerError(err)
	}
	if i != 1 {
		return weft.BadRequest("Didn't create row, check your query parameters exist")
	}

	return &weft.StatusOK
}
예제 #13
0
/*
	设置任务状态
*/
func (this *TaskDao) SetTasksStatus(tasks []types.CrawlTask, status TaskStatus) (int64, error) {
	nTasks := len(tasks)
	var affectedRows int64 = 0
	var err = ErrNoTasks
	if nTasks > 0 {
		taskIds := []int32{}
		var result sql.Result
		var args []interface{}
		var sqlStr string
		var now = time.Now()

		for _, task := range tasks {
			taskIds = append(taskIds, task.Id)
		}

		if status == TASK_FINISH {
			sqlStr = fmt.Sprintf("update %s set status=%d, last_crawl_time=%d, crawl_times=crawl_times+1, update_time='%s' where id in (?)", TaskTable, status, now.Unix(), now.Format("2006-01-02 15:04:05"))
		} else {
			sqlStr = fmt.Sprintf("update %s set status=%d, update_time='%s' where id in (?)", TaskTable, status, now.Format("2006-01-02 15:04:05"))
		}

		sqlStr, args, err = sqlx.In(sqlStr, taskIds)
		if err != nil {
			log.Errorln("build sql to set task status failed! sql is ", sqlStr)
		} else {
			result, err = this.db.Exec(sqlStr, args...)
			if err != nil {
				log.Errorln("update tasks status error: ", err)
			}

		}
		affectedRows, _ = result.RowsAffected()
	}
	return affectedRows, err
}
예제 #14
0
파일: user.go 프로젝트: yaolingling/harbor
// ChangeUserPassword ...
func ChangeUserPassword(u models.User, oldPassword ...string) (err error) {
	if len(oldPassword) > 1 {
		return errors.New("Wrong numbers of params.")
	}

	o := GetOrmer()

	var r sql.Result
	if len(oldPassword) == 0 {
		//In some cases, it may no need to check old password, just as Linux change password policies.
		r, err = o.Raw(`update user set password=?, salt=? where user_id=?`, utils.Encrypt(u.Password, u.Salt), u.Salt, u.UserID).Exec()
	} else {
		r, err = o.Raw(`update user set password=?, salt=? where user_id=? and password = ?`, utils.Encrypt(u.Password, u.Salt), u.Salt, u.UserID, utils.Encrypt(oldPassword[0], u.Salt)).Exec()
	}

	if err != nil {
		return err
	}
	c, err := r.RowsAffected()
	if err != nil {
		return err
	}
	if c == 0 {
		return errors.New("No record has been modified, change password failed.")
	}

	return nil
}
예제 #15
0
func (p *TxScope) getAffectedRows(r sql.Result) int64 {
	if count, err := r.RowsAffected(); err != nil {
		panic(err)
	} else {
		return count
	}
}
예제 #16
0
파일: db_raw.go 프로젝트: mysll/flynet
func (this *Database) ExecSql(mailbox rpc.Mailbox, msg *rpc.Message) (errcode int32, reply *rpc.Message) {
	var sqlstr string
	var callback string
	var callbackparams share.DBParams

	if server.Check(server.ParseArgs(msg, &sqlstr, &callback, &callbackparams)) {
		return 0, nil
	}

	sqlconn := db.sql
	var r sql.Result
	var err error

	app := server.GetAppById(mailbox.App)
	if app == nil {
		log.LogError(server.ErrAppNotFound)
		return 0, nil
	}

	if r, err = sqlconn.Exec(sqlstr); err != nil {
		log.LogError("sql:", sqlstr)
		server.Check(app.Call(nil, callback, callbackparams, 0, err.Error()))
		return 0, nil
	}

	eff, _ := r.RowsAffected()
	server.Check(app.Call(nil, callback, callbackparams, eff, ""))
	return 0, nil
}
예제 #17
0
func dataLatencyThresholdPut(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()
	var err error

	var lower, upper int

	if lower, err = strconv.Atoi(v.Get("lower")); err != nil {
		return weft.BadRequest("invalid lower")
	}

	if upper, err = strconv.Atoi(v.Get("upper")); err != nil {
		return weft.BadRequest("invalid upper")
	}

	siteID := v.Get("siteID")
	typeID := v.Get("typeID")

	var result sql.Result

	// TODO Change to upsert 9.5

	// return if insert succeeds
	if result, err = db.Exec(`INSERT INTO data.latency_threshold(sitePK, typePK, lower, upper)
				SELECT sitePK, typePK, $3, $4
				FROM data.site, data.type
				WHERE siteID = $1
				AND typeID = $2`,
		siteID, typeID, lower, upper); err == nil {
		var i int64
		if i, err = result.RowsAffected(); err != nil {
			return weft.InternalServerError(err)
		}
		if i == 1 {
			return &weft.StatusOK
		}
	}

	// return if update one row
	if pqErr, ok := err.(*pq.Error); ok && pqErr.Code == errorUniqueViolation {
		if result, err = db.Exec(`UPDATE data.latency_threshold SET lower=$3, upper=$4
				WHERE sitePK = (SELECT sitePK FROM data.site WHERE siteID = $1)
				AND typePK = (SELECT typePK FROM data.type WHERE typeID = $2)`,
			siteID, typeID, lower, upper); err == nil {
			var i int64
			if i, err = result.RowsAffected(); err != nil {
				return weft.InternalServerError(err)
			}
			if i == 1 {
				return &weft.StatusOK
			}
		}
	}

	if err == nil {
		err = fmt.Errorf("no rows affected, check your query.")
	}

	return weft.InternalServerError(err)
}
예제 #18
0
func checkResult(c *C, r sql.Result, affectedRows int64, insertID int64) {
	gotRows, err := r.RowsAffected()
	c.Assert(err, IsNil)
	c.Assert(gotRows, Equals, affectedRows)

	gotID, err := r.LastInsertId()
	c.Assert(err, IsNil)
	c.Assert(gotID, Equals, insertID)
}
예제 #19
0
파일: db_raw.go 프로젝트: mysll/flynet
func (this *Database) UpdateRow(mailbox rpc.Mailbox, msg *rpc.Message) (errcode int32, reply *rpc.Message) {
	var tbl string
	var values map[string]interface{}
	var condition string
	var callback string
	var callbackparams share.DBParams

	if server.Check(server.ParseArgs(msg, &tbl, &values, &condition, &callback, &callbackparams)) {
		return 0, nil
	}

	sqlconn := db.sql
	var r sql.Result
	var err error

	app := server.GetAppById(mailbox.App)
	if app == nil {
		log.LogError(server.ErrAppNotFound)
		return 0, nil
	}

	if condition != "" {
		condition = fmt.Sprintf("WHERE %s", condition)
	}

	args := make([]interface{}, 0, len(values))
	var sql bytes.Buffer
	sql.WriteString("UPDATE `")
	sql.WriteString(tbl)
	sql.WriteString("` SET")
	split := " "
	for k, v := range values {
		sql.WriteString(split)
		split = ", "
		sql.WriteString("`")
		sql.WriteString(k)
		sql.WriteString("`")
		sql.WriteString("=?")
		args = append(args, v)
	}
	sqlstr := fmt.Sprintf("%s %s", sql.String(), condition)
	if r, err = sqlconn.Exec(sqlstr, args...); err != nil {
		log.LogError("sql:", sqlstr)
		if callback == "_" {
			log.LogError(err)
			return 0, nil
		}
		server.Check(app.Call(nil, callback, callbackparams, 0, err.Error()))
		return 0, nil
	}
	if callback == "_" {
		return 0, nil
	}
	eff, _ := r.RowsAffected()
	server.Check(app.Call(nil, callback, callbackparams, eff, ""))
	return 0, nil
}
예제 #20
0
파일: params.go 프로젝트: hujunlong/orm
func (self *Params) Save() (bool, int64, error) {
	db, query := self.getWriteConnect()
	defer func() {
		self.set = self.set[len(self.set):]
	}()
	var err error
	var stmt *sql.Stmt
	var res sql.Result
	//var n int64
	//if n , err= self.Count();err == nil && n >0
	if self.hasRow {
		sqls, val := query.Update()
		if OpenSyncUpdate {
			sqls = strings.Replace(sqls, "?", "%v", -1)
			sqls = fmt.Sprintf(sqls, val...)
			SqlSyncHook <- sqls
			return false, 0, nil
		} else {
			if debug_sql {
				Debug.Println("save update ", sqls, val)
			}
			stmt, err = db.Prepare(sqls)
			if err == nil {
				defer stmt.Close()
			} else {
				return false, 0, err
			}
			res, err = stmt.Exec(val...)

			if err != nil {
				return false, 0, err
			}
			a, b := res.RowsAffected()
			return false, a, b
		}
	} else {
		sqls, val := query.Insert()
		if debug_sql {
			Debug.Println("save insert ", sqls, val)
		}
		stmt, err = db.Prepare(sqls)
		if err == nil {
			defer stmt.Close()
		} else {
			return false, 0, err
		}
		res, err = stmt.Exec(val...)
		if err != nil {
			return true, 0, err
		}
		a, b := res.LastInsertId()
		self.hasRow = true
		return true, a, b
	}

}
예제 #21
0
파일: named.go 프로젝트: Xackery/eqcleanup
func Clean(args ...string) (err error) {
	db, err := eqdb.Load()
	if err != nil {
		return
	}

	spawns := []Spawndata{
		{Npcid: 37082, Spawngroupid: 2096, Chance: 5},                            //Arthikus was 50
		{Npcid: 35160, Spawngroupid: 4748, Chance: 5},                            //Ghoul of TakishHiz was 20
		{Npcid: 37121, Spawngroupid: 3271, Chance: 5},                            //A sand giant was 50
		{Npcid: 37121, Spawngroupid: 3376, Chance: 5},                            //A sand giant was 50
		{Npcid: 37157, Spawngroupid: 2095, Chance: 5},                            //cazel was 50
		{Npcid: 22187, Spawngroupid: 788, Chance: 5},                             //a griffon was 50
		{Npcid: 22187, Spawngroupid: 792, Chance: 5},                             //a griffon was 50
		{Npcid: 92159, Spawngroupid: 9825, Chance: 5},                            //Overseer_Miklek was 34%
		{Npcid: 110100, Spawngroupid: 16400, Mindelay: 50000, Despawntimer: 100}, //Stormfeather

	}

	totalRemoved := int64(0)

	for _, spawn := range spawns {
		var result sql.Result
		if spawn.Chance > 0 {
			result, err = db.Exec("UPDATE spawnentry SET chance = ? WHERE npcid = ? AND spawngroupid = ?", spawn.Chance, spawn.Npcid, spawn.Spawngroupid)
			if err != nil {
				fmt.Println("Err updating spawngroup:", err.Error())
				return
			}
			var affect int64
			affect, err = result.RowsAffected()
			if err != nil {
				fmt.Println("Error getting rows affected for", focus, err.Error())
				return
			}
			totalRemoved += affect
		}
		if spawn.Mindelay > 0 && spawn.Despawntimer > 0 {
			result, err = db.Exec("UPDATE spawngroup SET mindelay = ?, despawn_timer = ? WHERE npcid = ? AND spawngroupid = ?", spawn.Mindelay, spawn.Despawntimer, spawn.Npcid, spawn.Spawngroupid)
			if err != nil {
				fmt.Println("Err updating spawngroup:", err.Error())
				return
			}
			var affect int64
			affect, err = result.RowsAffected()
			if err != nil {
				fmt.Println("Error getting rows affected for", focus, err.Error())
				return
			}
			totalRemoved += affect
		}
	}
	fmt.Println("Updated", totalRemoved, " DB entries related to", focus, "in spawnentry and spawngroup successfully.")

	return
}
예제 #22
0
파일: feeds.go 프로젝트: vincentcr/myfeeds
func checkRowsAffected(res sql.Result, expected int64) error {
	actual, err := res.RowsAffected()
	if err != nil {
		return fmt.Errorf("Could not check rows affected: %v", err)
	}
	if actual != expected {
		return fmt.Errorf("Unexpected result: expected %v, got %v", expected, actual)
	}
	return nil
}
예제 #23
0
파일: db.go 프로젝트: postfix/gipam
func mustHaveChanged(res sql.Result) error {
	n, err := res.RowsAffected()
	if err != nil {
		return err
	}
	if n == 0 {
		return ErrNotFound
	}
	return nil
}
예제 #24
0
파일: model.go 프로젝트: mpdroog/radiusd
func affectCheck(res sql.Result, expect int64, errMsg error) error {
	affect, e := res.RowsAffected()
	if e != nil {
		return e
	}
	if affect != expect {
		return errMsg
	}
	return nil
}
예제 #25
0
파일: field_device.go 프로젝트: GeoNet/mtr
func fieldDevicePut(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()

	var err error
	var latitude, longitude float64

	if latitude, err = strconv.ParseFloat(v.Get("latitude"), 64); err != nil {
		return weft.BadRequest("latitude invalid")
	}

	if longitude, err = strconv.ParseFloat(v.Get("longitude"), 64); err != nil {
		return weft.BadRequest("longitude invalid")
	}

	var result sql.Result

	// TODO - use upsert with PG 9.5?

	// return if insert succeeds
	if result, err = db.Exec(`INSERT INTO field.device(deviceID, modelPK, latitude, longitude)
				SELECT $1, modelPK, $3, $4
				FROM field.model
				WHERE modelID = $2`,
		v.Get("deviceID"), v.Get("modelID"), latitude, longitude); err == nil {
		var i int64
		if i, err = result.RowsAffected(); err != nil {
			return weft.InternalServerError(err)
		}
		if i == 1 {
			return &weft.StatusOK
		}
	}

	// return if update one row
	if pqErr, ok := err.(*pq.Error); ok && pqErr.Code == errorUniqueViolation {
		if result, err = db.Exec(`UPDATE field.device
					SET latitude = $2, longitude = $3
					WHERE deviceID = $1`,
			v.Get("deviceID"), latitude, longitude); err == nil {
			var i int64
			if i, err = result.RowsAffected(); err != nil {
				return weft.InternalServerError(err)
			}
			if i == 1 {
				return &weft.StatusOK
			}
		}
	}

	if err == nil {
		err = fmt.Errorf("no rows affected, check your query.")
	}

	return weft.InternalServerError(err)
}
예제 #26
0
파일: main.go 프로젝트: mattn/go-sqlite3
func resultDoCheck(result sql.Result, callerDescr string, callIndex int) {
	lastID, err := result.LastInsertId()
	if err != nil {
		log.Panic(err)
	}
	nAffected, err := result.RowsAffected()
	if err != nil {
		log.Panic(err)
	}

	log.Printf("Exec result for %s (%d): ID = %d, affected = %d\n", callerDescr, callIndex, lastID, nAffected)
}
예제 #27
0
파일: data_site.go 프로젝트: GeoNet/mtr
func dataSitePut(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()

	siteID := v.Get("siteID")

	var err error
	var latitude, longitude float64

	if latitude, err = strconv.ParseFloat(v.Get("latitude"), 64); err != nil {
		return weft.BadRequest("latitude invalid")
	}

	if longitude, err = strconv.ParseFloat(v.Get("longitude"), 64); err != nil {
		return weft.BadRequest("longitude invalid")
	}

	var result sql.Result

	// TODO - use upsert with PG 9.5?

	// return if insert succeeds
	if result, err = db.Exec(`INSERT INTO data.site(siteID, latitude, longitude) VALUES($1, $2, $3)`,
		siteID, latitude, longitude); err == nil {
		var i int64
		if i, err = result.RowsAffected(); err != nil {
			return weft.InternalServerError(err)
		}
		if i == 1 {
			return &weft.StatusOK
		}
	}

	// return if update one row
	if pqErr, ok := err.(*pq.Error); ok && pqErr.Code == errorUniqueViolation {
		if result, err = db.Exec(`UPDATE data.site SET latitude=$2, longitude=$3 where siteID=$1`,
			siteID, latitude, longitude); err == nil {
			var i int64
			if i, err = result.RowsAffected(); err != nil {
				return weft.InternalServerError(err)
			}
			if i == 1 {
				return &weft.StatusOK
			}
		}
	}

	if err == nil {
		err = fmt.Errorf("no rows affected, check your query.")
	}

	return weft.InternalServerError(err)
}
예제 #28
0
파일: db.go 프로젝트: carriercomm/repbin
func updateConvertNilError(res sql.Result, err error) error {
	if err != nil {
		return err
	}
	n, err := res.RowsAffected()
	if err != nil {
		return err
	}
	if n < 1 {
		return ErrNoModify
	}
	return nil
}
예제 #29
0
파일: field_state.go 프로젝트: GeoNet/mtr
func fieldStatePut(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	q := r.URL.Query()
	deviceID := q.Get("deviceID")
	typeID := q.Get("typeID")

	var err error
	var value bool
	if value, err = strconv.ParseBool(q.Get("value")); err != nil {
		return weft.BadRequest("invalid value")
	}

	var t time.Time
	if t, err = time.Parse(time.RFC3339, q.Get("time")); err != nil {
		return weft.BadRequest("invalid time")
	}

	var result sql.Result
	if result, err = db.Exec(`UPDATE field.state SET
				time = $3, value = $4
				WHERE devicePK = (SELECT devicePK from field.device WHERE deviceID = $1)
				AND typePK = (SELECT typePK from field.state_type WHERE typeID = $2)`,
		deviceID, typeID, t, value); err != nil {
		return weft.InternalServerError(err)
	}

	// If no rows change either the values are old or it's the first time we've seen this metric.
	var u int64
	if u, err = result.RowsAffected(); err != nil {
		return weft.InternalServerError(err)
	}

	if u == 1 {
		return &weft.StatusOK
	} else if result, err = db.Exec(`INSERT INTO field.state(devicePK, typePK, time, value)
					SELECT devicePK, typePK, $3, $4
					FROM field.device, field.state_type
					WHERE deviceID = $1
					AND typeID = $2`,
		deviceID, typeID, t, value); err == nil {

		var i int64
		if i, err = result.RowsAffected(); err != nil {
			return weft.InternalServerError(err)
		}
		if i == 1 {
			return &weft.StatusOK
		}
	}

	return weft.InternalServerError(err)
}
예제 #30
0
파일: attempt.go 프로젝트: dmaze/goordinate
// expireAttempts finds all attempts whose expiration time has passed
// and expires them.  It runs on all attempts for all work units in all
// work specs in all namespaces (which simplifies the query).  Expired
// attempts' statuses become "expired", and those attempts cease to be
// the active attempt for their corresponding work unit.
//
// In general this should be called in its own transaction and its error
// return ignored:
//
//     _ = withTx(self, func(tx *sql.Tx) error {
//              return expireAttempts(self, tx)
//     })
//
// Expiry is generally secondary to whatever actual work is going on.
// If a result is different because of expiry, pretend the relevant
// call was made a second earlier or later.  If this fails, then
// either there is a concurrency issue (and since the query is
// system-global, the other expirer will clean up for us) or there is
// an operational error (and the caller will fail afterwards).
func expireAttempts(c coordinable, tx *sql.Tx) error {
	// There are several places this is called with much smaller
	// scope.  For instance, Attempt.Status() needs to invoke
	// expiry but only actually cares about this very specific
	// attempt.  If there are multiple namespaces,
	// Worker.RequestAttempts() only cares about this namespace
	// (though it will run on all work specs).  It may help system
	// performance to try to run this with narrower scope.
	//
	// This is probably also an excellent candidate for a stored
	// procedure.
	var (
		now        time.Time
		cte, query string
		count      int64
		result     sql.Result
		err        error
	)

	now = c.Coordinate().clock.Now()

	// Remove expiring attempts from their work unit
	cte = buildSelect([]string{attemptID},
		[]string{attemptTable},
		[]string{attemptIsPending, attemptIsExpired}) // $1 = "now"
	cte += " FOR UPDATE"
	query = buildUpdate(workUnitTable,
		[]string{"active_attempt_id=NULL"},
		[]string{"active_attempt_id IN (" + cte + ")"})
	result, err = tx.Exec(query, now)
	if err != nil {
		return err
	}

	// If this marked nothing as expired, we're done
	count, err = result.RowsAffected()
	if err != nil {
		return err
	}
	if count == 0 {
		return nil
	}

	// Mark attempts as expired
	query = buildUpdate(attemptTable,
		[]string{"expiration_time=$1", "status='expired'"},
		[]string{attemptIsPending, attemptIsExpired})
	_, err = tx.Exec(query, now)
	return err
}