func (s *source) tableColumns(tableName string) ([]string, error) {
// Making sure this table is allocated.
tableSchema := s.schema.Table(tableName)
if len(tableSchema.Columns) > 0 {
return tableSchema.Columns, nil
}
q := fmt.Sprintf(`PRAGMA TABLE_INFO('%s')`, tableName)
rows, err := s.doRawQuery(q)
if s.columns == nil {
s.columns = make(map[string][]columnSchemaT)
}
columns := []columnSchemaT{}
if err = sqlutil.FetchRows(rows, &columns); err != nil {
return nil, err
}
s.columns[tableName] = columns
s.schema.TableInfo[tableName].Columns = make([]string, 0, len(s.columns))
for i := range s.columns[tableName] {
s.schema.TableInfo[tableName].Columns = append(s.schema.TableInfo[tableName].Columns, s.columns[tableName][i].Name)
}
return s.schema.TableInfo[tableName].Columns, nil
}
func (self *Dh) Count(query string) int64 {
var errs api.Err
drv := self.SqlDriver()
rows, err := drv.Query(query)
if err != nil {
errs.Push(api.Msg{
Field: "Database select All error: ",
Error: err.Error(),
})
return 0
}
type Total struct {
Count int64 `db:"count"`
}
total := []Total{}
// Mapping to an array.
if err = sqlutil.FetchRows(rows, &total); err != nil {
errs.Push(api.Msg{
Field: "Database select All error: ",
Error: err.Error(),
})
}
defer rows.Close()
return total[0].Count
}
// Returns a collection instance by name.
func (self *source) Collection(names ...string) (db.Collection, error) {
var rows *sql.Rows
var err error
if len(names) == 0 {
return nil, db.ErrMissingCollectionName
}
col := &table{
source: self,
names: names,
}
columns_t := []columnSchema_t{}
for _, name := range names {
chunks := strings.SplitN(name, " ", 2)
if len(chunks) > 0 {
name = chunks[0]
if err := self.tableExists(name); err != nil {
return nil, err
}
// Getting columns
rows, err = self.doQuery(sqlgen.Statement{
Type: sqlgen.SqlSelect,
Table: sqlgen.Table{`information_schema.columns`},
Columns: sqlgen.Columns{
{`column_name`},
{`data_type`},
},
Where: sqlgen.Where{
sqlgen.ColumnValue{sqlgen.Column{`table_catalog`}, `=`, sqlPlaceholder},
sqlgen.ColumnValue{sqlgen.Column{`table_name`}, `=`, sqlPlaceholder},
},
}, self.config.Database, name)
if err != nil {
return nil, err
}
if err = sqlutil.FetchRows(rows, &columns_t); err != nil {
return nil, err
}
col.Columns = make([]string, 0, len(columns_t))
for _, column := range columns_t {
col.Columns = append(col.Columns, column.Name)
}
}
}
return col, nil
}
func (s *source) tableColumns(tableName string) ([]string, error) {
// Making sure this table is allocated.
tableSchema := s.schema.Table(tableName)
if len(tableSchema.Columns) > 0 {
return tableSchema.Columns, nil
}
stmt := sqlgen.Statement{
Type: sqlgen.SqlSelect,
Table: sqlgen.Table{
`information_schema.columns`,
},
Columns: sqlgen.Columns{
{`column_name`},
{`data_type`},
},
Where: sqlgen.Where{
sqlgen.ColumnValue{
sqlgen.Column{`table_catalog`},
`=`,
sqlPlaceholder,
},
sqlgen.ColumnValue{
sqlgen.Column{`table_name`},
`=`,
sqlPlaceholder,
},
},
}
var rows *sql.Rows
var err error
if rows, err = s.doQuery(stmt, s.schema.Name, tableName); err != nil {
return nil, err
}
tableFields := []columnSchemaT{}
if err = sqlutil.FetchRows(rows, &tableFields); err != nil {
return nil, err
}
s.schema.TableInfo[tableName].Columns = make([]string, 0, len(tableFields))
for i := range tableFields {
s.schema.TableInfo[tableName].Columns = append(s.schema.TableInfo[tableName].Columns, tableFields[i].Name)
}
return s.schema.TableInfo[tableName].Columns, nil
}
func TestRawQuery(t *testing.T) {
var sess db.Database
var rows *sql.Rows
var err error
var drv *sql.DB
type publicationType struct {
ID int64 `db:"id,omitempty"`
Title string `db:"title"`
AuthorID int64 `db:"author_id"`
}
if sess, err = db.Open(Adapter, settings); err != nil {
t.Fatal(err)
}
defer sess.Close()
drv = sess.Driver().(*sql.DB)
rows, err = drv.Query(`
SELECT
p.id,
p.title AS publication_title,
a.name AS artist_name
FROM
artist AS a,
publication AS p
WHERE
a.id = p.author_id
`)
if err != nil {
t.Fatal(err)
}
var all []publicationType
if err = sqlutil.FetchRows(rows, &all); err != nil {
t.Fatal(err)
}
if len(all) != 9 {
t.Fatalf("Expecting some rows.")
}
}
// Returns a collection instance by name.
func (self *source) Collection(names ...string) (db.Collection, error) {
if len(names) == 0 {
return nil, db.ErrMissingCollectionName
}
col := &table{
source: self,
names: names,
}
var columns_t []columnSchema_t
for _, name := range names {
chunks := strings.SplitN(name, " ", 2)
if len(chunks) > 0 {
name = chunks[0]
if err := self.tableExists(name); err != nil {
return nil, err
}
rows, err := self.doRawQuery(fmt.Sprintf(`PRAGMA TABLE_INFO('%s')`, name))
if err != nil {
return nil, err
}
if err = sqlutil.FetchRows(rows, &columns_t); err != nil {
return nil, err
}
col.Columns = make([]string, 0, len(columns_t))
for _, column := range columns_t {
col.Columns = append(col.Columns, strings.ToLower(column.Name))
}
}
}
return col, nil
}
// Dumps all results into a pointer to an slice of structs or maps.
func (r *result) All(dst interface{}) error {
var err error
if r.cursor != nil {
return db.ErrQueryIsPending
}
// Current cursor.
err = r.setCursor()
if err != nil {
return err
}
defer r.Close()
// Fetching all results within the cursor.
err = sqlutil.FetchRows(r.cursor, dst)
return err
}
// Returns a collection instance by name.
func (self *source) Collection(names ...string) (db.Collection, error) {
if len(names) == 0 {
return nil, db.ErrMissingCollectionName
}
col := &table{
source: self,
names: names,
}
columns_t := []columnSchema_t{}
for _, name := range names {
chunks := strings.SplitN(name, " ", 2)
if len(chunks) > 0 {
name = chunks[0]
if err := self.tableExists(name); err != nil {
return nil, err
}
rows, err := self.doQuery(sqlgen.Statement{
Type: sqlgen.SqlSelect,
Table: sqlgen.Table{`__Column`},
Columns: sqlgen.Columns{
{`Name`},
{`Type`},
},
Where: sqlgen.Where{
sqlgen.ColumnValue{sqlgen.Column{`TableName`}, `==`, sqlPlaceholder},
},
}, name)
if err != nil {
return nil, err
}
if err = sqlutil.FetchRows(rows, &columns_t); err != nil {
return nil, err
}
col.Columns = make([]string, len(columns_t))
col.columnTypes = make(map[string]reflect.Kind)
for i, column := range columns_t {
column.DataType = strings.ToLower(column.DataType)
col.Columns[i] = column.ColumnName
// Default properties.
dtype := column.DataType
ctype := reflect.String
// Guessing datatypes.
switch dtype {
case `int`:
ctype = reflect.Int
case `int8`:
ctype = reflect.Int8
case `int16`:
ctype = reflect.Int16
case `int32`, `rune`:
ctype = reflect.Int32
case `int64`:
ctype = reflect.Int64
case `uint`:
ctype = reflect.Uint
case `uint8`:
ctype = reflect.Uint8
case `uint16`:
ctype = reflect.Uint16
case `uint32`:
ctype = reflect.Uint32
case `uint64`:
ctype = reflect.Uint64
case `float64`:
ctype = reflect.Float64
case `float32`:
ctype = reflect.Float32
case `time`:
ctype = timeType
default:
ctype = reflect.String
}
col.columnTypes[column.ColumnName] = ctype
}
}
}
return col, nil
}