Example #1
0
func (c *Connection) Connect(tries uint) error {
	if tries == 0 {
		return nil
	}

	var err error
	var db *sql.DB
	for i := tries; i > 0; i-- {
		// Wait before attempt.
		time.Sleep(c.backoff.Wait())

		// Open connection to MySQL but...
		db, err = sql.Open("mysql", c.dsn)
		if err != nil {
			continue
		}

		// ...try to use the connection for real.
		if err = db.Ping(); err != nil {
			// Connection failed.  Wrong username or password?
			db.Close()
			continue
		}

		// Connected
		c.conn = db
		c.backoff.Success()
		return nil
	}

	return errors.New(fmt.Sprintf("Failed to connect to MySQL after %d tries (%s)", tries, err))
}
Example #2
0
func Get(id string) (*Video, error) {
	var (
		video *Video = &Video{}
		err   error
		db    *sql.DB
	)

	db, err = settings.Db()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	err = db.QueryRow("SELECT * FROM videos WHERE id = $1", id).Scan(
		&video.Id,
		&video.Title,
		&video.YoutubeId,
		&video.NicoId,
		&video.UploadedAt,
		&video.CreatedAt,
		&video.UpdatedAt,
	)
	if err != nil {
		return nil, err
	}

	return video, nil
}
Example #3
0
func (sqlite sqlite_driver) OpenDatabase(db *sql.DB) error {
	if _, err := db.Exec(`
	CREATE TABLE IF NOT EXISTS samples (
		timestamp   integer,
		id          text,
		channel     integer,
		serial      string,
		key         string,
		min         real,
		max         real,
		avg         real
	)`); err != nil {
		db.Close()
		return err
	}

	if _, err := db.Exec(`
	CREATE INDEX IF NOT EXISTS i_samples ON samples (
		timestamp,
		key,
		id,
		channel,
		serial
	)`); err != nil {
		db.Close()
		return err
	}

	return nil
}
Example #4
0
func getCustomerPrice(personId int, productId int, number int) ([]*model.CustomerPrice, error) {
	var conn *sql.DB
	var stmt *sql.Stmt
	var err error
	if conn, err = db.Connect(); err != nil {
		return nil, err
	}
	defer conn.Close()

	_sql := "select * from customer_special_price where person_id = ? and product_id = ? order by create_time DESC limit ?"
	if stmt, err = conn.Prepare(_sql); err != nil {
		return nil, err
	}
	defer stmt.Close()

	rows, err := stmt.Query(personId, productId, number)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	models := []*model.CustomerPrice{}
	for rows.Next() {
		m := new(model.CustomerPrice)
		var blackhole sql.NullInt64
		err := rows.Scan(&m.Id, &m.PersonId, &m.ProductId, &m.Price, &m.CreateTime, &blackhole /*&m.LastUsedTime */)
		if err != nil {
			panic(err)
		}
		models = append(models, m)
	}
	return models, nil
}
Example #5
0
func (s *sphinxPools) newConn() (*SphinxDB, error) {
	var (
		err error
		db  *sql.DB
		o   orm.Ormer
	)

	if db, err = sql.Open("sphinx", "root:root@tcp("+setting.SphinxHost+")/?loc=UTC"); err != nil {
		return nil, err
	}

	if err = db.Ping(); err != nil {
		db.Close()
		return nil, err
	}

	db.SetMaxIdleConns(1)
	db.SetMaxOpenConns(2)

	o, err = orm.NewOrmWithDB("sphinx", "sphinx", db)
	if err != nil {
		return nil, err
	}

	sdb := &SphinxDB{
		alive: true,
		pools: s,
		db:    db,
		orm:   o,
	}
	return sdb, nil
}
Example #6
0
func DatabaseConnect(c conf.Database) (*sql.DB, error) {
	var db *sql.DB
	var err error

	if c.Type == "mysql" {
		if c.Password == "" {
			db, err = sql.Open("mysql", c.Username+"@"+c.Protocol+"("+c.Address+":"+strconv.Itoa(c.Port)+")/")
		} else {
			db, err = sql.Open("mysql", c.Username+":"+c.Password+"@"+c.Protocol+"("+c.Address+":"+strconv.Itoa(c.Port)+")/")
		}
	}

	if err != nil {
		slog.Errorf("%v: %v: %v: %v", "Database", c.Type, "connect open error", err)
		return nil, fmt.Errorf("%v: %v", "connect open error", err)
	}

	// check if can connect to database, if fail, check again every minute until connected
	for {
		err = db.Ping()
		if err == nil {
			break
		}
		slog.Errorf("%v: %v: %v: %v", "Database", c.Type, "connect ping error", err)
		next := time.After(time.Minute)
		select {
		case <-next:
		case <-ContinuousCollectorVars.quit:
			db.Close()
			return nil, fmt.Errorf("connect while quitting")
		}
	}

	return db, nil
}
func process(node *types.Container, credential *types.Credential, gauge *prometheus.GaugeVec) error {
	var err error

	//logit.Info.Println("dbsize node=" + node.Name + " credentials Username:" + credential.Username + " Password:" + credential.Password + " Database:" + credential.Database + " Host:" + credential.Host)
	var db *sql.DB
	db, err = util.GetMonitoringConnection(credential.Host,
		credential.Username, credential.Port, credential.Database, credential.Password)
	defer db.Close()
	if err != nil {
		logit.Error.Println("error in getting connectionto " + credential.Host)
		return err
	}

	var metrics []DBMetric
	//logit.Info.Println("dbsize running pg2 on " + node.Name)
	metrics, err = pg2(db)

	//write metrcs to prometheus

	i := 0
	for i = range metrics {
		//logit.Info.Println("dbsize setting dbsize metric")
		gauge.WithLabelValues(node.Name, metrics[i].Name).Set(metrics[i].Value)
		i++
	}

	return nil

}
Example #8
0
func saveToDB(db *sql.DB, stockList []Stock, configuration Configuration) {
	db, err := sql.Open("mysql", configuration.MySQLUser+":"+configuration.MySQLPass+"@tcp("+configuration.MySQLHost+":"+configuration.MySQLPort+")/"+configuration.MySQLDB)
	if err != nil {
		fmt.Println("Could not connect to database")
		return
	}

	for i := range stockList {
		//@TODO Save results to database
		stock := stockList[i]

		// Prepare statement for inserting data
		insertStatement := "INSERT INTO st_data (`symbol`, `exchange`, `name`, `change`, `close`, `percentageChange`, `open`, `high`, `low`, `volume` , `avgVolume`, `high52` , `low52`, `marketCap`, `eps`, `shares`, `time`, `minute`, `hour`, `day`, `month`, `year`) "
		insertStatement += "VALUES( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )"
		stmtIns, err := db.Prepare(insertStatement)
		if err != nil {
			panic(err.Error()) // proper error handling instead of panic in your app
		}
		defer stmtIns.Close() // Close the statement when we leave main() / the program terminates

		// Convert variables
		sqlChange, _ := strconv.ParseFloat(strings.Replace(stock.Change, ",", "", -1), 64)
		sqlClose, _ := strconv.ParseFloat(strings.Replace(stock.Close, ",", "", -1), 64)
		sqlPercChange, _ := strconv.ParseFloat(stock.PercentageChange, 64)
		sqlOpen, _ := strconv.ParseFloat(strings.Replace(stock.Open, ",", "", -1), 64)
		sqlHigh, _ := strconv.ParseFloat(strings.Replace(stock.High, ",", "", -1), 64)
		sqlLow, _ := strconv.ParseFloat(strings.Replace(stock.Low, ",", "", -1), 64)
		sqlHigh52, _ := strconv.ParseFloat(strings.Replace(stock.High52, ",", "", -1), 64)
		sqlLow52, _ := strconv.ParseFloat(strings.Replace(stock.Low52, ",", "", -1), 64)
		sqlEps, _ := strconv.ParseFloat(stock.EPS, 64)

		// Some contain letters that need to be converted
		sqlVolume := convertLetterToDigits(stock.Volume)
		sqlAvgVolume := convertLetterToDigits(stock.AverageVolume)
		sqlMarketCap := convertLetterToDigits(stock.MarketCap)
		sqlShares := convertLetterToDigits(stock.Shares)

		t := time.Now()
		utc, err := time.LoadLocation(configuration.TimeZone)
		if err != nil {
			fmt.Println("err: ", err.Error())
		}
		sqlTime := int32(t.Unix())
		sqlMinute := t.In(utc).Minute()
		sqlHour := t.In(utc).Hour()
		sqlDay := t.In(utc).Day()
		sqlMonth := t.In(utc).Month()
		sqlYear := t.In(utc).Year()

		_, err = stmtIns.Exec(stock.Symbol, stock.Exchange, stock.Name, sqlChange, sqlClose,
			sqlPercChange, sqlOpen, sqlHigh, sqlLow, sqlVolume, sqlAvgVolume,
			sqlHigh52, sqlLow52, sqlMarketCap, sqlEps, sqlShares,
			sqlTime, sqlMinute, sqlHour, sqlDay, sqlMonth, sqlYear)

		if err != nil {
			fmt.Println("Could not save results: " + err.Error())
		}
	}
	defer db.Close()
}
Example #9
0
func database(res http.ResponseWriter, req *http.Request) {

	//	fmt.Fprintln(res, "testing...\n")

	var db *sql.DB
	var err error
	dokku_db := os.Getenv("DATABASE_URL")

	db, err = sql.Open("postgres", dokku_db+"?sslmode=disable")
	if err != nil {
		fmt.Printf("sql.Open error: %v\n", err)
		return
	}
	defer db.Close()

	err = doInitialize(db)
	if err != nil {
		fmt.Print("initialize error: %v\n", err)
		return
	}

	err = doSelect(res, db)
	if err != nil {
		fmt.Print("select error: %v\n", err)
		return
	}
}
Example #10
0
func Disconnect(db *sql.DB) {
	err := db.Close()
	if err != nil {
		log.Println(err)
	}
	log.Println("Database connection: Closed.")
}
Example #11
0
func main() {

	// Establish mysql connection
	var db *sql.DB
	var err error
	db, err = sql.Open("mysql", "user:pass@tcp(127.0.0.1:3306)/db_name")
	if err != nil {
		log.Println(err)
	}
	defer db.Close()

	// Single query
	var str string
	str = singleQuery(db)
	fmt.Println(str)

	// Another query - multiple rows
	var rows *sql.Rows
	rows = query(db)
	printRows(rows)
	rows.Close()

	// Insert statement
	//stmt, err := db.Prepare("INSERT INTO users(username, password) VALUES(?, ?)")
	//if err != nil {	log.Fatal(err) }
	//_, err = stmt.Exec("myuser", "mypass")
	//if err != nil {	log.Fatal(err) }

}
func SetEmailTaskDone(emailTask *EmailTask) bool {
	var db *sql.DB
	var stmt *sql.Stmt
	var err error
	LogError := func() {
		seelog.Errorf("[SetEmailTaskDone Failed] [EmailTask : %v] [ERROR : %v]", *emailTask, err)
	}

	if db, err = GetDBConnection(); err != nil {
		LogError()
		return false
	}
	defer db.Close()

	if stmt, err = db.Prepare("UPDATE `email_request` SET `is_done` = 1 WHERE `id` = ?"); err != nil {
		LogError()
		return false
	}
	defer stmt.Close()

	if _, err = stmt.Exec(emailTask.Id); err != nil {
		LogError()
		return false
	}

	return true
}
// StatusUpdate called by backup jobs as they execute
func StatusUpdate(w rest.ResponseWriter, r *rest.Request) {

	request := TaskStatus{}
	err := r.DecodeJsonPayload(&request)
	if err != nil {
		logit.Error.Println(err.Error())
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	var dbConn *sql.DB
	dbConn, err = util.GetConnection(CLUSTERADMIN_DB)
	if err != nil {
		logit.Error.Println(err.Error())
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return

	}
	defer dbConn.Close()

	//logit.Info.Println("StatusUpdate called")

	err = UpdateStatus(dbConn, &request)
	if err != nil {
		logit.Error.Println(err.Error())
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	response := StatusUpdateResponse{}
	response.Output = "ok"
	w.WriteJson(&response)
}
Example #14
0
File: model.go Project: amaudy/Gooo
func TestEmptyDB(db *sql.DB) {
	q := `select relname from pg_class where relname = 'post' and relkind='r'`
	var initialized int = 0
	rows, err := db.Query(q)
	if err != nil {
		fmt.Println("DB Query panic")
		panic(fmt.Sprintf("%s", err))
	}
	for rows.Next() {
		var relname string
		err = rows.Scan(&relname)
		if len(relname) > 0 {
			initialized++
		}
	}
	err = rows.Err()
	util.HandleErr(err)
	rows.Close()

	if initialized == 0 {
		q = `DROP SEQUENCE IF EXISTS post_id_seq CASCADE;
	            DROP TABLE IF EXISTS post CASCADE;
	            CREATE SEQUENCE post_id_seq;
	            CREATE TABLE post(id INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('post_id_seq'),
	                title VARCHAR(32), content TEXT, user_id INTEGER,
	                published BOOLEAN, created TIMESTAMP, modified TIMESTAMP)`
		_, err = db.Exec(q)
		util.HandleErr(err)
	}
	defer db.Close()
}
Example #15
0
func runTests(t *testing.T, dsn string, tests ...func(dbt *DBTest)) {
	if !available {
		t.Skipf("MySQL server not running on %s", netAddr)
	}

	db, err := sql.Open("mysql", dsn)
	if err != nil {
		t.Fatalf("error connecting: %s", err.Error())
	}
	defer db.Close()

	db.Exec("DROP TABLE IF EXISTS test")

	dsn2 := dsn + "&interpolateParams=true"
	var db2 *sql.DB
	if _, err := ParseDSN(dsn2); err != errInvalidDSNUnsafeCollation {
		db2, err = sql.Open("mysql", dsn2)
		if err != nil {
			t.Fatalf("error connecting: %s", err.Error())
		}
		defer db2.Close()
	}

	dbt := &DBTest{t, db}
	dbt2 := &DBTest{t, db2}
	for _, test := range tests {
		test(dbt)
		dbt.db.Exec("DROP TABLE IF EXISTS test")
		if db2 != nil {
			test(dbt2)
			dbt2.db.Exec("DROP TABLE IF EXISTS test")
		}
	}
}
func process() {
	var err error
	var metrics []collectapi.Metric

	var conn *sql.DB
	var host = HOSTNAME
	var user = "postgres"
	var port = PG_PORT
	var database = "postgres"
	var password = PG_ROOT_PASSWORD

	conn, err = collectapi.GetMonitoringConnection(logger, host, user, port, database, password)
	if err != nil {
		logger.Println("could not connect to " + host)
		logger.Println(err.Error())
		return
	}
	defer conn.Close()

	metrics, err = collectapi.GetMetrics(logger, HOSTNAME, user, PG_PORT, PG_ROOT_PASSWORD, conn)
	if err != nil {
		logger.Println("error getting metrics from " + host)
		logger.Println(err.Error())
		return
	}

	//write metrics to Prometheus
	err = collectapi.WritePrometheusMetrics(logger, PROM_GATEWAY, HOSTNAME, metrics)
	if err != nil {
		logger.Println("error writing metrics from " + host)
		logger.Println(err.Error())
		return
	}
}
Example #17
0
File: db_test.go Project: rrva/lxd
func Test_dbDevicesGet_profiles(t *testing.T) {
	var db *sql.DB
	var err error
	var result shared.Devices
	var subresult shared.Device
	var expected shared.Device

	db = createTestDb(t)
	defer db.Close()

	result, err = dbDevicesGet(db, "theprofile", true)
	if err != nil {
		t.Fatal(err)
	}

	expected = shared.Device{"type": "nic", "devicekey": "devicevalue"}
	subresult = result["devicename"]

	for key, value := range expected {
		if subresult[key] != value {
			t.Errorf("Mismatching value for key %s: %v != %v", key, subresult[key], value)
		}
	}

}
Example #18
0
func (d *PushDataBase) putConn(conn *sql.DB) {
	if len(d.dbpool) == d.maxConn {
		conn.Close()
		return
	}
	d.dbpool <- conn
}
Example #19
0
File: db_test.go Project: rrva/lxd
func Test_dbDevicesGet_containers(t *testing.T) {
	var db *sql.DB
	var err error
	var result shared.Devices
	var subresult shared.Device
	var expected shared.Device

	db = createTestDb(t)
	defer db.Close()

	result, err = dbDevicesGet(db, "thename", false)
	if err != nil {
		t.Fatal(err)
	}

	expected = shared.Device{"type": "nic", "configkey": "configvalue"}
	subresult = result["somename"]

	for key, value := range expected {
		if subresult[key] != value {
			t.Errorf("Mismatching value for key %s: %s != %s", key, subresult[key], value)
		}
	}

}
Example #20
0
File: db_test.go Project: rrva/lxd
func Test_deleting_an_image_cascades_on_related_tables(t *testing.T) {
	var db *sql.DB
	var err error
	var count int
	var statements string

	db = createTestDb(t)
	defer db.Close()

	// Drop the image we just created.
	statements = `DELETE FROM images;`

	_, err = db.Exec(statements)
	if err != nil {
		t.Errorf("Error deleting image! %s", err)
	}

	// Make sure there are 0 images_aliases entries left.
	statements = `SELECT count(*) FROM images_aliases;`
	err = db.QueryRow(statements).Scan(&count)

	if count != 0 {
		t.Errorf("Deleting an image didn't delete the image alias association! There are %d left", count)
	}

	// Make sure there are 0 images_properties entries left.
	statements = `SELECT count(*) FROM images_properties;`
	err = db.QueryRow(statements).Scan(&count)

	if count != 0 {
		t.Errorf("Deleting an image didn't delete the related images_properties! There are %d left", count)
	}
}
Example #21
0
File: db_test.go Project: rrva/lxd
func Test_dbImageGet_finds_image_for_fingerprint(t *testing.T) {
	var db *sql.DB
	var err error
	var result *shared.ImageBaseInfo

	db = createTestDb(t)
	defer db.Close()

	result, err = dbImageGet(db, "fingerprint", false, false)

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

	if result == nil {
		t.Fatal("No image returned!")
	}

	if result.Filename != "filename" {
		t.Fatal("Filename should be set.")
	}

	if result.CreationDate != 1431547174 {
		t.Fatal(result.CreationDate)
	}

	if result.ExpiryDate != 1431547175 { // It was short lived
		t.Fatal(result.ExpiryDate)
	}

	if result.UploadDate != 1431547176 {
		t.Fatal(result.UploadDate)
	}
}
Example #22
0
File: db_test.go Project: vahe/lxd
func Test_dbImageGet_finds_image_for_fingerprint(t *testing.T) {
	var db *sql.DB
	var err error
	var result *shared.ImageInfo

	db = createTestDb(t)
	defer db.Close()

	_, result, err = dbImageGet(db, "fingerprint", false, false)

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

	if result == nil {
		t.Fatal("No image returned!")
	}

	if result.Filename != "filename" {
		t.Fatal("Filename should be set.")
	}

	if result.CreationDate.UTC() != time.Unix(1431547174, 0).UTC() {
		t.Fatal(fmt.Sprintf("%s != %s", result.CreationDate, time.Unix(1431547174, 0)))
	}

	if result.ExpiryDate.UTC() != time.Unix(1431547175, 0).UTC() { // It was short lived
		t.Fatal(fmt.Sprintf("%s != %s", result.ExpiryDate, time.Unix(1431547175, 0)))
	}

	if result.UploadDate.UTC() != time.Unix(1431547176, 0).UTC() {
		t.Fatal(fmt.Sprintf("%s != %s", result.UploadDate, time.Unix(1431547176, 0)))
	}
}
func ping(dbConn *sql.DB, port string, containerName string, containerRole string) (string, error) {
	var db *sql.DB
	var err error
	var userid, password, database string

	//get node credentials
	userid, password, database, err = getCredential(dbConn, containerName, containerRole)
	if err != nil {
		logit.Error.Println(err.Error())
		return "down", err
	}

	db, err = util.GetMonitoringConnection(containerName,
		userid, port, database, password)
	defer db.Close()
	if err != nil {
		logit.Error.Println("error in getting connectionto " + containerName)
		return "down", err
	}

	var result string
	err = db.QueryRow("select now()::text").Scan(&result)
	if err != nil {
		logit.Error.Println("could not ping db on " + containerName)
		return "down", err
	}
	return "up", nil

}
Example #24
0
func cleanCloseTestDb(db *sql.DB, t *testing.T) {
	for _, stmt := range cleanStmts {
		_, err := db.Exec(stmt)
		checkErr(t, err)
	}
	db.Close()
}
Example #25
0
// Load a semanticizer (entity linker) from modelpath.
//
// Also returns a settings object that represents the dumpparser settings used
// to generate the model.
func Load(modelpath string) (sem *Semanticizer,
	settings *storage.Settings, err error) {

	var db *sql.DB
	defer func() {
		if db != nil && err != nil {
			db.Close()
		}
	}()

	db, settings, err = storage.LoadModel(modelpath)
	if err != nil {
		return
	}
	ngramcount, err := storage.LoadCM(db)
	if err != nil {
		return
	}
	allq, err := prepareAllQuery(db)
	if err != nil {
		return
	}

	sem = &Semanticizer{db: db, ngramcount: ngramcount,
		maxNGram: settings.MaxNGram, allQuery: allq}
	return
}
Example #26
0
func teardownAndCloseDB(t *testing.T, db *sql.DB) {
	err := teardownTestDB(db)
	if err != nil {
		t.Fatalf("DB teardown failed: %v", err.Error())
	}
	db.Close()
	return
}
Example #27
0
func orderDrinkHandler(w http.ResponseWriter, r *http.Request) {

	var err error
	var db *sql.DB

	if len(r.URL.Path) <= len("/order/") {
		http.NotFound(w, r)
		return
	} else {
		// Open database
		db = getDBConnection()
	}
	defer db.Close()
	tx, _ := db.Begin()
	defer tx.Rollback()

	recipe_id := r.URL.Path[len("/order/"):]

	// Check drink is known
	var menuitem MenuItem
	row := tx.QueryRow("select id, name from recipe where id = ?", recipe_id)
	err = row.Scan(&menuitem.Id, &menuitem.DrinkName)
	if err == sql.ErrNoRows {
		http.NotFound(w, r)
		return
	}

	alcoholic := recipeContainsAlcohol(tx, recipe_id)

	// Generate order
	_, insertErr := tx.Exec(
		"insert into drink_order (create_ts, recipe_id, alcohol, id_checked, cancelled) VALUES (?, ?, ?, ?, ?)",
		int32(time.Now().Unix()),
		recipe_id,
		alcoholic,
		false,
		false,
	)
	if insertErr != nil {
		panic(fmt.Sprintf("Insert order failed: %v", insertErr))
	}

	var orderLogged OrderLogged

	// Order reference (id)
	row = tx.QueryRow("select max(id) from drink_order")
	var order_id int
	err = row.Scan(&order_id)
	orderLogged.OrderId = fmt.Sprintf(ORDER_FMT, order_id)
	if err == sql.ErrNoRows {
		http.NotFound(w, r)
		return
	}
	tx.Commit()
	t, _ := template.ParseFiles("order_logged.html")
	t.Execute(w, orderLogged)
}
// ExecuteNow called by admin do perform an adhoc task
func ExecuteNow(w rest.ResponseWriter, r *rest.Request) {
	request := TaskRequest{}
	err := r.DecodeJsonPayload(&request)
	if err != nil {
		logit.Error.Println(err.Error())
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	var dbConn *sql.DB
	dbConn, err = util.GetConnection(CLUSTERADMIN_DB)
	if err != nil {
		logit.Error.Println(err.Error())
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return

	}
	defer dbConn.Close()
	log.Println("-log- ExecuteNow.impl called profile=" + request.ProfileName)
	fmt.Println("-fmt- ExecuteNow.impl called profile=" + request.ProfileName)
	//logit.Info.Println("-logit- ExecuteNow.impl called profile=" + request.ProfileName)

	if request.ProfileName == "pg_basebackup" {
		err = ProvisionBackupJob(dbConn, &request)
		if err != nil {
			logit.Error.Println(err.Error())
			rest.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else if request.ProfileName == "pg_backrest_restore" {
		logit.Info.Println("doing pg_backrest_restore job on...")
		err = ProvisionBackrestRestoreJob(dbConn, &request)
		if err != nil {
			logit.Error.Println(err.Error())
			rest.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else if request.ProfileName == "restore" {
		logit.Info.Println("doing restore job on...")
		err = ProvisionRestoreJob(dbConn, &request)
		if err != nil {
			logit.Error.Println(err.Error())
			rest.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	} else {
		err = errors.New("invalid profile name found:" + request.ProfileName)
		logit.Error.Println(err)
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	logit.Info.Println("ExecuteNow.impl completed")

	response := ExecuteNowResponse{}
	response.Output = "ok"
	w.WriteJson(&response)
}
Example #29
0
func dbStoreImage(db *sql.DB, hash string, delHash string, orig string, thumb string) {
	defer db.Close()

	_, err := db.Exec("INSERT INTO img (hash, date, deletehash, orig, thumb) VALUES ($1, $2, $3, $4, $5);", hash, time.Now().Unix(), delHash, orig, thumb)

	if err != nil {
		fmt.Printf("Error storing image. %s", err)
	}
}
Example #30
0
func DailySalesData_alldata(startTime string, excludeYangYi bool) (model.ProductSales, error) {

	var conn *sql.DB
	var stmt *sql.Stmt
	var err error
	if conn, err = db.Connect(); err != nil {
		return nil, err
	}
	defer conn.Close()

	_sql := `
select
  DATE_FORMAT(o.create_time, '%Y-%m-%d'), sum(od.quantity)
from
  order_detail od 
  left join ` + "`" + `order` + "`" + ` o on od.order_track_number = o.track_number
where 
  o.type in (?,?)
  and o.status in (?,?,?,?)
  and o.create_time >= ?
  and od.product_id <> ?
group by
  DATE_FORMAT(o.create_time, '%Y-%m-%d')
order by
  DATE_FORMAT(o.create_time, '%Y-%m-%d') asc
`
	if stmt, err = conn.Prepare(_sql); err != nil {
		return nil, err
	}
	defer stmt.Close()

	var excluded_product_id = 0
	if excludeYangYi {
		excluded_product_id = base.STAT_EXCLUDED_PRODUCT
	}

	rows, err := stmt.Query(
		model.Wholesale, model.SubOrder, // model.ShippingInstead, // 查子订单
		"toprint", "todeliver", "delivering", "done",
		startTime, excluded_product_id,
	)

	if db.Err(err) {
		return nil, err
	}
	defer rows.Close() // db.CloseRows(rows) // use db.CloseRows or rows.Close()? Is rows always nun-nil?

	ps := model.ProductSales{}

	for rows.Next() {
		p := new(model.SalesNode)
		rows.Scan(&p.Key, &p.Value)
		ps = append(ps, p)
	}
	return ps, nil
}