Example #1
4
func (res TagsResource) getTags(req *restful.Request, resp *restful.Response) {

	links := halgo.Links{}.
		Self("/api/lookups/tags").
		Link("root", "/api").
		Link("lookups", "/api/lookups")

	// go fetch our employmenttype data from the db

	tags := []TagDataModel{}
	stmt := database.TagsStatement{}.GetSelectAll()
	db, err := sqlx.Connect("mssql", "server=d101983;user id=retroUser;password=Password")
	if err != nil {
		log.Fatal("Could not connect to the database, " + err.Error())
		return
	}

	defer db.Close()

	err = db.Select(&tags, stmt)
	if err != nil {
		resp.WriteError(500, errors.New("Error retrieving tags from database, "+err.Error()))
		return
	}

	data := TagResourceModel{
		Links: links,
		Tags:  tags,
	}
	resp.WriteEntity(data)
}
Example #2
2
// 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")
	}
}
Example #3
0
// 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
}
// FetchMetrics interface for mackerelplugin
func (p PostgresPlugin) FetchMetrics() (map[string]interface{}, error) {

	db, err := sqlx.Connect("postgres", fmt.Sprintf("user=%s password=%s host=%s port=%s sslmode=%s connect_timeout=%d %s", p.Username, p.Password, p.Host, p.Port, p.SSLmode, p.Timeout, p.Option))
	if err != nil {
		logger.Errorf("FetchMetrics: %s", err)
		return nil, err
	}
	defer db.Close()

	statStatDatabase, err := fetchStatDatabase(db)
	if err != nil {
		return nil, err
	}
	statConnections, err := fetchConnections(db)
	if err != nil {
		return nil, err
	}
	statDatabaseSize, err := fetchDatabaseSize(db)
	if err != nil {
		return nil, err
	}

	stat := make(map[string]interface{})
	mergeStat(stat, statStatDatabase)
	mergeStat(stat, statConnections)
	mergeStat(stat, statDatabaseSize)

	return stat, err
}
Example #5
0
// 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://%v@localhost: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 sqlxConn() *sqlx.DB {
	db, err := sqlx.Connect("mysql", mysqlDSN)
	if err != nil {
		log.Fatalln(err)
	}
	return db
}
Example #7
0
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)
	}
}
Example #8
0
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
}
Example #9
0
File: db.go Project: zqzca/back
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
}
Example #10
0
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")
}
Example #11
0
func main() {
	// this Pings the database trying to connect, panics on error
	// use sqlx.Open() for sql.Open() semantics
	dbUserName := os.Getenv("DB_USERNAME")
	creds := fmt.Sprintf("user=%s dbname=initial sslmode=disable", dbUserName)

	fmt.Println(dbUserName)

	fmt.Println(creds)

	db, err := sqlx.Connect("postgres", creds)
	fmt.Println("yay db!")
	if err != nil {
		fmt.Println(err)
	}

	// exec the schema or fail; multi-statement Exec behavior varies between
	// database drivers;  pq will exec them all, sqlite3 won't, ymmv
	db.MustExec(schema)

	tx := db.MustBegin()
	fmt.Println("starting seeding")
	tx.MustExec("INSERT INTO users (first_name, last_name, email) VALUES ($1, $2, $3)", "Theo", "Smith-Crespo", "*****@*****.**")
	tx.MustExec("INSERT INTO users (first_name, last_name, email) VALUES ($1, $2, $3)", "Janice", "Smith", "*****@*****.**")
	tx.MustExec("INSERT INTO users (first_name, last_name, email) VALUES ($1, $2, $3)", "Alvin", "Crespo", "*****@*****.**")
	tx.Commit()
	fmt.Println("ending seeding")
}
Example #12
0
func createDb(spec string) (*sqlx.DB, error) {
	db, err := sqlx.Connect("mysql", spec+"?parseTime=true&charset=utf8mb4,utf8")
	if err != nil {
		return nil, err
	}
	return db, nil
}
Example #13
0
// DBConnect connects to MySQL database
func DBConnect() (*sqlx.DB, error) {
	// Generate connection string using configuration
	conn := fmt.Sprintf("%s:%s@/%s", Static.Config.DB.Database, Static.Config.DB.Username, Static.Config.DB.Password)

	// Return connection and associated errors
	return sqlx.Connect("mysql", conn)
}
Example #14
0
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)
		}
	}

}
Example #15
0
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)
	}
}
Example #16
0
func (config *DBConfig) ConnectToDB() *sqlx.DB {
	result, err := sqlx.Connect(config.Flavor, config.URI)
	if err != nil {
		log.Fatal(err)
	}
	return result
}
Example #17
0
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
}
func TestFetchStatDatabase(t *testing.T) {
	db, _ := sqlx.Connect("testdb", "")

	columns := []string{"xact_commit", "xact_rollback", "blks_read", "blks_hit", "blk_read_time", "blk_write_time",
		"tup_returned", "tup_fetched", "tup_inserted", "tup_updated", "tup_deleted", "deadlocks", "temp_bytes"}

	testdb.StubQuery(`SELECT * FROM pg_stat_database`, testdb.RowsFromCSVString(columns, `
	1,2,3,4,5,6,7,8,9,10,11,12,13
	10,20,30,40,50,60,70,80,90,100,110,120,130
	`))

	stat, err := fetchStatDatabase(db)

	expected := map[string]interface{}{
		"xact_commit":  uint64(11),
		"blks_hit":     uint64(44),
		"tup_returned": uint64(77),
	}

	if err != nil {
		t.Errorf("Expected no error, but got %s instead", err)
	}
	if err = db.Close(); err != nil {
		t.Errorf("Error '%s' was not expected while closing the database", err)
	}
	if stat["xact_commit"] != expected["xact_commit"] {
		t.Error("should be 11")
	}
	if stat["blks_hit"] != expected["blks_hit"] {
		t.Error("should be 44")
	}
	if stat["tup_returned"] != expected["tup_returned"] {
		t.Error("should be 77")
	}
}
Example #19
0
func newDbForTest(t *testing.T) *sqlx.DB {
	var err error
	pguser, pgpass, pghost, pgport, pgsslmode := os.Getenv("PGUSER"), os.Getenv("PGPASSWORD"), os.Getenv("PGHOST"), os.Getenv("PGPORT"), os.Getenv("PGSSLMODE")
	if pguser == "" {
		pguser, err = libunix.CurrentUser()
		if err != nil {
			t.Fatalf("Getting current user should never fail. Error: %v", err)
		}
	}

	if pghost == "" {
		pghost = "localhost"
	}

	if pgport == "" {
		pgport = "5432"
	}

	if pgsslmode == "" {
		pgsslmode = "disable"
	}

	db, err := sqlx.Connect("postgres", fmt.Sprintf("postgres://%v@%v:%v/fpc-test?sslmode=%v&password=%v", pguser, pghost, pgport, pgsslmode, pgpass))
	if err != nil {
		t.Fatalf("Connecting to local postgres should never fail. Error: %v", err)
	}
	return db
}
Example #20
0
File: pg.go Project: husio/bb
func WithPG(ctx context.Context, credentials string) (context.Context, error) {
	db, err := sqlx.Connect("postgres", credentials)
	if err != nil {
		return ctx, err
	}
	return context.WithValue(ctx, "db:connection", db), nil
}
Example #21
0
func test(config map[string]map[string]string) {
	db, _ := sqlx.Connect("mysql", config["scheduler"]["dsn"])
	log.Infoln("db stats: ", db.Stats())

	taskDao := dao.InitTaskDao(db)
	crawlRules, _ := taskDao.GetWaitRules()
	crawlTasks := []types.CrawlTask{}
	for _, rule := range crawlRules {
		log.Infoln(rule.Domain, rule.Urlpath)
		crawlTasks = append(crawlTasks, taskDao.ConvertRuleToTask(rule))
	}

	log.Infoln("get task: ", len(crawlTasks))

	num, results, err := taskDao.AddNewTasks(crawlTasks)

	log.Infoln("add task: ", num, results, err)

	affectedRows, _ := taskDao.UpdateRules(crawlRules, results)

	log.Infoln("update rules: ", affectedRows)

	waitingTasks, _ := taskDao.GetWaitingTasks()

	for _, task := range waitingTasks {
		log.Infoln(task.Domain, task.Urlpath)
	}

	affectedRows, _ = taskDao.SetTasksStatus(waitingTasks, dao.TASK_FINISH)
	log.Infoln("set task status: ", affectedRows)

}
Example #22
0
File: main.go Project: fmr/kanban
func main() {

	flag.Parse()

	r := gin.Default()

	r.LoadHTMLGlob("templates/*")

	r.Use(static.Serve("/static", static.LocalFile("static", false)))

	dbx, err := sqlx.Connect("sqlite3", *dbName)

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

	api.New(r, "/api/v1", db.New(dbx))

	r.GET("/", func(c *gin.Context) {
		c.HTML(http.StatusOK, "index.html", gin.H{"env": *env})
	})

	if err := r.Run(":" + *port); err != nil {
		panic(err)
	}
}
Example #23
0
// dbConnect connects to the database via sqlx.
func dbConnect() (*sqlx.DB, error) {
	db, err := sqlx.Connect("mysql", strings.Join(dbCreds, ""))
	if err != nil {
		return nil, err
	}
	return db, nil
}
Example #24
0
// NewDB creates a new DB
func NewDB(path string) (*DB, error) {
	db, err := sqlx.Connect("sqlite3", path)
	if err != nil {
		return nil, err
	}
	return &DB{db}, nil
}
Example #25
0
func Open(conf *core.Config) (*sqlx.DB, error) {
	type DBConfig struct {
		Development struct {
			Driver string
			Open   string
		}
	}

	configText, err := ioutil.ReadFile(conf.GetFilePath(filepath.Join("database", "dbconf.yml")))
	if err != nil {
		return nil, err
	}

	dbConfig := DBConfig{}
	err = yaml.Unmarshal(configText, &dbConfig)
	if err != nil {
		return nil, err
	}

	db, err := sqlx.Connect(dbConfig.Development.Driver, dbConfig.Development.Open)
	if err != nil {
		return nil, err
	}

	return db, nil
}
Example #26
0
// 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
}
Example #27
0
// Interface returns an interface to the local data store. Currently, it assumes
// that the schema our tables and functions are in can be found in the search
// path, so you'll need to ensure that it's set in the provided resource.
//
// Example resource: "user=enoch dbname=evetool search_path=eveindy"
func Interface(driver, resource string, xmlAPI evego.XMLAPI) (LocalDB, error) {
	dbConn, err := sqlx.Connect(driver, resource)
	if err != nil {
		return nil, err
	}
	// Is resource a URL or the other thing?
	// Find out, then add/modify search_path parameter.
	d := &dbInterface{
		db:     dbConn,
		xmlAPI: xmlAPI,
	}
	// Prepare statements
	stmts := []struct {
		preparedStatement **sqlx.Stmt
		statementText     string
	}{
		// Pointer magic, stage 1: Pass the address of the pointer.
		{&d.getSessionStmt, getSessionStmt},
		{&d.setTokenStmt, setTokenStmt},
		{&d.getAPIKeysStmt, getAPIKeysStmt},
		{&d.addAPIKeyStmt, addAPIKeyStmt},
		{&d.deleteAPIKeyStmt, deleteAPIKeyStmt},
		{&d.logoutSessionStmt, logoutSessionStmt},
		{&d.apiKeyInsertToonStmt, apiKeyInsertToonStmt},
		{&d.apiKeyListToonsStmt, apiKeyListToonsStmt},
		{&d.apiKeyInsertSkillStmt, apiKeyInsertSkillStmt},
		{&d.apiKeyClearSkillsStmt, apiKeyClearSkillsStmt},
		{&d.getSkillStmt, getSkillStmt},
		{&d.getSkillGroupStmt, getSkillGroupStmt},
		{&d.apiKeyClearCorpStandingsStmt, apiKeyClearCorpStandingsStmt},
		{&d.apiKeyClearFacStandingsStmt, apiKeyClearFacStandingsStmt},
		{&d.apiKeyInsertCorpStandingsStmt, apiKeyInsertCorpStandingsStmt},
		{&d.apiKeyInsertFacStandingsStmt, apiKeyInsertFacStandingsStmt},
		{&d.getStandingsStmt, getStandingsStmt},
		{&d.deleteToonsStmt, deleteToonsStmt},
		{&d.clearOutpostsStmt, clearOutpostsStmt},
		{&d.insertOutpostsStmt, insertOutpostsStmt},
		{&d.searchStationsStmt, searchStationsStmt},
		{&d.getStationStmt, getStationStmt},
		{&d.clearBlueprintsStmt, clearBlueprintsStmt},
		{&d.insertBlueprintStmt, insertBlueprintStmt},
		{&d.getBlueprintsStmt, getBlueprintsStmt},
		{&d.clearAssetsStmt, clearAssetsStmt},
		{&d.insertAssetStmt, insertAssetStmt},
		{&d.getAssetsStmt, getAssetsStmt},
		{&d.unusedSalvageStmt, unusedSalvageStmt},
	}

	for _, s := range stmts {
		prepared, err := dbConn.Preparex(s.statementText)
		if err != nil {
			log.Fatalf("Unable to prepare statement: %v\n%v", err, s.statementText)
		}
		// Pointer magic, stage 2: Dereference the pointer to the pointer
		// and set it to point to the statement we just prepared.
		*s.preparedStatement = prepared
	}

	return d, nil
}
Example #28
0
func (r *RDPG) connect() (db *sqlx.DB, err error) {
	db, err = sqlx.Connect("postgres", r.URI)
	if err != nil {
		log.Error(fmt.Sprintf("rdpg.Node#Connect() %s ! %s", r.URI, err))
	}
	return db, err
}
Example #29
0
func InitSQLX(dialect, args string) (*sqlx.DB, error) {
	var db *sqlx.DB
	var err error

	var i int
retry:
	for {
		db, err = sqlx.Connect(dialect, args)
		switch {
		case err == nil:
			break retry
		case i >= RETRY:
			return nil, err
		default:
			logs.Error(err)
			i++
		}
		time.Sleep(TIMEOUT)
	}

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

	return db, nil
}
Example #30
0
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)
	}
}