func newSorted(t *testing.T) (kv sorted.KeyValue, clean func()) { f, err := ioutil.TempFile("", "sqlite-test") if err != nil { t.Fatal(err) } db, err := sql.Open("sqlite3", f.Name()) if err != nil { t.Fatalf("opening test database: %v", err) } for _, tableSql := range sqlite.SQLCreateTables() { do(db, tableSql) } do(db, fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, sqlite.SchemaVersion())) kv, err = sorted.NewKeyValue(jsonconfig.Obj{ "type": "sqlite", "file": f.Name(), }) if err != nil { t.Fatal(err) } return kv, func() { kv.Close() os.Remove(f.Name()) } }
func initSQLiteDB(path string) error { db, err := sql.Open("sqlite3", path) if err != nil { return err } defer db.Close() for _, tableSql := range sqlite.SQLCreateTables() { if _, err := db.Exec(tableSql); err != nil { return err } } if sqlite.IsWALCapable() { if _, err := db.Exec(sqlite.EnableWAL()); err != nil { return err } } else { log.Print("WARNING: An SQLite indexer without Write Ahead Logging will most likely fail. See http://camlistore.org/issues/114\n") } _, err = db.Exec(fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, sqlite.SchemaVersion())) return err }
func (c *dbinitCmd) RunCommand(args []string) error { if c.dbName == "" { return cmdmain.UsageError("--dbname flag required") } if c.dbType != "mysql" && c.dbType != "postgres" && c.dbType != "mongo" { if c.dbType == "sqlite" { if !WithSQLite { return ErrNoSQLite } c.wal = c.wal && sqlite.IsWALCapable() if !c.wal { fmt.Print("WARNING: An SQLite indexer without Write Ahead Logging will most likely fail. See http://camlistore.org/issues/114\n") } } else { return cmdmain.UsageError(fmt.Sprintf("--dbtype flag: got %v, want %v", c.dbType, `"mysql" or "postgres" or "sqlite", or "mongo"`)) } } var rootdb *sql.DB var err error switch c.dbType { case "postgres": conninfo := fmt.Sprintf("user=%s dbname=%s host=%s password=%s sslmode=%s", c.user, "postgres", c.host, c.password, c.sslMode) rootdb, err = sql.Open("postgres", conninfo) case "mysql": rootdb, err = sql.Open("mymysql", "mysql/"+c.user+"/"+c.password) } if err != nil { exitf("Error connecting to the root %s database: %v", c.dbType, err) } dbname := c.dbName exists := c.dbExists(rootdb) if exists { if c.keep { return nil } if !c.wipe { return cmdmain.UsageError(fmt.Sprintf("Database %q already exists, but --wipe not given. Stopping.", dbname)) } if c.dbType == "mongo" { return c.wipeMongo() } if c.dbType != "sqlite" { do(rootdb, "DROP DATABASE "+dbname) } } switch c.dbType { case "sqlite": _, err := os.Create(dbname) if err != nil { exitf("Error creating file %v for sqlite db: %v", dbname, err) } case "mongo": return nil case "postgres": // because we want string comparison to work as on MySQL and SQLite. // in particular we want: 'foo|bar' < 'foo}' (which is not the case with an utf8 collation apparently). do(rootdb, "CREATE DATABASE "+dbname+" LC_COLLATE = 'C' TEMPLATE = template0") default: do(rootdb, "CREATE DATABASE "+dbname) } var db *sql.DB switch c.dbType { case "postgres": conninfo := fmt.Sprintf("user=%s dbname=%s host=%s password=%s sslmode=%s", c.user, dbname, c.host, c.password, c.sslMode) db, err = sql.Open("postgres", conninfo) case "sqlite": db, err = sql.Open("sqlite3", dbname) default: db, err = sql.Open("mymysql", dbname+"/"+c.user+"/"+c.password) } if err != nil { return fmt.Errorf("Connecting to the %s %s database: %v", dbname, c.dbType, err) } switch c.dbType { case "postgres": for _, tableSql := range postgres.SQLCreateTables() { do(db, tableSql) } for _, statement := range postgres.SQLDefineReplace() { do(db, statement) } doQuery(db, fmt.Sprintf(`SELECT replaceintometa('version', '%d')`, postgres.SchemaVersion())) case "mysql": for _, tableSql := range mysql.SQLCreateTables() { do(db, tableSql) } do(db, fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, mysql.SchemaVersion())) case "sqlite": for _, tableSql := range sqlite.SQLCreateTables() { do(db, tableSql) } if c.wal { do(db, sqlite.EnableWAL()) } do(db, fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, sqlite.SchemaVersion())) } return nil }