func sqlGetRow(rows *sqlx.Rows, bytesToStrings, idTo_id bool) (*map[string]interface{}, error) {
results := make(map[string]interface{})
err := rows.MapScan(results)
if err != nil {
log.Println(err)
} else {
if idTo_id {
// Convert "id" column to "_id" for mongo
if _, ok := results["id"]; ok {
// Mangle id, because mongo is persnickity
results["_id"] = results["id"]
delete(results, "id")
}
}
if bytesToStrings {
// Convert byte arrays to strings
for k, v := range results {
if _, ok := v.([]byte); ok {
// Damn. Byte. Arrays. Sqlx.
results[k] = string(v.([]byte))
}
}
}
}
return &results, err
}
func (tx *Transaction) decodeRows(s *schema.Schema, rows *sqlx.Rows, list []*schema.Resource) ([]*schema.Resource, error) {
for rows.Next() {
resourceData := map[string]interface{}{}
data := map[string]interface{}{}
rows.MapScan(data)
var resource *schema.Resource
tx.decode(s, s.GetDbTableName(), data, resourceData)
resource, err := schema.NewResource(s, resourceData)
if err != nil {
return nil, fmt.Errorf("Failed to decode rows")
}
list = append(list, resource)
}
return list, nil
}
func (r mapRower) scanRow(rows *sqlx.Rows) (Value, error) {
m := make(map[string]interface{})
e := rows.MapScan(m)
return m, e
}
/*
Run postgres task
*/
func (p *PostgresTask) Run(r *http.Request, data map[string]interface{}) (response *Response) {
response = NewResponse(http.StatusOK)
queryresults := []*Response{}
for _, query := range p.config.Queries {
qresponse := NewResponse(http.StatusOK).StripStatusData()
var (
args []interface{}
db *sqlx.DB
err error
url string
rows *sqlx.Rows
Rows []map[string]interface{}
errq error
)
if url, err = p.Interpolate(query.URL, data); err != nil {
qresponse.Error(err)
goto Append
}
// interpolate all args
args = []interface{}{}
for _, arg := range query.Args {
interpolated, e := p.Interpolate(arg, data)
if e != nil {
qresponse.Error(e)
goto Append
}
args = append(args, interpolated)
}
// add query with args to response?
if p.config.ReturnQueries {
qresponse.AddValue("query", query.Query).AddValue("args", args)
}
if db, err = sqlx.Connect("postgres", url); err != nil {
if err, ok := err.(*pq.Error); ok {
qresponse.AddValue("error_code", err.Code.Name())
}
qresponse.Error(err)
goto Append
}
// run query
rows, errq = db.Queryx(query.Query, args...)
if errq != nil {
if errq, ok := errq.(*pq.Error); ok {
qresponse.AddValue("error_code", errq.Code.Name())
}
qresponse.Error(errq)
goto Append
}
Rows = []map[string]interface{}{}
for rows.Next() {
results := make(map[string]interface{})
err = rows.MapScan(results)
if err != nil {
if err, ok := err.(*pq.Error); ok {
qresponse.AddValue("error_code", err.Code.Name())
}
qresponse.Error(err)
goto Append
}
Rows = append(Rows, results)
}
qresponse.Result(Rows)
Append:
queryresults = append(queryresults, qresponse)
}
// single result
if p.config.singleResultIndex != -1 {
response.Result(queryresults[p.config.singleResultIndex])
} else {
response.Result(queryresults)
}
return
}
/*
Run mysql task.
*/
func (m *MySQLTask) Run(r *http.Request, data map[string]interface{}) (response *Response) {
response = NewResponse(http.StatusOK)
queries := []*Response{}
var (
db *sqlx.DB
rows *sqlx.Rows
err error
)
for _, query := range m.config.Queries {
var (
Rows []map[string]interface{}
)
args := []interface{}{}
qr := NewResponse(http.StatusOK).StripStatusData()
var url string
if url, err = m.Interpolate(query.URL, data); err != nil {
qr.Error(err)
goto Append
}
if m.config.ReturnQueries {
qr.AddValue("query", query.Query)
}
if db, err = sqlx.Open("mysql", url); err != nil {
qr.Error(err.Error())
if err, ok := err.(*mysql.MySQLError); ok {
qr.AddValue("error_code", err.Number)
}
goto Append
}
for _, arg := range query.Args {
var a string
if a, err = m.Interpolate(arg, data); err != nil {
qr.Error(err)
goto Append
}
args = append(args, a)
}
if m.config.ReturnQueries {
qr.AddValue("args", args)
}
// run query
rows, err = db.Queryx(query.Query, args...)
if err != nil {
qr.Error(err)
if err, ok := err.(*mysql.MySQLError); ok {
qr.AddValue("error_code", err.Number)
}
goto Append
}
Rows = []map[string]interface{}{}
for rows.Next() {
results := make(map[string]interface{})
err = rows.MapScan(results)
if err != nil {
qr.Error(err)
goto Append
}
Rows = append(Rows, results)
}
qr.Result(Rows)
Append:
queries = append(queries, qr)
}
// single result
if m.config.singleResultIndex != -1 {
response.Result(queries[m.config.singleResultIndex])
} else {
response.Result(queries)
}
return
}
