LBRYCommunity/sqlboiler
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity

Rename everything.

Browse source
This commit is contained in:
Aaron 2016-03-22 21:25:57 -07:00
parent 48a9ba8d29
commit 1394489a63
11 changed files with 99 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -9,7 +9,7 @@ SQLBoiler is a tool to generate Go boilerplate code for database interactions. S
# Supports?
* Postgres
If anyone wants to create a driver for their own database it's easy very to do. All you need to do is create a driver in the ````/dbdrivers```` package that implements the ````DBDriver```` interface (you can use ````postgres_driver.go```` as an example), and add your driver to the switch statement in the ````initDBDriver()```` function in ````sqlboiler.go````. That's it!
If anyone wants to create a driver for their own database it's easy very to do. All you need to do is create a driver in the ````/dbdrivers```` package that implements the ````Interface```` interface (you can use ````postgres_driver.go```` as an example), and add your driver to the switch statement in the ````initInterface()```` function in ````sqlboiler.go````. That's it!
I've included templates for struct definitions and select, delete and insert statement helpers. Editing the output of the existing templates is as easy as modifying the template file, but to add new types of statements you'll need to add a new command and a new template. This is also very easy to do, and you can use any of the existing command files as an example.

2
cmds/commands.go
View file

@ -34,7 +34,7 @@ var sqlBoilerDefaultTestImports = imports{
}
// sqlBoilerConditionalTypeImports imports are only included in the template output
// if the database requires one of the following special types. Check ParseTableInfo
// if the database requires one of the following special types. Check TranslateColumn
// to see the type assignments.
var sqlBoilerConditionalTypeImports = map[string]imports{
"null.Int": imports{

2
cmds/imports.go
View file

@ -40,7 +40,7 @@ func combineImports(a, b imports) imports {
return c
}
func combineConditionalTypeImports(a imports, b map[string]imports, columns []dbdrivers.DBColumn) imports {
func combineConditionalTypeImports(a imports, b map[string]imports, columns []dbdrivers.Column) imports {
tmpImp := imports{
standard: make(importList, len(a.standard)),
thirdparty: make(importList, len(a.thirdparty)),

10
cmds/imports_test.go
View file

@ -30,17 +30,17 @@ func TestCombineConditionalTypeImports(t *testing.T) {
},
}
cols := []dbdrivers.DBColumn{
dbdrivers.DBColumn{
cols := []dbdrivers.Column{
dbdrivers.Column{
Type: "null.Time",
},
dbdrivers.DBColumn{
dbdrivers.Column{
Type: "null.Time",
},
dbdrivers.DBColumn{
dbdrivers.Column{
Type: "time.Time",
},
dbdrivers.DBColumn{
dbdrivers.Column{
Type: "null.Float",
},
}

6
cmds/shared.go
View file

@ -18,16 +18,16 @@ type CobraRunFunc func(cmd *cobra.Command, args []string)
// output file, if one is specified with a flag.
type CmdData struct {
Tables []string
Columns [][]dbdrivers.DBColumn
Columns [][]dbdrivers.Column
PkgName string
OutFolder string
DBDriver dbdrivers.DBDriver
Interface dbdrivers.Interface
}
// tplData is used to pass data to the template
type tplData struct {
Table string
Columns []dbdrivers.DBColumn
Columns []dbdrivers.Column
PkgName string
}

22
cmds/sqlboiler.go
View file

@ -55,7 +55,7 @@ func init() {
// sqlBoilerPostRun cleans up the output file and database connection once
// all commands are finished running.
func sqlBoilerPostRun(cmd *cobra.Command, args []string) {
cmdData.DBDriver.Close()
cmdData.Interface.Close()
}
// sqlBoilerPreRun executes before all commands start running. Its job is to
@ -68,11 +68,11 @@ func sqlBoilerPreRun(cmd *cobra.Command, args []string) {
var err error
cmdData = &CmdData{}
// Initialize the cmdData.DBDriver
initDBDriver()
// Initialize the cmdData.Interface
initInterface()
// Connect to the driver database
if err = cmdData.DBDriver.Open(); err != nil {
if err = cmdData.Interface.Open(); err != nil {
errorQuit(fmt.Errorf("Unable to connect to the database: %s", err))
}
@ -103,9 +103,9 @@ func sqlBoilerPreRun(cmd *cobra.Command, args []string) {
}
}
// initDBDriver attempts to set the cmdData DBDriver based off the passed in
// initInterface attempts to set the cmdData Interface based off the passed in
// driver flag value. If an invalid flag string is provided the program will exit.
func initDBDriver() {
func initInterface() {
// Retrieve driver flag
driverName := SQLBoiler.PersistentFlags().Lookup("driver").Value.String()
if driverName == "" {
@ -115,7 +115,7 @@ func initDBDriver() {
// Create a driver based off driver flag
switch driverName {
case "postgres":
cmdData.DBDriver = dbdrivers.NewPostgresDriver(
cmdData.Interface = dbdrivers.NewPostgresDriver(
cfg.Postgres.User,
cfg.Postgres.Pass,
cfg.Postgres.DBName,
@ -124,7 +124,7 @@ func initDBDriver() {
)
}
if cmdData.DBDriver == nil {
if cmdData.Interface == nil {
errorQuit(errors.New("An invalid driver name was provided"))
}
}
@ -147,7 +147,7 @@ func initTables() {
if len(cmdData.Tables) == 0 {
// get all table names
var err error
cmdData.Tables, err = cmdData.DBDriver.GetAllTables()
cmdData.Tables, err = cmdData.Interface.AllTables()
if err != nil {
errorQuit(fmt.Errorf("Unable to get all table names: %s", err))
}
@ -159,11 +159,11 @@ func initTables() {
}
// initColumns builds a description of each table (column name, column type)
// and assigns it to cmdData.Columns, the slice of dbdrivers.DBColumn slices.
// and assigns it to cmdData.Columns, the slice of dbdrivers.Column slices.
func initColumns() {
// loop over table Names and build Columns
for i := 0; i < len(cmdData.Tables); i++ {
tInfo, err := cmdData.DBDriver.GetTableInfo(cmdData.Tables[i])
tInfo, err := cmdData.Interface.Columns(cmdData.Tables[i])
if err != nil {
errorQuit(fmt.Errorf("Unable to get the table info: %s", err))
}

8
cmds/sqlboiler_test.go
View file

@ -14,8 +14,8 @@ import (
func init() {
cmdData = &CmdData{
Tables: []string{"patrick_table", "spiderman"},
Columns: [][]dbdrivers.DBColumn{
[]dbdrivers.DBColumn{
Columns: [][]dbdrivers.Column{
[]dbdrivers.Column{
{Name: "patrick_column", Type: "string", IsNullable: false},
{Name: "aaron_column", Type: "null.String", IsNullable: true},
{Name: "id", Type: "null.Int", IsNullable: true},
@ -24,13 +24,13 @@ func init() {
{Name: "fun_time", Type: "time.Time", IsNullable: false},
{Name: "cool_stuff_forever", Type: "[]byte", IsNullable: false},
},
[]dbdrivers.DBColumn{
[]dbdrivers.Column{
{Name: "patrick", Type: "string", IsNullable: false},
},
},
PkgName: "patrick",
OutFolder: "",
DBDriver: nil,
Interface: nil,
}
}

32
cmds/template_funcs.go
View file

@ -183,11 +183,11 @@ func makeDBName(tableName, colName string) string {
return tableName + "_" + colName
}
// updateParamNames takes a []DBColumn and returns a comma seperated
// updateParamNames takes a []Column and returns a comma seperated
// list of parameter names for the update statement template SET clause.
// eg: col1=$1,col2=$2,col3=$3
// Note: updateParamNames will exclude the PRIMARY KEY column.
func updateParamNames(columns []dbdrivers.DBColumn) string {
func updateParamNames(columns []dbdrivers.Column) string {
names := make([]string, 0, len(columns))
counter := 0
for _, c := range columns {
@ -200,11 +200,11 @@ func updateParamNames(columns []dbdrivers.DBColumn) string {
return strings.Join(names, ",")
}
// updateParamVariables takes a prefix and a []DBColumns and returns a
// updateParamVariables takes a prefix and a []Columns and returns a
// comma seperated list of parameter variable names for the update statement.
// eg: prefix("o."), column("name_id") -> "o.NameID, ..."
// Note: updateParamVariables will exclude the PRIMARY KEY column.
func updateParamVariables(prefix string, columns []dbdrivers.DBColumn) string {
func updateParamVariables(prefix string, columns []dbdrivers.Column) string {
names := make([]string, 0, len(columns))
for _, c := range columns {
@ -218,9 +218,9 @@ func updateParamVariables(prefix string, columns []dbdrivers.DBColumn) string {
return strings.Join(names, ", ")
}
// insertParamNames takes a []DBColumn and returns a comma seperated
// insertParamNames takes a []Column and returns a comma seperated
// list of parameter names for the insert statement template.
func insertParamNames(columns []dbdrivers.DBColumn) string {
func insertParamNames(columns []dbdrivers.Column) string {
names := make([]string, 0, len(columns))
for _, c := range columns {
names = append(names, c.Name)
@ -228,9 +228,9 @@ func insertParamNames(columns []dbdrivers.DBColumn) string {
return strings.Join(names, ", ")
}
// insertParamFlags takes a []DBColumn and returns a comma seperated
// insertParamFlags takes a []Column and returns a comma seperated
// list of parameter flags for the insert statement template.
func insertParamFlags(columns []dbdrivers.DBColumn) string {
func insertParamFlags(columns []dbdrivers.Column) string {
params := make([]string, 0, len(columns))
for i := range columns {
params = append(params, fmt.Sprintf("$%d", i+1))
@ -238,10 +238,10 @@ func insertParamFlags(columns []dbdrivers.DBColumn) string {
return strings.Join(params, ", ")
}
// insertParamVariables takes a prefix and a []DBColumns and returns a
// insertParamVariables takes a prefix and a []Columns and returns a
// comma seperated list of parameter variable names for the insert statement.
// For example: prefix("o."), column("name_id") -> "o.NameID, ..."
func insertParamVariables(prefix string, columns []dbdrivers.DBColumn) string {
func insertParamVariables(prefix string, columns []dbdrivers.Column) string {
names := make([]string, 0, len(columns))
for _, c := range columns {
@ -252,11 +252,11 @@ func insertParamVariables(prefix string, columns []dbdrivers.DBColumn) string {
return strings.Join(names, ", ")
}
// selectParamNames takes a []DBColumn and returns a comma seperated
// selectParamNames takes a []Column and returns a comma seperated
// list of parameter names with for the select statement template.
// It also uses the table name to generate the "AS" part of the statement, for
// example: var_name AS table_name_var_name, ...
func selectParamNames(tableName string, columns []dbdrivers.DBColumn) string {
func selectParamNames(tableName string, columns []dbdrivers.Column) string {
selects := make([]string, 0, len(columns))
for _, c := range columns {
statement := fmt.Sprintf("%s AS %s", c.Name, makeDBName(tableName, c.Name))
@ -266,9 +266,9 @@ func selectParamNames(tableName string, columns []dbdrivers.DBColumn) string {
return strings.Join(selects, ", ")
}
// scanParamNames takes a []DBColumn and returns a comma seperated
// scanParamNames takes a []Column and returns a comma seperated
// list of parameter names for use in a db.Scan() call.
func scanParamNames(object string, columns []dbdrivers.DBColumn) string {
func scanParamNames(object string, columns []dbdrivers.Column) string {
scans := make([]string, 0, len(columns))
for _, c := range columns {
statement := fmt.Sprintf("&%s.%s", object, titleCase(c.Name))
@ -279,7 +279,7 @@ func scanParamNames(object string, columns []dbdrivers.DBColumn) string {
}
// hasPrimaryKey returns true if one of the columns passed in is a primary key
func hasPrimaryKey(columns []dbdrivers.DBColumn) bool {
func hasPrimaryKey(columns []dbdrivers.Column) bool {
for _, c := range columns {
if c.IsPrimaryKey {
return true
@ -290,7 +290,7 @@ func hasPrimaryKey(columns []dbdrivers.DBColumn) bool {
}
// getPrimaryKey returns the primary key column name if one is present
func getPrimaryKey(columns []dbdrivers.DBColumn) string {
func getPrimaryKey(columns []dbdrivers.Column) string {
for _, c := range columns {
if c.IsPrimaryKey {
return c.Name

6
cmds/template_funcs_test.go
View file

@ -6,7 +6,7 @@ import (
"github.com/pobri19/sqlboiler/dbdrivers"
)
var testColumns = []dbdrivers.DBColumn{
var testColumns = []dbdrivers.Column{
{Name: "friend_column", Type: "int", IsNullable: false, IsPrimaryKey: false},
{Name: "enemy_column_thing", Type: "string", IsNullable: true, IsPrimaryKey: false},
}
@ -98,7 +98,7 @@ func TestMakeDBName(t *testing.T) {
func TestUpdateParamNames(t *testing.T) {
t.Parallel()
var testCols = []dbdrivers.DBColumn{
var testCols = []dbdrivers.Column{
{Name: "id", Type: "int", IsNullable: false, IsPrimaryKey: true},
{Name: "friend_column", Type: "int", IsNullable: false, IsPrimaryKey: false},
{Name: "enemy_column_thing", Type: "string", IsNullable: true, IsPrimaryKey: false},
@ -113,7 +113,7 @@ func TestUpdateParamNames(t *testing.T) {
func TestUpdateParamVariables(t *testing.T) {
t.Parallel()
var testCols = []dbdrivers.DBColumn{
var testCols = []dbdrivers.Column{
{Name: "id", Type: "int", IsNullable: false, IsPrimaryKey: true},
{Name: "friend_column", Type: "int", IsNullable: false, IsPrimaryKey: false},
{Name: "enemy_column_thing", Type: "string", IsNullable: true, IsPrimaryKey: false},

41
dbdrivers/db_driver.go
View file

@ -1,23 +1,18 @@
package dbdrivers
// DBDriver is an interface that handles the operation uniqueness of each
// type of database connection. For example, queries to obtain schema data
// will vary depending on what type of database software is in use.
// The goal of the DBDriver is to retrieve all table names in a database
// using GetAllTables() if no table names are provided via flags,
// to handle the database connection using Open() and Close(), and to
// build the table information using GetTableInfo() and ParseTableInfo()
type DBDriver interface {
// GetAllTables connects to the database and retrieves all "public" table names
GetAllTables() ([]string, error)
// Interface for a database driver. Functionality required to support a specific
// database type (eg, MySQL, Postgres etc.)
type Interface interface {
// AllTables connects to the database and retrieves all "public" table names
AllTables() ([]string, error)
// GetTableInfo retrieves column information about the table.
GetTableInfo(tableName string) ([]DBColumn, error)
// Columns retrieves column information about the table.
Columns(tableName string) ([]Column, error)
// ParseTableInfo builds a DBColumn out of a column name and column type.
// Its main responsibility is to convert database types to Go types, for example
// "varchar" to "string".
ParseTableInfo(name, colType string, isNullable bool, isPrimary bool) DBColumn
// TranslateColumn builds a Column out of a column metadata.
// Its main responsibility is to convert database types to Go types, for
// example "varchar" to "string".
TranslateColumn(Column) Column
// Open the database connection
Open() error
@ -26,9 +21,17 @@ type DBDriver interface {
Close()
}
// DBColumn holds information about a database column name.
// Column types are Go types, converted by ParseTableInfo.
type DBColumn struct {
// Table metadata from the database schema.
type Table struct {
Name string
Columns []Column
IsJoinTable bool
}
// Column holds information about a database column.
// Types are Go types, converted by TranslateColumn.
type Column struct {
Name string
Type string
IsPrimaryKey bool

65
dbdrivers/postgres_driver.go
View file

@ -44,11 +44,11 @@ func (d *PostgresDriver) Close() {
d.dbConn.Close()
}
// GetAllTables connects to the postgres database and
// AllTables connects to the postgres database and
// retrieves all table names from the information_schema where the
// table schema is public. It excludes common migration tool tables
// such as gorp_migrations
func (d *PostgresDriver) GetAllTables() ([]string, error) {
func (d *PostgresDriver) AllTables() ([]string, error) {
var tableNames []string
rows, err := d.dbConn.Query(`select table_name from
@ -71,12 +71,12 @@ func (d *PostgresDriver) GetAllTables() ([]string, error) {
return tableNames, nil
}
// GetTableInfo takes a table name and attempts to retrieve the table information
// Columns takes a table name and attempts to retrieve the table information
// from the database information_schema.columns. It retrieves the column names
// and column types and returns those as a []DBColumn after ParseTableInfo()
// and column types and returns those as a []Column after TranslateColumn()
// converts the SQL types to Go types, for example: "varchar" to "string"
func (d *PostgresDriver) GetTableInfo(tableName string) ([]DBColumn, error) {
var table []DBColumn
func (d *PostgresDriver) Columns(tableName string) ([]Column, error) {
var table []Column
rows, err := d.dbConn.Query(`
SELECT c.column_name, c.data_type, c.is_nullable,
@ -104,56 +104,55 @@ func (d *PostgresDriver) GetTableInfo(tableName string) ([]DBColumn, error) {
if err := rows.Scan(&colName, &colType, &isNullable, &isPrimary); err != nil {
return nil, err
}
t := d.ParseTableInfo(colName, colType, isNullable == "YES", isPrimary == "PRIMARY KEY")
t := d.TranslateColumn(Column{
Name: colName,
Type: colType,
IsNullable: isNullable == "YES",
IsPrimaryKey: isPrimary == "PRIMARY KEY",
})
table = append(table, t)
}
return table, nil
}
// ParseTableInfo converts postgres database types to Go types, for example
// TranslateColumn converts postgres database types to Go types, for example
// "varchar" to "string" and "bigint" to "int64". It returns this parsed data
// as a DBColumn object.
func (d *PostgresDriver) ParseTableInfo(colName, colType string, isNullable bool, isPrimary bool) DBColumn {
var t DBColumn
t.Name = colName
t.IsPrimaryKey = isPrimary
t.IsNullable = isNullable
if isNullable {
switch colType {
// as a Column object.
func (d *PostgresDriver) TranslateColumn(c Column) Column {
if c.IsNullable {
switch c.Type {
case "bigint", "bigserial", "integer", "smallint", "smallserial", "serial":
t.Type = "null.Int"
c.Type = "null.Int"
case "bit", "bit varying", "character", "character varying", "cidr", "inet", "json", "macaddr", "text", "uuid", "xml":
t.Type = "null.String"
c.Type = "null.String"
case "boolean":
t.Type = "null.Bool"
c.Type = "null.Bool"
case "date", "interval", "time", "timestamp without time zone", "timestamp with time zone":
t.Type = "null.Time"
c.Type = "null.Time"
case "double precision", "money", "numeric", "real":
t.Type = "null.Float"
c.Type = "null.Float"
default:
t.Type = "null.String"
c.Type = "null.String"
}
} else {
switch colType {
switch c.Type {
case "bigint", "bigserial", "integer", "smallint", "smallserial", "serial":
t.Type = "int64"
c.Type = "int64"
case "bit", "bit varying", "character", "character varying", "cidr", "inet", "json", "macaddr", "text", "uuid", "xml":
t.Type = "string"
c.Type = "string"
case "bytea":
t.Type = "[]byte"
c.Type = "[]byte"
case "boolean":
t.Type = "bool"
c.Type = "bool"
case "date", "interval", "time", "timestamp without time zone", "timestamp with time zone":
t.Type = "time.Time"
c.Type = "time.Time"
case "double precision", "money", "numeric", "real":
t.Type = "float64"
c.Type = "float64"
default:
t.Type = "string"
c.Type = "string"
}
}
return t
return c
}