func makeIndex() *index.Index {
dbname := "camlitest_" + os.Getenv("USER")
closeAllSessions(dbname)
do(rootdb, "DROP DATABASE IF EXISTS "+dbname)
do(rootdb, "CREATE DATABASE "+dbname)
var err error
testdb, err = sql.Open("postgres", "user=postgres password=postgres host=localhost sslmode=require dbname="+dbname)
if err != nil {
panic("opening test database: " + err.Error())
}
for _, tableSql := range postgres.SQLCreateTables() {
do(testdb, tableSql)
}
for _, statement := range postgres.SQLDefineReplace() {
do(testdb, statement)
}
doQuery(testdb, fmt.Sprintf(`SELECT replaceintometa('version', '%d')`, postgres.SchemaVersion()))
s, err := postgres.NewStorage("localhost", "postgres", "postgres", dbname, "require")
if err != nil {
panic(err)
}
return index.New(s)
}
func (c *dbinitCmd) RunCommand(args []string) error {
if c.dbName == "" {
return cmdmain.UsageError("--dbname flag required")
}
if c.dbType != "mysql" && c.dbType != "postgres" {
if c.dbType == "sqlite" {
if !WithSQLite {
return ErrNoSQLite
}
} else {
return cmdmain.UsageError(fmt.Sprintf("--dbtype flag: got %v, want %v", c.dbType, `"mysql" or "postgres", or "sqlite"`))
}
}
var rootdb *sql.DB
var err error
switch c.dbType {
case "postgres":
conninfo := fmt.Sprintf("user=%s dbname=%s host=%s password=%s sslmode=require", c.user, "postgres", c.host, c.password)
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 := dbExists(rootdb, c.dbType, dbname)
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 != "sqlite" {
do(rootdb, "DROP DATABASE "+dbname)
}
}
if c.dbType == "sqlite" {
_, err := os.Create(dbname)
if err != nil {
exitf("Error creating file %v for sqlite db: %v", dbname, err)
}
} else {
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=require", c.user, dbname, c.host, c.password)
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)
}
do(db, fmt.Sprintf(`REPLACE INTO meta VALUES ('version', '%d')`, sqlite.SchemaVersion()))
}
return nil
}
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
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
}
func main() {
flag.Parse()
if *flagDatabase == "" {
exitf("--database flag required")
}
if *flagType != "mysql" && *flagType != "postgres" {
exitf("--type flag: wrong value")
}
var rootdb *sql.DB
var err error
switch *flagType {
case "postgres":
conninfo := fmt.Sprintf("user=%s dbname=%s host=%s password=%s sslmode=require", *flagUser, "postgres", *flagHost, *flagPassword)
rootdb, err = sql.Open("postgres", conninfo)
case "mysql":
rootdb, err = sql.Open("mymysql", "mysql/"+*flagUser+"/"+*flagPassword)
}
if err != nil {
exitf("Error connecting to the %s database: %v", *flagType, err)
}
dbname := *flagDatabase
exists := dbExists(rootdb, dbname)
if exists {
if *flagIgnore {
return
}
if !*flagWipe {
exitf("Databases %q already exists, but --wipe not given. Stopping.", dbname)
}
do(rootdb, "DROP DATABASE "+dbname)
}
do(rootdb, "CREATE DATABASE "+dbname)
var db *sql.DB
switch *flagType {
case "postgres":
conninfo := fmt.Sprintf("user=%s dbname=%s host=%s password=%s sslmode=require", *flagUser, dbname, *flagHost, *flagPassword)
db, err = sql.Open("postgres", conninfo)
default:
db, err = sql.Open("mymysql", dbname+"/"+*flagUser+"/"+*flagPassword)
}
if err != nil {
exitf("Error connecting to the %s database: %v", *flagType, err)
}
switch *flagType {
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()))
}
}
