129 lines
3.0 KiB
Go
129 lines
3.0 KiB
Go
package storage
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/spf13/viper"
|
|
|
|
"github.com/jinzhu/gorm"
|
|
_ "github.com/jinzhu/gorm/dialects/postgres"
|
|
)
|
|
|
|
type PostgresDataStore struct {
|
|
Dbhost string
|
|
Dbport string
|
|
Dbuser string
|
|
Dbpass string
|
|
Dbname string
|
|
MaxOpenConnections int
|
|
DB *gorm.DB
|
|
}
|
|
|
|
// InitPostgresDb initializes the database
|
|
func InitPostgresDb() (datastore DataStore, err error) {
|
|
|
|
d := PostgresDataStore{}
|
|
|
|
// Initialize the database
|
|
d.dbConfig()
|
|
|
|
psqlInfo := fmt.Sprintf("host=%s port=%s user=%s "+
|
|
"password=%s dbname=%s sslmode=disable",
|
|
d.Dbhost, d.Dbport,
|
|
d.Dbuser, d.Dbpass, d.Dbname)
|
|
|
|
d.DB, err = gorm.Open(viper.GetString("datastore.dialect"), psqlInfo)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Since the error returned from “Open” does not check if the datasource is valid calling
|
|
// Ping on the database is required
|
|
err = d.DB.DB().Ping()
|
|
if err != nil {
|
|
log.Fatal("Error: Could not establish a connection with the database")
|
|
}
|
|
|
|
// Setup connection pool
|
|
d.DB.DB().SetMaxOpenConns(d.MaxOpenConnections)
|
|
|
|
fmt.Println("Successfully connected!")
|
|
// listTables()
|
|
return &d, nil
|
|
}
|
|
|
|
func (d *PostgresDataStore) dbConfig() {
|
|
|
|
d.Dbhost = viper.GetString("datastore.host")
|
|
if d.Dbhost == "" {
|
|
d.Dbhost = "localhost"
|
|
}
|
|
d.Dbport = viper.GetString("datastore.port")
|
|
if d.Dbport == "" {
|
|
d.Dbport = "5432"
|
|
}
|
|
d.Dbuser = viper.GetString("datastore.user")
|
|
if d.Dbuser == "" {
|
|
d.Dbuser = "postgres"
|
|
}
|
|
d.Dbpass = viper.GetString("datastore.password")
|
|
if d.Dbpass == "" {
|
|
d.Dbpass = "root"
|
|
}
|
|
d.Dbname = viper.GetString("datastore.schema")
|
|
if d.Dbname == "" {
|
|
d.Dbname = "mobtools"
|
|
}
|
|
d.MaxOpenConnections = viper.GetInt("datastore.maxOpenConnections")
|
|
}
|
|
|
|
// ExecuteQuery executes the query on the DB
|
|
func (d *PostgresDataStore) ExecuteQuery(query string) ([]map[string]interface{}, error) {
|
|
rows, err := d.DB.Raw(query).Rows()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cols, err := rows.Columns()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
defer rows.Close()
|
|
values := make([]map[string]interface{}, 0)
|
|
|
|
for rows.Next() {
|
|
// Create a slice of interface{}'s to represent each column,
|
|
// and a second slice to contain pointers to each item in the columns slice.
|
|
columns := make([]interface{}, len(cols))
|
|
columnPointers := make([]interface{}, len(cols))
|
|
for i := range columns {
|
|
columnPointers[i] = &columns[i]
|
|
}
|
|
|
|
// Scan the result into the column pointers...
|
|
if err := rows.Scan(columnPointers...); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Create our map, and retrieve the value for each column from the pointers slice,
|
|
// storing it in the map with the name of the column as the key.
|
|
m := make(map[string]interface{})
|
|
for i, colName := range cols {
|
|
val := columnPointers[i].(*interface{})
|
|
m[colName] = *val
|
|
}
|
|
|
|
// Outputs: map[columnName:value columnName2:value2 columnName3:value3 ...]
|
|
fmt.Println(m)
|
|
values = append(values, m)
|
|
}
|
|
|
|
return values, nil
|
|
}
|
|
|
|
func (d *PostgresDataStore) GetDatastore() *gorm.DB {
|
|
return d.DB
|
|
}
|