Example #1
0
func (ø *db) DeletePackage(pkgPath string) (err error) {
	var tx *sql.Tx
	defer func() {
		if err != nil && tx != nil {
			tx.Rollback()
		}
	}()
	tx, err = ø.Begin()
	if err != nil {
		return
	}
	err = _deleteExports(pkgPath, tx)
	if err != nil {
		return
	}
	err = _deleteImports(pkgPath, tx)
	if err != nil {
		return
	}

	err = _deletePackage(pkgPath, tx)
	if err != nil {
		return
	}
	tx.Commit()
	fmt.Printf("deleted: %s\n", pkgPath)
	return
}
Example #2
0
func fieldMetricDelete(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()

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

	var err error
	var txn *sql.Tx

	if txn, err = db.Begin(); err != nil {
		return weft.InternalServerError(err)
	}

	for _, table := range []string{"field.metric", "field.metric_summary", "field.metric_tag", "field.threshold"} {
		if _, err = txn.Exec(`DELETE FROM `+table+` WHERE
				devicePK = (SELECT devicePK FROM field.device WHERE deviceID = $1)
				 AND typePK = (SELECT typePK from field.type WHERE typeID = $2)`,
			deviceID, typeID); err != nil {
			txn.Rollback()
			return weft.InternalServerError(err)
		}
	}

	if err = txn.Commit(); err != nil {
		return weft.InternalServerError(err)
	}

	return &weft.StatusOK
}
Example #3
0
func (self *Source) doExec(terms ...interface{}) (res sql.Result, err error) {
	var tx *sql.Tx

	if self.session == nil {
		return nil, db.ErrNotConnected
	}

	chunks := sqlCompile(terms)

	query := strings.Join(chunks.Query, ` `)

	for i := 0; i < len(chunks.Args); i++ {
		query = strings.Replace(query, `?`, fmt.Sprintf(`$%d`, i+1), 1)
	}

	if debugEnabled() == true {
		debugLogQuery(query, chunks)
	}

	if tx, err = self.session.Begin(); err != nil {
		return nil, err
	}

	if res, err = tx.Exec(query, chunks.Args...); err != nil {
		return nil, err
	}

	if err = tx.Commit(); err != nil {
		return nil, err
	}

	return res, nil
}
// Benchmarking raw database/sql.
func BenchmarkAppendTxRawSQL(b *testing.B) {
	var err error
	var sess db.Database
	var tx *sql.Tx

	if sess, err = db.Open(Adapter, settings); err != nil {
		b.Fatal(err)
	}

	defer sess.Close()

	driver := sess.Driver().(*sql.DB)

	if tx, err = driver.Begin(); err != nil {
		b.Fatal(err)
	}

	if _, err = tx.Exec("TRUNCATE TABLE `artist`"); err != nil {
		b.Fatal(err)
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		if _, err = tx.Exec("INSERT INTO `artist` (`name`) VALUES('Hayao Miyazaki')"); err != nil {
			b.Fatal(err)
		}
	}

	if err = tx.Commit(); err != nil {
		b.Fatal(err)
	}
}
Example #5
0
// AddParent adds a parent. Uses passed transaction or a new one if one is not provided
func AddParent(familyID int, name string, email string, password string, tx *sql.Tx) (int, error) {
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	needCommit := false
	if tx == nil {
		tx, err = db.Begin()
		if err != nil {
			return 0, err
		}
		needCommit = true
		defer tx.Rollback()
	}

	// Create the parent
	if _, err := tx.Exec("INSERT INTO parents VALUES(NULL, ?, ?, ?, ?, NULL, NULL)", familyID, name, email, hashedPassword); err != nil {
		return 0, err
	}
	// Get the ID
	var ID int
	row := tx.QueryRow("SELECT LAST_INSERT_ID()")
	err = row.Scan(&ID)
	if needCommit {
		tx.Commit()
	}

	return ID, err
}
Example #6
0
func truncateAllTables(svc *Services) error {
	var tx *sql.Tx
	done := func(err error) error {
		if err == nil {
			err = tx.Commit()
		}
		if err != nil {
			tx.Rollback()
			return fmt.Errorf("truncateAllTables failed: %v", err)
		} else {
			return nil
		}
	}

	tx, err := svc.db.Begin()
	if err != nil {
		return done(err)
	}
	names, err := getTableNames(tx)
	if err != nil {
		return done(err)
	}

	for _, name := range names {
		stmt := fmt.Sprintf("TRUNCATE TABLE %v CASCADE", name)
		if _, err := tx.Exec(stmt); err != nil {
			return done(err)
		}
	}

	return done(nil)
}
Example #7
0
func EndTx(tx *sql.Tx, err *error) {
	if *err == nil {
		tx.Commit()
	} else {
		tx.Rollback()
	}
}
Example #8
0
func processLogin(
	w http.ResponseWriter, r *http.Request, tx *sql.Tx, login *Login,
) (bool, error) {
	cEmail := canonEmail(r.Form.Get("email"))
	cPassword := strings.TrimSpace(r.Form.Get("password"))

	login.Email = cEmail

	userID, passwordHash, err := getUserInfo(tx, cEmail)
	switch {
	case err == sql.ErrNoRows:
		login.Error = errBadUserOrPassword
		return false, nil
	case err != nil:
		return false, err
	}

	if !checkPasswordHash(cPassword, passwordHash) {
		login.Error = errBadUserOrPassword
		return false, nil
	}

	err = loginUser(w, r, tx, userID)
	if err != nil {
		return false, err
	}
	err = tx.Commit()
	if err != nil {
		return false, err
	}

	return true, nil
}
Example #9
0
func dataCompletenessDelete(r *http.Request, h http.Header, b *bytes.Buffer) *weft.Result {
	v := r.URL.Query()

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

	var txn *sql.Tx
	var err error

	if txn, err = db.Begin(); err != nil {
		return weft.InternalServerError(err)
	}

	for _, table := range []string{"data.completeness", "data.completeness_summary", "data.completeness_tag"} {
		if _, err = txn.Exec(`DELETE FROM `+table+` WHERE
				sitePK = (SELECT sitePK FROM data.site WHERE siteID = $1)
				AND typePK = (SELECT typePK FROM data.completeness_type WHERE typeID = $2)`,
			siteID, typeID); err != nil {
			txn.Rollback()
			return weft.InternalServerError(err)
		}
	}

	if err = txn.Commit(); err != nil {
		return weft.InternalServerError(err)
	}

	return &weft.StatusOK
}
Example #10
0
func readData(client net.Conn) {
	b := bufio.NewReadWriter(bufio.NewReader(client), bufio.NewWriter(client))
	i := 0
	var err error
	var tx *sql.Tx
	for {
		if i == 0 {
			tx, err = pg.Begin()
			if err != nil {
				log.Printf("error=true action=begin message=%v", err)
			}
			i += 1
		} else if i == (*checkpoint + 1) {
			//checkpoint is set by flag
			// we inc checkpoint for the case when it is set to 1
			err = tx.Commit()
			if err != nil {
				log.Printf("error=true action=commit message=%v", err)
			}
			log.Printf("action=commit")
			i = 0
		} else {
			line, err := b.ReadString('\n')
			if err != nil {
				break
			}
			handleInput(*tx, line)
			i += 1
		}
	}
}
Example #11
0
func (r *Runner) invokeMigration(isTest bool, m Migration, c *spiffy.DbConnection, optionalTx ...*sql.Tx) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("%v", err)
		}
	}()

	if m.IsTransactionIsolated() {
		err = m.Apply(c, spiffy.OptionalTx(optionalTx...))
		return
	}

	var tx *sql.Tx
	tx, err = c.Begin()
	if err != nil {
		return err
	}
	defer func() {
		if err == nil {
			err = exception.Wrap(tx.Commit())
		} else {
			err = exception.WrapMany(err, exception.New(tx.Rollback()))
		}
	}()
	err = m.Apply(c, tx)
	return
}
Example #12
0
// Up is executed when this migration is applied
func Up_20130702202327(txn *sql.Tx) {
	_, err := txn.Exec("CREATE TABLE projects (project_name TEXT, meta TEXT, PRIMARY KEY (project_name))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE components (project_name TEXT, component_name TEXT, gitrepo TEXT, meta TEXT, PRIMARY KEY (project_name, component_name))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE repositories (project_name TEXT, repository_name TEXT, type TEXT, arch TEXT, state TINYINT UNSIGNED, PRIMARY KEY (project_name, repository_name))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE types (type_name TEXT, display_name TEXT, description TEXT, needsuper BOOL, applsh TEXT, buldsh TEXT, publsh TEXT, PRIMARY KEY (type_name))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE jobs (project_name TEXT, repository_name TEXT, repository_arch TEXT, component_name TEXT, job_id BIGINT AUTO_INCREMENT, time TEXT, state TINYINT UNSIGNED, results TEXT, PRIMARY KEY (project_name, repository_name, repository_arch, component_name, job_id))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE owners (username TEXT, projects TEXT, email TEXT, isgroup BOOL, groupusers TEXT, PRIMARY KEY (username))")
	if err != nil {
		panic(err)
	}
	_, err = txn.Exec("CREATE TABLE authentication (username TEXT, password TEXT, token TEXT, admin TINYINT, PRIMARY KEY (username))")
	if err != nil {
		panic(err)
	}
	err = txn.Commit()
	if err != nil {
		panic(err)
	}
}
Example #13
0
func (self *DBRcs) Upgrade(patch_root string, verbose bool) (err error) {
	// 1. Read the version file passed in.
	// 2. Verify the previous version exists and matches the *current*
	//    version of the database.
	// 3. Start transactional schema upgrade
	// 4. Update version code in schema
	// 5. Rollback on failure, commit if no errors

	var curr_db_ver string
	var curr_patch_dir string
	var node *versionNode
	var sql_cmd string
	var txn *sql.Tx
	var upgrade_bytes []byte

	if err = self.ComputeHistory(patch_root); err != nil {
		return err
	}

	if curr_db_ver, err = self.CurrentDBVersion(); err != nil {
		if err == sql.ErrNoRows {
			return fmt.Errorf("No version code has been set yet.  You need to initialize the versioning system.")
		}
		return err
	}

	// walk the nodes from back to front
	for i := len(self.revisions) - 1; i >= 0; i-- {
		node = self.revisions[i]
		// Process this node
		curr_patch_dir, err = GetPatchDirectory(patch_root, node.version)
		if node.prev == curr_db_ver {
			upgrade_sql := filepath.Join(curr_patch_dir, "upgrade.sql")
			fmt.Printf("Reading from :[%v]\n", upgrade_sql)
			upgrade_bytes, err = ioutil.ReadFile(upgrade_sql)

			sql_cmd = string(upgrade_bytes)
			fmt.Printf("Attempting SQL is: [%v]\n", sql_cmd)
			txn, err = self.Db.Begin()
			if _, err = txn.Exec(sql_cmd); err != nil {
				fmt.Printf("Failed to execute: [%s]\n", sql_cmd)
				txn.Rollback()
				return err
			}

			// Roll the version forward
			_, err = txn.Exec("update meta set value = $1 where key = 'db.hash';", node.version)
			if err != nil {
				txn.Rollback()
				return err
			}
			fmt.Printf("Version switched from : [%v]\n", curr_db_ver)
			curr_db_ver = node.version
			fmt.Printf("Version switched to   : [%v]\n", curr_db_ver)
			txn.Commit()
			fmt.Printf("Success!  Executed [%v]\n", sql_cmd)
		}
	}
	return err
}
Example #14
0
// Delete will delete all of the configurations whose name is in the list
// of names in the arugment. It will not return an error if the name is not found.
func (cc *ConfigurationController) Delete(names ...string) (err error) {
	var (
		tx   *sql.Tx
		stmt *sql.Stmt
	)
	tx, err = cc.DB.Begin()
	if err != nil {
		tx.Rollback()
		return err
	}

	stmt, err = tx.Prepare("DELETE FROM configurations where config_name = $1")
	if err != nil {
		tx.Rollback()
		return err
	}

	for _, name := range names {
		_, err := stmt.Exec(name)

		if err == sql.ErrNoRows {
			err = nil
		}
		if err != nil {
			tx.Rollback()
			return err
		}
	}

	return tx.Commit()

}
Example #15
0
func (c *BaseCluster) MarkDeleted() (err error) {
	c.installer.dbMtx.Lock()
	defer c.installer.dbMtx.Unlock()

	var tx *sql.Tx
	tx, err = c.installer.db.Begin()
	if err != nil {
		return
	}

	if _, err = tx.Exec(`UPDATE prompts SET DeletedAt = now() WHERE ID IN (SELECT ResourceID FROM events WHERE ClusterID == $1 AND ResourceType == "prompt")`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE events SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE domains SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE instances SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE clusters SET DeletedAt = now() WHERE ID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE aws_clusters SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE digital_ocean_clusters SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE digital_ocean_droplets SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	if _, err = tx.Exec(`UPDATE ssh_clusters SET DeletedAt = now() WHERE ClusterID == $1`, c.ID); err != nil {
		tx.Rollback()
		return
	}

	c.installer.ClusterDeleted(c.ID)
	err = tx.Commit()
	return
}
Example #16
0
// Migrate executes the required migration of the database on startup.
// For each successful migration, an entry will be written into the "version"
// table, that states when a certain version was reached.
func Migrate(db *sql.DB) error {
	var err error

	if db == nil {
		return errs.Errorf("Database handle is nil\n")
	}

	m := getMigrations()

	var tx *sql.Tx
	for nextVersion := int64(0); nextVersion < int64(len(m)) && err == nil; nextVersion++ {

		tx, err = db.Begin()
		if err != nil {
			return errs.Errorf("Failed to start transaction: %s\n", err)
		}

		err = migrateToNextVersion(tx, &nextVersion, m)

		if err != nil {
			oldErr := err
			log.Info(nil, map[string]interface{}{
				"pkg":         "migration",
				"nextVersion": nextVersion,
				"migrations":  m,
				"err":         err,
			}, "Rolling back transaction due to: ", err)

			if err = tx.Rollback(); err != nil {
				log.Error(nil, map[string]interface{}{
					"nextVersion": nextVersion,
					"migrations":  m,
					"err":         err,
				}, "error while rolling back transaction: ", err)
				return errs.Errorf("Error while rolling back transaction: %s\n", err)
			}
			return oldErr
		}

		if err = tx.Commit(); err != nil {
			log.Error(nil, map[string]interface{}{
				"migrations": m,
				"err":        err,
			}, "error during transaction commit: ", err)
			return errs.Errorf("Error during transaction commit: %s\n", err)
		}

	}

	if err != nil {
		log.Error(nil, map[string]interface{}{
			"migrations": m,
			"err":        err,
		}, "migration failed with error: ", err)
		return errs.Errorf("Migration failed with error: %s\n", err)
	}

	return nil
}
Example #17
0
// 提交事务
// tx:事务对象
// 返回值:
// 错误对象
func CommitTransaction(tx *sql.Tx) error {
	err := tx.Commit()
	if err != nil {
		logUtil.Log(fmt.Sprintf("提交事务失败,错误信息:%s", err), logUtil.Error, true)
	}

	return err
}
Example #18
0
func TxCommit(tx *sql.Tx) error {
	err := tx.Commit()
	if err != nil {
		DFErrorLog("Transaction Commit Error:" + err.Error())
		return err
	}
	DFLog("Transaction Commit")
	return err
}
Example #19
0
func (s *cleansrv) cleanOldEntries() (err error) {
	var tx *sql.Tx
	tx, err = s.db.Begin()
	if err != nil {
		return err
	}

	defer func() {
		if err == nil {
			err = tx.Commit()
		} else {
			tx.Rollback()
		}
	}()

	res, err := tx.Stmt(s.prep["cleanAddress"]).Exec()
	if err != nil {
		return err
	}
	if rows, _ := res.RowsAffected(); rows > 0 {
		log.Printf("Clean: %d old addresses", rows)
	}

	res, err = tx.Stmt(s.prep["cleanRelay"]).Exec()
	if err != nil {
		return err
	}
	if rows, _ := res.RowsAffected(); rows > 0 {
		log.Printf("Clean: %d old relays", rows)
	}

	res, err = tx.Stmt(s.prep["cleanDevice"]).Exec()
	if err != nil {
		return err
	}
	if rows, _ := res.RowsAffected(); rows > 0 {
		log.Printf("Clean: %d old devices", rows)
	}

	var devs, addrs, relays int
	row := tx.Stmt(s.prep["countDevice"]).QueryRow()
	if err = row.Scan(&devs); err != nil {
		return err
	}
	row = tx.Stmt(s.prep["countAddress"]).QueryRow()
	if err = row.Scan(&addrs); err != nil {
		return err
	}
	row = tx.Stmt(s.prep["countRelay"]).QueryRow()
	if err = row.Scan(&relays); err != nil {
		return err
	}

	log.Printf("Database: %d devices, %d addresses, %d relays", devs, addrs, relays)
	return nil
}
Example #20
0
func applyMigration(c *Config, m Migration, direction int) error {
	var tx *sql.Tx
	var exec execer

	rollback := func() {
		if tx != nil {
			tx.Rollback()
		}
	}

	contents, err := ioutil.ReadFile(filepath.Join(c.MigrationFolder, m.Filename))
	if err != nil {
		return err
	}

	db, err := openConnection(c)
	defer db.Close()
	if err != nil {
		return err
	}
	exec = db

	if m.WrapInTransaction() {
		tx, err = db.Begin()
		if err != nil {
			return err
		}
		exec = tx
	}

	if _, err = exec.Exec(string(contents)); err != nil {
		rollback()
		return errors.New(formatPgErr(&contents, err.(*pq.Error)))
	}

	if direction == UP {
		if err = insertSchemaVersion(c, exec, m.Version); err != nil {
			rollback()
			return errors.New(formatPgErr(&contents, err.(*pq.Error)))
		}
	} else {
		if err = deleteSchemaVersion(c, exec, m.Version); err != nil {
			rollback()
			return errors.New(formatPgErr(&contents, err.(*pq.Error)))
		}
	}

	if tx != nil {
		err = tx.Commit()
		if err != nil {
			return err
		}
	}

	return nil
}
Example #21
0
//Increments the phone no used count
func IncPhoneUsedCount(phoneNo, authID string, tx *sql.Tx) (err error) {
	_, err = tx.Exec(`
    UPDATE phone_number 
    SET count = count + 1 
    WHERE number = $1 AND account_id = 
      (SELECT id FROM account WHERE auth_id = $2)
    `, phoneNo, authID)
	tx.Commit()
	return
}
Example #22
0
// Down is executed when this migration is rolled back
func Down_20130702202327(txn *sql.Tx) {
	_, err := txn.Exec("DROP TABLE IF EXISTS projects, components, repositories, types, jobs, owners, authentication;")
	if err != nil {
		panic(err)
	}
	err = txn.Commit()
	if err != nil {
		panic(err)
	}
}
Example #23
0
func completeTransaction(tx *sql.Tx, errResult error) error {
	if errResult != nil {
		err := tx.Rollback()
		if err != nil {
			log.Printf("warning: failed to rollback: %v", err)
		}
	} else {
		errResult = tx.Commit()
	}
	return errResult
}
Example #24
0
File: rdb.go Project: donh/query
// IoC execution(in transaction)
func ExecuteInTx(txCallback func(*sql.Tx)) {
	var tx *sql.Tx
	var err error

	if tx, err = DbForTest.Begin(); err != nil {
		log.Fatalf("Cannot create transaction: %v", err)
	}

	defer tx.Commit()
	txCallback(tx)
}
Example #25
0
// Update the version table for the given migration,
// and finalize the transaction.
func FinalizeMigration(conf *DBConf, txn *sql.Tx, direction bool, v int64) error {

	// XXX: drop goose_db_version table on some minimum version number?
	stmt := conf.Driver.Dialect.insertVersionSql()
	if _, err := txn.Exec(stmt, v, direction); err != nil {
		txn.Rollback()
		return err
	}

	return txn.Commit()
}
Example #26
0
func (library *Library) Flush() (err error) {
	var (
		tx     *sql.Tx
		stmt1  *sql.Stmt
		stmt2  *sql.Stmt
		res    sql.Result
		lastId int64
	)

	tx, err = library.db.Begin()
	if err != nil {
		return
	}

	stmt1, err = tx.Prepare("INSERT INTO songs (path, title, artist, albumartist, album, track, year, genre, composer, copyright) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
	if err != nil {
		tx.Rollback()
		return
	}

	stmt2, err = tx.Prepare("INSERT INTO comments (data, song_id) VALUES (?, ?)")
	if err != nil {
		tx.Rollback()
		return
	}

	for _, song := range library.queue {
		res, err = stmt1.Exec(song.Path, song.Title, song.Artist, song.AlbumArtist, song.Album, song.Track, song.Year, song.Genre, song.Composer, song.Copyright)
		if err != nil {
			tx.Rollback()
			return
		}

		if len(song.Comments) > 0 {
			lastId, err = res.LastInsertId()
			if err != nil {
				tx.Rollback()
				return
			}

			for _, comment := range song.Comments {
				_, err = stmt2.Exec(comment, lastId)
				if err != nil {
					tx.Rollback()
					return
				}
			}
		}
	}

	err = tx.Commit()
	library.queue = nil
	return
}
Example #27
0
File: db.go Project: postfix/arx
// Finalise handles transaction rollback and commit.
func Finalise(tx *sql.Tx, err error) {
	if err != nil {
		if err = tx.Rollback(); err != nil {
			log.Printf("database transaction rollback failed (%v)", err)
		}
	} else {
		if err = tx.Commit(); err != nil {
			log.Printf("failed to commit transaction (%v)", err)
		}
	}
}
Example #28
0
func Backup(log *logging.Logger, cfg *ini.File, grace string, reload bool) {
	const POOL = 5
	var db database.DB
	var tx *sql.Tx
	var c = make(chan bool, POOL)
	var wg = new(sync.WaitGroup)

	var dataset, maxdatasets int
	var sections []*ini.Section

	sections = cfg.Sections()

	maxdatasets, _ = cfg.Section("dataset").Key(grace).Int()

	db.Open(log, cfg)
	defer db.Close()

	tx, _ = db.Conn.Begin()
	dataset = database.GetDataset(log, tx, grace)
	tx.Commit()

	if !reload {
		if nextds := dataset + 1; nextds > maxdatasets {
			dataset = 1
		} else {
			dataset = dataset + 1
		}
	}
	log.Info("Dataset processed: " + strconv.Itoa(dataset))

	wg.Add(len(sections) - len(SECT_RESERVED))
	for _, section := range sections {
		if !contains(SECT_RESERVED, section.Name()) {
			if section.Key("type").String() == "file" { // FIXME: useless?
				sect := common.Section{
					Name:       section.Name(),
					Grace:      grace,
					Dataset:    dataset,
					Compressed: section.Key("compress").MustBool(),
				}

				go fileBackup(log, &sect, cfg, c, wg)
				c <- true
			}
		}
	}
	wg.Wait() // Wait for all the children to die
	close(c)

	tx, _ = db.Conn.Begin()
	database.SetDataset(log, tx, dataset, grace)
	tx.Commit()
}
Example #29
0
func execInsert(db *sql.DB, query string, parameters ...interface{}) {
	var err error
	var tx *sql.Tx
	var stmt *sql.Stmt
	stmt, err = db.Prepare(query)
	tx, err = db.Begin()
	_, err = tx.Stmt(stmt).Exec(parameters...)
	err = tx.Commit()
	if err != nil {
		log.Fatalf("Insert error %q\n", err)
	}
}
Example #30
0
func (this *DBAdaptor) CommitTransaction(tx *sql.Tx) error {
	if this.db == nil {
		return fmt.Errorf("database object invalid")
	}

	err := tx.Commit()
	if err != nil {
		//fmt.Printf("提交失败\n")
		return err
	}

	return nil
}