// OpenFromConnPool takes the existing *pgx.ConnPool pool and returns a *sql.DB
// with pool as the backend. This enables full control over the connection
// process and configuration while maintaining compatibility with the
// database/sql interface. In addition, by calling Driver() on the returned
// *sql.DB and typecasting to *stdlib.Driver a reference to the pgx.ConnPool can
// be reaquired later. This allows fast paths targeting pgx to be used while
// still maintaining compatibility with other databases and drivers.
//
// pool connection size must be at least 2.
func OpenFromConnPool(pool *pgx.ConnPool) (*sql.DB, error) {
d := &Driver{Pool: pool}
name := fmt.Sprintf("pgx-%d", openFromConnPoolCount)
openFromConnPoolCount++
sql.Register(name, d)
db, err := sql.Open(name, "")
if err != nil {
return nil, err
}
// Presumably OpenFromConnPool is being used because the user wants to use
// database/sql most of the time, but fast path with pgx some of the time.
// Allow database/sql to use all the connections, but release 2 idle ones.
// Don't have database/sql immediately release all idle connections because
// that would mean that prepared statements would be lost (which kills
// performance if the prepared statements constantly have to be reprepared)
stat := pool.Stat()
if stat.MaxConnections <= 2 {
return nil, errors.New("pool connection size must be at least 2")
}
db.SetMaxIdleConns(stat.MaxConnections - 2)
db.SetMaxOpenConns(stat.MaxConnections)
return db, nil
}
func init() {
mu.Lock()
defer mu.Unlock()
if !driverRegistered("mysql") {
sql.Register("mysql", &mysql.MySQLDriver{})
}
if !driverRegistered("mariadb") {
sql.Register("mariadb", &mysql.MySQLDriver{})
}
}
// init computes the supported versions into a byte slice and register the driver.
func init() {
for i, v := range versionsSupported {
binary.BigEndian.PutUint32(handshakeRequest[i*4:i*4+4], v)
}
sql.Register("neo4j-bolt", &neoDriver{})
}
func initDatabase() models.Control {
var dbDriver string
sql.Register(dbDriver, &sqlite3.SQLiteDriver{})
database, err := sql.Open(dbDriver, "db")
if err != nil {
fmt.Println("Failed to create the handle")
}
if err := database.Ping(); err != nil {
fmt.Println("Failed to keep connection alive")
}
if err != nil {
log.Fatal(err)
}
_, err = database.Exec(
"CREATE TABLE IF NOT EXISTS Config (id integer PRIMARY KEY, notifications_limit integer NOT NULL, timeout integer NOT NULL)",
)
if err != nil {
log.Fatal(err)
}
config := models.Config{NotificationsLimit: 3, Timeout: 10}
_ = database.QueryRow(
"SELECT notifications_limit, timeout FROM Config ORDER BY id DESC LIMIT 1",
).Scan(&config.NotificationsLimit, &config.Timeout)
controller := models.Control{Config: config, Database: database}
return controller
}
func main() {
// Load and validate config file.
config := LoadConfig("config.json")
// Register SQLite driver.
sqlite3conn := []*sqlite3.SQLiteConn{}
sql.Register(config.DbName,
&sqlite3.SQLiteDriver{
ConnectHook: func(conn *sqlite3.SQLiteConn) error {
sqlite3conn = append(sqlite3conn, conn)
return nil
},
})
// Open SQLite database and assign it to the contxt.
db, err := sql.Open(config.DbName, config.DbPath)
if err != nil {
log.Fatal(err.Error())
}
// Create the application context.
ctx := server.NewAppContext(db, config.AuthKey)
defer db.Close()
// Create mux and register the handlers.
mux := http.NewServeMux()
mux.Handle("/gcm/devices/", server.NewGCMHandler(ctx))
mux.Handle("/apn/devices/", server.NewAPNHandler(ctx))
// Attemp to start the server.
address := fmt.Sprintf("%s:%d", config.Address, config.Port)
log.Fatal(http.ListenAndServe(address, mux))
}
func main() {
sql.Register("sqlite3_with_extensions",
&sqlite3.SQLiteDriver{
Extensions: []string{
"sqlite3_mod_regexp",
},
})
db, err := sql.Open("sqlite3_with_extensions", ":memory:")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// Force db to make a new connection in pool
// by putting the original in a transaction
tx, err := db.Begin()
if err != nil {
log.Fatal(err)
}
defer tx.Commit()
// New connection works (hopefully!)
rows, err := db.Query("select 'hello world' where 'hello world' regexp '^hello.*d$'")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
var helloworld string
rows.Scan(&helloworld)
fmt.Println(helloworld)
}
}
func BenchmarkCustomFunctions(b *testing.B) {
customFunctionOnce.Do(func() {
custom_add := func(a, b int64) int64 {
return a + b
}
sql.Register("sqlite3_BenchmarkCustomFunctions", &SQLiteDriver{
ConnectHook: func(conn *SQLiteConn) error {
// Impure function to force sqlite to reexecute it each time.
if err := conn.RegisterFunc("custom_add", custom_add, false); err != nil {
return err
}
return nil
},
})
})
db, err := sql.Open("sqlite3_BenchmarkCustomFunctions", ":memory:")
if err != nil {
b.Fatal("Failed to open database:", err)
}
defer db.Close()
b.ResetTimer()
for i := 0; i < b.N; i++ {
var i int64
err = db.QueryRow("SELECT custom_add(1,2)").Scan(&i)
if err != nil {
b.Fatal("Failed to run custom add:", err)
}
}
}
func main() {
sql.Register("sqlite3_with_extensions",
&sqlite3.SQLiteDriver{
Extensions: []string{
"sqlite3_mod_vtable",
},
})
db, err := sql.Open("sqlite3_with_extensions", ":memory:")
if err != nil {
log.Fatal(err)
}
defer db.Close()
db.Exec("create virtual table repo using github(id, full_name, description, html_url)")
rows, err := db.Query("select id, full_name, description, html_url from repo")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
var id, full_name, description, html_url string
rows.Scan(&id, &full_name, &description, &html_url)
fmt.Printf("%s: %s\n\t%s\n\t%s\n\n", id, full_name, description, html_url)
}
}
// GetDatabase initialises a new database for a NameCache.
func GetDatabase(cfg *DBConfig) (*sql.DB, error) {
driver := "sqlite3_sous"
conn := InMemory
if cfg != nil {
if cfg.Driver != "" {
driver = cfg.Driver
}
if cfg.Connection != "" {
conn = cfg.Connection
}
}
if driver == "sqlite3" {
driver = "sqlite3_sous"
}
registerSQLOnce.Do(func() {
sql.Register(driver, &sqlite.SQLiteDriver{
ConnectHook: func(conn *sqlite.SQLiteConn) error {
if err := conn.RegisterFunc("semverEqual", semverEqual, true); err != nil {
return err
}
return nil
},
})
})
db, err := sql.Open(driver, conn) //only call once
return db, errors.Wrapf(err, "get DB/open: %v", cfg)
}
func init() {
err := initDriver()
if err != nil {
panic(err)
}
sql.Register("odbc", &drv)
}
func TestOpen(t *testing.T) {
cfgfile := os.Getenv("DBCONFIG")
if cfgfile == "" {
cfgfile = "config.toml"
}
cfg := new(Config)
if f, err := os.Open(cfgfile); err != nil {
t.Fatal(err, "(did you set the DBCONFIG env variable?)")
} else {
if _, err := toml.DecodeReader(f, cfg); err != nil {
t.Fatal(err)
}
}
d := NewDriver("ClusterSql", mysql.MySQLDriver{})
for _, ncfg := range cfg.Nodes {
if ncfg.Password != "" {
d.AddNode(ncfg.Name, fmt.Sprintf("%s:%s@tcp(%s:%d)/%s", ncfg.UserName, ncfg.Password, ncfg.HostName, ncfg.Port, ncfg.DBName))
} else {
d.AddNode(ncfg.Name, fmt.Sprintf("%s@tcp(%s:%d)/%s", ncfg.UserName, ncfg.HostName, ncfg.Port, ncfg.DBName))
}
}
sql.Register("cluster", d)
var err error
db, err = sql.Open("cluster", "galera")
if err != nil {
t.Error(err)
}
}
// Register a txdb sql driver under the given sql driver name
// which can be used to open a single transaction based database
// connection.
//
// When Open is called any number of times it returns
// the same transaction connection. Any Begin, Commit calls
// will not start or close the transaction.
//
// When Close is called, the transaction is rolled back.
//
// Use drv and dsn as the standard sql properties for
// your test database connection to be isolated within transaction.
//
// Note: if you open a secondary database, make sure to differianciate
// the dsn string when opening the sql.DB. The transaction will be
// isolated within that dsn
func Register(name, drv, dsn string) {
sql.Register(name, &txDriver{
dsn: dsn,
drv: drv,
conns: make(map[string]*conn),
})
}
func init() {
hook := func(conn *sqlite3.SQLiteConn) error {
_, err := conn.Exec("PRAGMA foreign_keys = ON", nil)
return err
}
driver := &sqlite3.SQLiteDriver{ConnectHook: hook}
sql.Register("sql_fk", driver)
}
func init() {
sql.Register("sqlite3", &Driver{})
if os.Getenv("SQLITE_LOG") != "" {
ConfigLog(func(d interface{}, err error, msg string) {
log.Printf("%s: %s, %s\n", d, err, msg)
}, "SQLITE")
}
}
func init() {
fmt.Println("init()", reflect.TypeOf(globalStubDriver))
// for stub test: not call in init() usually
db, err := globalStubDriver.Open("DataSourceName")
fmt.Println("db, err=\t", db, err)
sql.Register("stubdriver", globalStubDriver)
}
func init() {
dvr = NewFakeDialect()
sql.Register("dali", dvr)
dbHandle, err := sql.Open("dali", "")
if err != nil {
panic(err)
}
db = NewDB(dbHandle, dvr)
}
func init() {
sql.Register("sqlite3_textql",
&sqlite3.SQLiteDriver{
ConnectHook: func(conn *sqlite3.SQLiteConn) error {
sqlite3conn = append(sqlite3conn, conn)
return nil
},
})
}
func init() {
sql.Register("sqlite3_fk",
&sqlite3.SQLiteDriver{
ConnectHook: func(conn *sqlite3.SQLiteConn) error {
_, err := conn.Exec("PRAGMA foreign_keys = ON", nil)
return err
},
})
}
func init() {
sql.Register("sqlite3", &impl{open: defaultOpen})
if os.Getenv("SQLITE_LOG") != "" {
ConfigLog(func(d interface{}, err error, msg string) {
log.Printf("%s: %s, %s\n", d, err, msg)
}, "SQLITE")
}
ConfigMemStatus(false)
}
func init() {
sql.Register("csv", &csvDriver{})
db, err := sql.Open("ql", "memory:///dev/null")
if err != nil {
panic(err)
}
defer db.Close()
qldrv = db.Driver()
}
func init() {
var err error
_drv.sqlPkgEnv, err = OpenEnv(nil)
if err != nil {
errE(err)
}
// database/sql/driver expects binaryFloat to return float64 (not the Rset default of float32)
_drv.sqlPkgEnv.cfg.StmtCfg.Rset.binaryFloat = F64
sql.Register(Name, _drv)
}
func SetupConnectionCountingDriver(delegateDriverName, sqlDataSource, newDriverName string) {
delegateDBConn, err := sql.Open(delegateDriverName, sqlDataSource)
if err == nil {
// ignoring any connection errors since we only need this to access the driver struct
delegateDBConn.Close()
}
connectionCountingDriver := &connectionCountingDriver{delegateDBConn.Driver()}
sql.Register(newDriverName, connectionCountingDriver)
}
func init() {
regex := func(re, s string) (bool, error) {
return regexp.MatchString(re, s)
}
sql.Register("sqlite3_custom",
&sqlite3.SQLiteDriver{
ConnectHook: func(conn *sqlite3.SQLiteConn) error {
return conn.RegisterFunc("REGEXP", regex, true)
},
})
}
// Once the exporter tool is installed, just invoke the command with the
// appropriate parameters, like:
// exporter -in yourdatabase.db -out youroutputfile.csv
func main() {
// Parse the flags from the command line.
flag.Parse()
cfg := loadConfig(*configFile)
ctx := &Context{}
// Use FieldsExporter if there are export fields. Default to RawExporter.
if len(cfg.Fields) > 0 {
exporter := NewFieldExporter(cfg.Fields)
ctx.Exporter = exporter
} else {
exporter := new(RawExporter)
ctx.Exporter = exporter
}
// CSV Params.
ctx.Out.CSVFile = *outputFile
// DB params.
ctx.In.Path = *inputFile
ctx.In.User = *dbUser
ctx.In.Password = *dbPassword
// Prepare the db connection pool.
sqlite3conn := []*sqlite3.SQLiteConn{}
sql.Register("contactlab.push.exporter.SQLITE",
&sqlite3.SQLiteDriver{
ConnectHook: func(conn *sqlite3.SQLiteConn) error {
sqlite3conn = append(sqlite3conn, conn)
return nil
},
})
// Open a connection to the database.
log.Printf("Connecting to %s...\n", ctx.In.Path)
db, err := sql.Open("contactlab.push.exporter.SQLITE", ctx.In.Path)
if err != nil {
log.Fatalln(err)
}
defer db.Close()
ctx.In.Connection = db
err = prepareCSV(ctx)
if err != nil {
log.Fatalln(err)
}
log.Println("Done!")
}
func dostuff() error {
//http://golang-basic.blogspot.co.nz/2014/06/golang-database-step-by-step-guide-on.html
var DB_DRIVER string
sql.Register(DB_DRIVER, &sqlite3.SQLiteDriver{})
_, err := sql.Open(DB_DRIVER, "mysqlite_3")
if err != nil {
log.Println("ERROR: Failed to create the handle.")
}
return nil
}
func TestCustomRegister2(t *testing.T) {
sql.Register("sqlite3FK", sqlite.NewDriver(nil, func(c *sqlite.Conn) error {
_, err := c.EnableFKey(true)
return err
}))
db, err := sql.Open("sqlite3FK", ":memory:")
checkNoError(t, err, "Error while opening customized db: %s")
defer checkSqlDbClose(db, t)
conn := sqlite.Unwrap(db)
fk, err := conn.IsFKeyEnabled()
checkNoError(t, err, "Error while reading foreign_keys status: %s")
assert.Tf(t, fk, "foreign_keys = %t; want %t", fk, true)
}
// NewDbMapFromConfig functions similarly to NewDbMap, but it takes the
// decomposed form of the connection string, a *mysql.Config.
func NewDbMapFromConfig(config *mysql.Config, maxOpenConns int) (*gorp.DbMap, error) {
adjustMySQLConfig(config)
// We always want strict mode. Rather than leaving this up to DB config, we
// prefix each statement with it.
prefix := "SET STATEMENT sql_mode='STRICT_ALL_TABLES' FOR "
// If a read timeout is set, we set max_statement_time to 95% of that, and
// long_query_time to 80% of that. That way we get logs of queries that are
// close to timing out but not yet doing so, and our queries get stopped by
// max_statement_time before timing out the read. This generates clearer
// errors, and avoids unnecessary reconnects.
if config.ReadTimeout != 0 {
// In MariaDB, max_statement_time and long_query_time are both seconds.
// Note: in MySQL (which we don't use), max_statement_time is millis.
readTimeout := config.ReadTimeout.Seconds()
prefix = fmt.Sprintf(
"SET STATEMENT max_statement_time=%g, long_query_time=%g, sql_mode='STRICT_ALL_TABLES' FOR ",
readTimeout*0.95, readTimeout*0.80)
}
// The way we generate a customized database driver means that we need to
// choose a name to register the driver with. Because this function can be
// called multiple times with different parameters, we choose a random name
// each time we register to avoid conflicts with other DB instances.
// We use crypto/rand rather than math.Rand not out of a particular necessity
// for high-quality randomness, but simply because using non-crypto rand is a
// code smell.
driverNum, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
if err != nil {
return nil, err
}
driverName := fmt.Sprintf("mysql-%d", driverNum)
sql.Register(driverName, prefixdb.New(prefix, mysql.MySQLDriver{}))
db, err := sqlOpen(driverName, config.FormatDSN())
if err != nil {
return nil, err
}
if err = db.Ping(); err != nil {
return nil, err
}
setMaxOpenConns(db, maxOpenConns)
dialect := gorp.MySQLDialect{Engine: "InnoDB", Encoding: "UTF8"}
dbmap := &gorp.DbMap{Db: db, Dialect: dialect, TypeConverter: BoulderTypeConverter{}}
initTables(dbmap)
return dbmap, err
}
func init() {
sql.Register("sqlite3_gipam",
&sqlite.SQLiteDriver{
ConnectHook: func(conn *sqlite.SQLiteConn) error {
if err := conn.RegisterFunc("prefixIsInside", dbPrefixIsInside, true); err != nil {
return err
}
if err := conn.RegisterFunc("prefixLen", dbPrefixLen, true); err != nil {
return err
}
return nil
},
})
}
func TestAggregatorRegistration(t *testing.T) {
customSum := func() *sumAggregator {
var ret sumAggregator
return &ret
}
sql.Register("sqlite3_AggregatorRegistration", &SQLiteDriver{
ConnectHook: func(conn *SQLiteConn) error {
if err := conn.RegisterAggregator("customSum", customSum, true); err != nil {
return err
}
return nil
},
})
db, err := sql.Open("sqlite3_AggregatorRegistration", ":memory:")
if err != nil {
t.Fatal("Failed to open database:", err)
}
defer db.Close()
_, err = db.Exec("create table foo (department integer, profits integer)")
if err != nil {
// trace feature is not implemented
t.Skip("Failed to create table:", err)
}
_, err = db.Exec("insert into foo values (1, 10), (1, 20), (2, 42)")
if err != nil {
t.Fatal("Failed to insert records:", err)
}
tests := []struct {
dept, sum int64
}{
{1, 30},
{2, 42},
}
for _, test := range tests {
var ret int64
err = db.QueryRow("select customSum(profits) from foo where department = $1 group by department", test.dept).Scan(&ret)
if err != nil {
t.Fatal("Query failed:", err)
}
if ret != test.sum {
t.Fatalf("Custom sum returned wrong value, got %d, want %d", ret, test.sum)
}
}
}
func init() {
d := &Driver{}
sql.Register("pgx", d)
databaseSqlOids = make(map[pgx.Oid]bool)
databaseSqlOids[pgx.BoolOid] = true
databaseSqlOids[pgx.ByteaOid] = true
databaseSqlOids[pgx.Int2Oid] = true
databaseSqlOids[pgx.Int4Oid] = true
databaseSqlOids[pgx.Int8Oid] = true
databaseSqlOids[pgx.Float4Oid] = true
databaseSqlOids[pgx.Float8Oid] = true
databaseSqlOids[pgx.DateOid] = true
databaseSqlOids[pgx.TimestampTzOid] = true
}
