Golang sqlx.Connect函数代码示例

// Connect to the database
func Connect(d Databases) {
	var err error

	switch d.Type {
	case "MySQL":
		// Connect to MySQL
		if DB, err = sqlx.Connect("mysql", DSN(d.MySQL)); err != nil {
			log.Println("SQL Driver Error", err)
		}

		// Check if is alive
		if err := DB.Ping(); err != nil {
			log.Println("Database Error", err)
		}
	case "SQLite":
		// Connect to SQLite
		if DB, err = sqlx.Connect("sqlite3", d.SQLite.Parameter); err != nil {
			log.Println("SQL Driver Error", err)
		}

		// Check if is alive
		if err := DB.Ping(); err != nil {
			log.Println("Database Error", err)
		}
	default:
		log.Println("No registered database in config")
	}
}

// TODO: Instead pass back *sql.DB
func (r *RDPG) OpenDB(dbname string) error {
	if r.DB == nil {
		u, err := url.Parse(r.URI)
		if err != nil {
			log.Error(fmt.Sprintf("Failed parsing URI %s err: %s", r.URI, err))
		}
		u.Path = dbname
		r.URI = u.String()
		db, err := sqlx.Connect("postgres", r.URI)
		if err != nil {
			log.Error(fmt.Sprintf("Failed connecting to %s err: %s", rdpgURI, err))
			return err
		}
		r.DB = db
	} else {
		err := r.DB.Ping()
		if err != nil {
			db, err := sqlx.Connect("postgres", r.URI)
			if err != nil {
				log.Error(fmt.Sprintf("Failed connecting to %s err: %s", rdpgURI, err))
				proc, _ := os.FindProcess(os.Getpid())
				proc.Signal(syscall.SIGTERM)
				return err
			}
			r.DB = db
		}
	}
	return nil
}

// SqlRepository returns a new sqlRepository or panics if it cannot
func SqlRepository() UserRepository {
	settings := settings.NewSettings("settings.json")
	db, err := sqlx.Connect(settings.DriverName(), settings.DataSource())
	if err != nil {
		panic("Error connecting to db: " + err.Error())
	}

	repo := &sqlRepository{
		db: db,
	}

	datetime := "datetime"
	if settings.DriverName() == "postgres" {
		datetime = "timestamp with time zone"
	}

	schema := fmt.Sprintf(`CREATE TABLE IF NOT EXISTS authuser (
		key text not null primary key,
		name text,
		email text,
		password text,
		created %s,
		modified %s,
		lastactive %s
	);`, datetime, datetime, datetime)

	_, err = repo.db.Exec(schema)
	return repo
}

func sqlxConn() *sqlx.DB {
	db, err := sqlx.Connect("mysql", mysqlDSN)
	if err != nil {
		log.Fatalln(err)
	}
	return db
}

func initInjector(cmd *cobra.Command, args []string) {
	db, err := sqlx.Connect("postgres", viper.GetString("postgres-url"))
	if err != nil {
		fail(err)
	}

	mustProvide(inject.Object{Value: &drivers.DB})
	mustProvide(inject.Object{Value: &drivers.Horizon})
	mustProvide(inject.Object{Value: &uis.Console})
	mustProvide(inject.Object{Value: &drivers.Editor})
	mustProvide(inject.Object{Value: &drivers.HTTP})
	mustProvide(inject.Object{Value: db})
	mustProvide(inject.Object{
		Name:  "postgres-url",
		Value: viper.GetString("postgres-url"),
	})
	mustProvide(inject.Object{
		Name:  "horizon-url",
		Value: viper.GetString("horizon-url"),
	})

	if err := injector.Populate(); err != nil {
		fail(err)
	}
}

func initializing() {
	conn, err := sqlx.Connect("mysql", config.GetConfig().GetString("database.mysql"))
	if err != nil {
		fmt.Printf("mysql connect err: %+v\n", err)
	}
	db = conn
}

func Connect() (*sqlx.DB, error) {
	open := os.Getenv("DATABASE_URL")

	fmt.Println("connecting to", open)

	if parsedURL, err := pq.ParseURL(open); err == nil && parsedURL != "" {
		open = parsedURL
	}

	con, err := sqlx.Connect("postgres", open)

	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	err = con.Ping()

	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	return con, err
}

func init() {
	info := config.File.GetStringMap("database")

	ConnectionInfo = DatabaseConnection{
		info["user"].(string),
		info["host"].(string),
		info["database"].(string),
	}

	connString := fmt.Sprintf(
		"postgres://%s:@%s/%s?sslmode=disable",
		info["user"],
		info["host"],
		info["database"],
	)

	Sq = sq.StatementBuilder.PlaceholderFormat(sq.Dollar)

	client, err := sqlx.Connect("postgres", connString)
	if err != nil {
		panic(err)
	}

	Client = client
	println("Connected to Postgres")
}

func NewEntityManager(dbType string, url string) (em EntityManager, err error) {
	em.db, err = sqlx.Connect(dbType, url)
	em.log = logrus.WithFields(logrus.Fields{
		"service": "EntityManager",
	})
	return
}

// DBConnect connects to MySQL database
func DBConnect() (*sqlx.DB, error) {
	// Generate connection string using configuration
	conn := fmt.Sprintf("%s:%[email protected]/%s", Static.Config.DB.Database, Static.Config.DB.Username, Static.Config.DB.Password)

	// Return connection and associated errors
	return sqlx.Connect("mysql", conn)
}

func main() {
	var (
		cfgFile string
		role    string
	)

	flag.StringVar(&cfgFile, "c", "./conf/cfg.ini", "config file")
	flag.StringVar(&role, "r", "", "server role: scheduler, fetcher etc.")
	flag.Parse()

	config, err := utils.ReadConfig(cfgFile)

	if err == nil {
		if role == "scheduler" {
			db, _ := sqlx.Connect("mysql", config["scheduler"]["dsn"])
			log.Infoln("db stats: ", db.Stats())

			scheduler := scheduler.InitScheduler(db, config["scheduler"])
			scheduler.Run()
		} else if role == "fetcher" {
			fetcher := fetcher.InitFetcher(config["fetcher"])
			fetcher.Run()
		} else {
			fmt.Println("unknown role:", role)
		}
	}

}

func searchHandler(w http.ResponseWriter, req *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	query := req.URL.Query()["q"][0]
	cypher := `MATCH (movie:Movie) 
				 WHERE movie.title =~ {0} 
				 RETURN movie.title as title, movie.tagline as tagline, movie.released as released`
	db, err := sqlx.Connect("neo4j-cypher", neo4jURL)
	if err != nil {
		log.Println("error connecting to neo4j:", err)
	}
	defer db.Close()

	movies := []Movie{}
	param := "(?i).*" + query + ".*"
	err = db.Select(&movies, cypher, param)
	if err != nil {
		log.Println("error querying search:", err)
	}

	movieResults := []MovieResult{}
	for _, x := range movies {
		movieResults = append(movieResults, MovieResult{x})
	}

	err = json.NewEncoder(w).Encode(movieResults)
	if err != nil {
		log.Println("error writing search response:", err)
	}
}

func (config *DBConfig) ConnectToDB() *sqlx.DB {
	result, err := sqlx.Connect(config.Flavor, config.URI)
	if err != nil {
		log.Fatal(err)
	}
	return result
}

// NewApplication is the constructor for Application struct.
//
// If testing is true, connects to the "test" database.
func NewApplication(testing bool) (*Application, error) {
	u, err := libunix.CurrentUser()
	if err != nil {
		return nil, err
	}

	dbname := "forty-thieves"
	if testing {
		dbname += "-test"
	}
	dsn := libenv.EnvWithDefault(
		"DSN", fmt.Sprintf("postgres://%[email protected]:5432/%s?sslmode=disable", u, dbname))

	db, err := sqlx.Connect("postgres", dsn)
	if err != nil {
		return nil, err
	}

	cookieStoreSecret := libenv.EnvWithDefault("COOKIE_SECRET", "ittwiP92o0oi6P4i")

	app := &Application{}
	app.dsn = dsn
	app.db = db
	app.cookieStore = sessions.NewCookieStore([]byte(cookieStoreSecret))

	return app, err
}

func init() {
	usr, err := user.Current()
	if err != nil {
		panic(err)
	}
	workDir := filepath.Join(usr.HomeDir, ".pmusic")
	artDir := filepath.Join(workDir, "cArt")
	path := filepath.Join(workDir, "music.db3")

	err = os.MkdirAll(artDir, 0700)
	if err != nil {
		panic(err)
	}

	db, err = sqlx.Connect("sqlite3", path)
	if err != nil {
		panic(err)
	}

	dbm = modl.NewDbMap(&db.DB, modl.SqliteDialect{})
	dbm.AddTable(Musician{}, "musician").SetKeys(true, "Uid")
	dbm.AddTable(Stations{}, "station").SetKeys(true, "Uid")
	dbm.AddTable(Album{}, "album").SetKeys(true, "Uid")
	dbm.AddTable(Track{}, "track").SetKeys(true, "Uid")
	dbm.AddTable(PTimeStamp{}, "ptimestamp").SetKeys(true, "Uid")
	err = dbm.CreateTablesIfNotExists()
	if err != nil {
		panic(err)
	}
}