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

Finished most of the stripping

Browse source
This commit is contained in:
Patrick O'brien 2016-03-28 01:03:14 +10:00
parent c74ed4e75f
commit 27cafdd2fb
15 changed files with 401 additions and 723 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

101
cmds/boil.go
View file

@ -1,101 +0,0 @@
package cmds
import (
"sort"
"github.com/spf13/cobra"
)
var boilCmd = &cobra.Command{
Use: "boil",
Short: "Generates ALL templates by running every command alphabetically",
}
// boilRun executes every sqlboiler command, starting with structs.
func boilRun(cmd *cobra.Command, args []string) {
commandNames := buildCommandList()
// Prepend "struct" command to templateNames slice so it sits at top of sort
commandNames = append([]string{"struct"}, commandNames...)
// Create a testCommandNames with "driverName_main" prepended to the front for the test templates
// the main template initializes all of the testing assets
testCommandNames := append([]string{cmdData.DriverName + "_main"}, commandNames...)
for _, table := range cmdData.Tables {
data := &tplData{
Table: table,
PkgName: cmdData.PkgName,
}
var out [][]byte
var imps imports
imps.standard = sqlBoilerDefaultImports.standard
imps.thirdparty = sqlBoilerDefaultImports.thirdparty
// Loop through and generate every command template (excluding skipTemplates)
for _, command := range commandNames {
imps = combineImports(imps, sqlBoilerCustomImports[command])
imps = combineConditionalTypeImports(imps, sqlBoilerConditionalTypeImports, data.Table.Columns)
out = append(out, generateTemplate(command, data))
}
err := outHandler(cmdData.OutFolder, out, data, imps, false)
if err != nil {
errorQuit(err)
}
// Generate the test templates for all commands
if len(testTemplates) != 0 {
var testOut [][]byte
var testImps imports
testImps.standard = sqlBoilerDefaultTestImports.standard
testImps.thirdparty = sqlBoilerDefaultTestImports.thirdparty
testImps = combineImports(testImps, sqlBoilerConditionalDriverTestImports[cmdData.DriverName])
// Loop through and generate every command test template (excluding skipTemplates)
for _, command := range testCommandNames {
testImps = combineImports(testImps, sqlBoilerCustomTestImports[command])
testOut = append(testOut, generateTestTemplate(command, data))
}
err = outHandler(cmdData.OutFolder, testOut, data, testImps, true)
if err != nil {
errorQuit(err)
}
}
}
}
func buildCommandList() []string {
// Exclude these commands from the output
skipCommands := []string{
"boil",
"struct",
}
var commandNames []string
// Build a list of template names
for _, c := range sqlBoilerCommands {
skip := false
for _, s := range skipCommands {
// Skip name if it's in the exclude list.
if s == c.Name() {
skip = true
break
}
}
if !skip {
commandNames = append(commandNames, c.Name())
}
}
// Sort all names alphabetically
sort.Strings(commandNames)
return commandNames
}

38
cmds/boil_test.go
View file

@ -1,38 +0,0 @@
package cmds
import "testing"
func TestBuildCommandList(t *testing.T) {
list := buildCommandList()
skips := []string{"struct", "boil"}
for _, item := range list {
for _, skipItem := range skips {
if item == skipItem {
t.Errorf("Did not expect to find: %s %#v", item, list)
}
}
}
CommandNameLoop:
for cmdName := range sqlBoilerCommands {
for _, skipItem := range skips {
if cmdName == skipItem {
continue CommandNameLoop
}
}
found := false
for _, item := range list {
if item == cmdName {
found = true
break
}
}
if !found {
t.Error("Expected to find command name:", cmdName)
}
}
}

194
cmds/commands.go
View file

@ -1,194 +0,0 @@
package cmds
import (
"text/template"
"github.com/spf13/cobra"
)
type importList []string
// imports defines the optional standard imports and
// thirdparty imports (from github for example)
type imports struct {
standard importList
thirdparty importList
}
// sqlBoilerDefaultImports defines the list of default template imports.
var sqlBoilerDefaultImports = imports{
standard: importList{
`"errors"`,
`"fmt"`,
},
thirdparty: importList{
`"github.com/pobri19/sqlboiler/boil"`,
},
}
// sqlBoilerDefaultTestImports defines the list of default test template imports.
var sqlBoilerDefaultTestImports = imports{
standard: importList{
`"testing"`,
`"os"`,
`"os/exec"`,
`"fmt"`,
`"io/ioutil"`,
`"bytes"`,
`"errors"`,
},
thirdparty: importList{
`"github.com/BurntSushi/toml"`,
},
}
// sqlBoilerConditionalTypeImports imports are only included in the template output
// if the database requires one of the following special types. Check TranslateColumnType
// to see the type assignments.
var sqlBoilerConditionalTypeImports = map[string]imports{
"null.Int": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.String": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Bool": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Float": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Time": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"time.Time": imports{
standard: importList{`"time"`},
},
}
// sqlBoilerConditionalDriverTestImports defines the test template imports
// for the particular database interfaces
var sqlBoilerConditionalDriverTestImports = map[string]imports{
"postgres": imports{
standard: importList{`"database/sql"`},
thirdparty: importList{`_ "github.com/lib/pq"`},
},
}
var sqlBoilerCustomImports map[string]imports
var sqlBoilerCustomTestImports map[string]imports
// sqlBoilerCommands points each command to its cobra.Command variable.
//
// If you would like to add your own custom command, add it to this
// map, and point it to your <commandName>Cmd variable.
//
// Command names should match the template file name (without the file extension).
var sqlBoilerCommands = map[string]*cobra.Command{
// Command to generate all commands
"boil": boilCmd,
// Struct commands
"struct": structCmd,
// Insert commands
"insert": insertCmd,
// Select commands
"all": allCmd,
"where": whereCmd,
"select": selectCmd,
"selectwhere": selectWhereCmd,
"find": findCmd,
"findselect": findSelectCmd,
// Delete commands
"delete": deleteCmd,
// Update commands
"update": updateCmd,
}
// sqlBoilerCommandRuns points each command to its custom run function.
// If a run function is not defined here, it will use the defaultRun() default run function.
var sqlBoilerCommandRuns = map[string]CobraRunFunc{
"boil": boilRun,
}
// sqlBoilerTemplateFuncs is a map of all the functions that get passed into the templates.
// If you wish to pass a new function into your own template, add a pointer to it here.
var sqlBoilerTemplateFuncs = template.FuncMap{
"singular": singular,
"plural": plural,
"titleCase": titleCase,
"titleCaseSingular": titleCaseSingular,
"titleCasePlural": titleCasePlural,
"camelCase": camelCase,
"camelCaseSingular": camelCaseSingular,
"camelCasePlural": camelCasePlural,
"makeDBName": makeDBName,
"selectParamNames": selectParamNames,
"insertParamNames": insertParamNames,
"insertParamFlags": insertParamFlags,
"insertParamVariables": insertParamVariables,
"scanParamNames": scanParamNames,
"hasPrimaryKey": hasPrimaryKey,
"getPrimaryKey": getPrimaryKey,
"updateParamNames": updateParamNames,
"updateParamVariables": updateParamVariables,
}
/* Struct commands */
var structCmd = &cobra.Command{
Use: "struct",
Short: "Generate structs from table definitions",
}
/* Insert commands */
var insertCmd = &cobra.Command{
Use: "insert",
Short: "Generate insert statement helpers from table definitions",
}
/* Select commands */
var allCmd = &cobra.Command{
Use: "all",
Short: "Generate a helper to select all records",
}
var whereCmd = &cobra.Command{
Use: "where",
Short: "Generate a helper to select all records with specific column values",
}
var selectCmd = &cobra.Command{
Use: "select",
Short: "Generate a helper to select specific fields of all records",
}
var selectWhereCmd = &cobra.Command{
Use: "selectwhere",
Short: "Generate a helper to select specific fields of records with specific column values",
}
var findCmd = &cobra.Command{
Use: "find",
Short: "Generate a helper to select a single record by ID",
}
var findSelectCmd = &cobra.Command{
Use: "findselect",
Short: "Generate a helper to select specific fields of a record by ID",
}
/* Delete commands */
var deleteCmd = &cobra.Command{
Use: "delete",
Short: "Generate delete statement helpers from table definitions",
}
/* Update commands */
var updateCmd = &cobra.Command{
Use: "update",
Short: "Generate update statement helpers from table definitions",
}

112
cmds/config.go
View file

@ -3,49 +3,107 @@ package cmds
import (
"fmt"
"os"
"text/template"
"github.com/BurntSushi/toml"
)
type PostgresCfg struct {
User string `toml:"user"`
Pass string `toml:"pass"`
Host string `toml:"host"`
Port int `toml:"port"`
DBName string `toml:"dbname"`
// sqlBoilerDefaultImports defines the list of default template imports.
var sqlBoilerImports = imports{
standard: importList{
`"errors"`,
`"fmt"`,
},
thirdparty: importList{
`"github.com/pobri19/sqlboiler/boil"`,
},
}
type Config struct {
Postgres PostgresCfg `toml:"postgres"`
TestPostgres *PostgresCfg `toml:"postgres_test"`
// sqlBoilerDefaultTestImports defines the list of default test template imports.
var sqlBoilerTestImports = imports{
standard: importList{
`"testing"`,
`"os"`,
`"os/exec"`,
`"fmt"`,
`"io/ioutil"`,
`"bytes"`,
`"errors"`,
},
thirdparty: importList{
`"github.com/BurntSushi/toml"`,
},
}
var cfg *Config
// sqlBoilerTypeImports imports are only included in the template output if the database
// requires one of the following special types. Check TranslateColumnType to see the type assignments.
var sqlBoilerTypeImports = map[string]imports{
"null.Int": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.String": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Bool": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Float": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"null.Time": imports{
thirdparty: importList{`"gopkg.in/guregu/null.v3"`},
},
"time.Time": imports{
standard: importList{`"time"`},
},
}
// sqlBoilerConditionalDriverTestImports defines the test template imports
// for the particular database interfaces
var sqlBoilerDriverTestImports = map[string]imports{
"postgres": imports{
standard: importList{`"database/sql"`},
thirdparty: importList{`_ "github.com/lib/pq"`},
},
}
// sqlBoilerTemplateFuncs is a map of all the functions that get passed into the templates.
// If you wish to pass a new function into your own template, add a pointer to it here.
var sqlBoilerTemplateFuncs = template.FuncMap{
"singular": singular,
"plural": plural,
"titleCase": titleCase,
"titleCaseSingular": titleCaseSingular,
"titleCasePlural": titleCasePlural,
"camelCase": camelCase,
"camelCaseSingular": camelCaseSingular,
"camelCasePlural": camelCasePlural,
"makeDBName": makeDBName,
"selectParamNames": selectParamNames,
"insertParamNames": insertParamNames,
"insertParamFlags": insertParamFlags,
"insertParamVariables": insertParamVariables,
"scanParamNames": scanParamNames,
"hasPrimaryKey": hasPrimaryKey,
"getPrimaryKey": getPrimaryKey,
"updateParamNames": updateParamNames,
"updateParamVariables": updateParamVariables,
}
// LoadConfigFile loads the toml config file into the cfg object
func LoadConfigFile(filename string) {
func (cmdData *CmdData) LoadConfigFile(filename string) error {
cfg := &Config{}
_, err := toml.DecodeFile(filename, &cfg)
if os.IsNotExist(err) {
fmt.Printf("Failed to find the toml configuration file %s: %s", filename, err)
return
return fmt.Errorf("Failed to find the toml configuration file %s: %s", filename, err)
}
if err != nil {
fmt.Println("Failed to decode toml configuration file:", err)
return fmt.Errorf("Failed to decode toml configuration file: %s", err)
}
// If any of the test cfg variables are not present then test TestPostgres to nil
//
// As a safety precaution, set TestPostgres to nil if
// the dbname is the same as the cfg dbname. This will prevent the test
// from erasing the production database tables if someone accidently
// configures the config.toml incorrectly.
if cfg.TestPostgres != nil {
if cfg.TestPostgres.User == "" || cfg.TestPostgres.Pass == "" ||
cfg.TestPostgres.Host == "" || cfg.TestPostgres.Port == 0 ||
cfg.TestPostgres.DBName == "" || cfg.Postgres.DBName == cfg.TestPostgres.DBName {
cfg.TestPostgres = nil
}
}
cmdData.Config = cfg
return nil
}

43
cmds/config_test.go
View file

@ -9,13 +9,11 @@ import (
func TestLoadConfig(t *testing.T) {
t.Parallel()
cmdData := &CmdData{}
file, _ := ioutil.TempFile(os.TempDir(), "sqlboilercfgtest")
defer os.Remove(file.Name())
if cfg != nil {
t.Errorf("Expected cfgs to be empty for the time being.")
}
fContents := `[postgres]
host="localhost"
port=5432
@ -24,37 +22,14 @@ func TestLoadConfig(t *testing.T) {
dbname="mydb"`
file.WriteString(fContents)
LoadConfigFile(file.Name())
if cfg.TestPostgres != nil || cfg.Postgres.Host != "localhost" ||
cfg.Postgres.User != "user" || cfg.Postgres.Pass != "pass" ||
cfg.Postgres.DBName != "mydb" || cfg.Postgres.Port != 5432 {
t.Errorf("Config failed to load properly, got: %#v", cfg.Postgres)
err := cmdData.LoadConfigFile(file.Name())
if err != nil {
t.Errorf("Unable to load config file: %s", err)
}
fContents = `
[postgres_test]
host="localhost"
port=5432
user="testuser"
pass="testpass"`
file.WriteString(fContents)
LoadConfigFile(file.Name())
if cfg.TestPostgres != nil {
t.Errorf("Test config failed to load properly, got: %#v", cfg.Postgres)
}
fContents = `
dbname="testmydb"`
file.WriteString(fContents)
LoadConfigFile(file.Name())
if cfg.TestPostgres.DBName != "testmydb" || cfg.TestPostgres.Host != "localhost" ||
cfg.TestPostgres.User != "testuser" || cfg.TestPostgres.Pass != "testpass" ||
cfg.TestPostgres.Port != 5432 {
t.Errorf("Test config failed to load properly, got: %#v", cfg.Postgres)
if cmdData.Config.Postgres.Host != "localhost" ||
cmdData.Config.Postgres.User != "user" || cmdData.Config.Postgres.Pass != "pass" ||
cmdData.Config.Postgres.DBName != "mydb" || cmdData.Config.Postgres.Port != 5432 {
t.Errorf("Config failed to load properly, got: %#v", cmdData.Config.Postgres)
}
}

2
cmds/imports.go
View file

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

6
cmds/imports_test.go
View file

@ -7,7 +7,7 @@ import (
"github.com/pobri19/sqlboiler/dbdrivers"
)
func TestCombineConditionalTypeImports(t *testing.T) {
func TestCombineTypeImports(t *testing.T) {
imports1 := imports{
standard: importList{
`"errors"`,
@ -45,7 +45,7 @@ func TestCombineConditionalTypeImports(t *testing.T) {
},
}
res1 := combineConditionalTypeImports(imports1, sqlBoilerConditionalTypeImports, cols)
res1 := combineTypeImports(imports1, sqlBoilerTypeImports, cols)
if !reflect.DeepEqual(res1, importsExpected) {
t.Errorf("Expected res1 to match importsExpected, got:\n\n%#v\n", res1)
@ -63,7 +63,7 @@ func TestCombineConditionalTypeImports(t *testing.T) {
},
}
res2 := combineConditionalTypeImports(imports2, sqlBoilerConditionalTypeImports, cols)
res2 := combineTypeImports(imports2, sqlBoilerTypeImports, cols)
if !reflect.DeepEqual(res2, importsExpected) {
t.Errorf("Expected res2 to match importsExpected, got:\n\n%#v\n", res1)

77
cmds/shared.go
View file

@ -4,69 +4,8 @@ import (
"fmt"
"io"
"os"
"github.com/pobri19/sqlboiler/dbdrivers"
"github.com/spf13/cobra"
)
// CobraRunFunc declares the cobra.Command.Run function definition
type CobraRunFunc func(cmd *cobra.Command, args []string)
// CmdData holds the table schema a slice of (column name, column type) slices.
// It also holds a slice of all of the table names sqlboiler is generating against,
// the database driver chosen by the driver flag at runtime, and a pointer to the
// output file, if one is specified with a flag.
type CmdData struct {
Tables []dbdrivers.Table
PkgName string
OutFolder string
Interface dbdrivers.Interface
DriverName string
}
// tplData is used to pass data to the template
type tplData struct {
Table dbdrivers.Table
PkgName string
}
// errorQuit displays an error message and then exits the application.
func errorQuit(err error) {
fmt.Println(fmt.Sprintf("Error: %s\n---\n\nRun 'sqlboiler --help' for usage.", err))
os.Exit(-1)
}
// defaultRun is the default function passed to the commands cobra.Command.Run.
// It will generate the specific commands template and send it to outHandler for output.
func defaultRun(cmd *cobra.Command, args []string) {
// Generate the template for every table
for _, t := range cmdData.Tables {
data := &tplData{
Table: t,
PkgName: cmdData.PkgName,
}
templater(cmd, data)
}
}
// templater generates the template by passing it the tplData object.
// Once the template is generated, it will add the imports to the output stream
// and output the contents of the template with the added bits (imports and package declaration).
func templater(cmd *cobra.Command, data *tplData) {
// outHandler takes a slice of byte slices, so append the Template
// execution output to a [][]byte before sending it to outHandler.
out := [][]byte{generateTemplate(cmd.Name(), data)}
imps := combineImports(sqlBoilerDefaultImports, sqlBoilerCustomImports[cmd.Name()])
imps = combineConditionalTypeImports(imps, sqlBoilerConditionalTypeImports, data.Table.Columns)
err := outHandler(cmdData.OutFolder, out, data, imps, false)
if err != nil {
errorQuit(fmt.Errorf("Unable to generate the template for command %s: %s", cmd.Name(), err))
}
}
var testHarnessStdout io.Writer = os.Stdout
var testHarnessFileOpen = func(filename string) (io.WriteCloser, error) {
file, err := os.Create(filename)
@ -75,39 +14,39 @@ var testHarnessFileOpen = func(filename string) (io.WriteCloser, error) {
// outHandler loops over the slice of byte slices, outputting them to either
// the OutFile if it is specified with a flag, or to Stdout if no flag is specified.
func outHandler(outFolder string, output [][]byte, data *tplData, imps imports, testTemplate bool) error {
func outHandler(cmdData *CmdData, output [][]byte, data *tplData, imps imports, testTemplate bool) error {
out := testHarnessStdout
var path string
if len(outFolder) != 0 {
if len(cmdData.OutFolder) != 0 {
if testTemplate {
path = outFolder + "/" + data.Table.Name + "_test.go"
path = cmdData.OutFolder + "/" + data.Table.Name + "_test.go"
} else {
path = outFolder + "/" + data.Table.Name + ".go"
path = cmdData.OutFolder + "/" + data.Table.Name + ".go"
}
outFile, err := testHarnessFileOpen(path)
if err != nil {
errorQuit(fmt.Errorf("Unable to create output file %s: %s", path, err))
return fmt.Errorf("Unable to create output file %s: %s", path, err)
}
defer outFile.Close()
out = outFile
}
if _, err := fmt.Fprintf(out, "package %s\n\n", cmdData.PkgName); err != nil {
errorQuit(fmt.Errorf("Unable to write package name %s to file: %s", cmdData.PkgName, path))
return fmt.Errorf("Unable to write package name %s to file: %s", cmdData.PkgName, path)
}
impStr := buildImportString(imps)
if len(impStr) > 0 {
if _, err := fmt.Fprintf(out, "%s\n", impStr); err != nil {
errorQuit(fmt.Errorf("Unable to write imports to file handle: %v", err))
return fmt.Errorf("Unable to write imports to file handle: %v", err)
}
}
for _, templateOutput := range output {
if _, err := fmt.Fprintf(out, "%s\n", templateOutput); err != nil {
errorQuit(fmt.Errorf("Unable to write template output to file handle: %v", err))
return fmt.Errorf("Unable to write template output to file handle: %v", err)
}
}

10
cmds/shared_test.go
View file

@ -28,7 +28,7 @@ func TestOutHandler(t *testing.T) {
templateOutputs := [][]byte{[]byte("hello world"), []byte("patrick's dreams")}
if err := outHandler("", templateOutputs, &data, imports{}, false); err != nil {
if err := outHandler(&CmdData{PkgName: "patrick"}, templateOutputs, &data, imports{}, false); err != nil {
t.Error(err)
}
@ -66,7 +66,7 @@ func TestOutHandlerFiles(t *testing.T) {
templateOutputs := [][]byte{[]byte("hello world"), []byte("patrick's dreams")}
if err := outHandler("folder", templateOutputs, &data, imports{}, false); err != nil {
if err := outHandler(&CmdData{OutFolder: "folder", PkgName: "patrick"}, templateOutputs, &data, imports{}, false); err != nil {
t.Error(err)
}
if out := file.String(); out != "package patrick\n\nhello world\npatrick's dreams\n" {
@ -80,7 +80,7 @@ func TestOutHandlerFiles(t *testing.T) {
}
file = &bytes.Buffer{}
if err := outHandler("folder", templateOutputs, &data, a1, false); err != nil {
if err := outHandler(&CmdData{OutFolder: "folder", PkgName: "patrick"}, templateOutputs, &data, a1, false); err != nil {
t.Error(err)
}
if out := file.String(); out != "package patrick\n\nimport \"fmt\"\nhello world\npatrick's dreams\n" {
@ -94,7 +94,7 @@ func TestOutHandlerFiles(t *testing.T) {
}
file = &bytes.Buffer{}
if err := outHandler("folder", templateOutputs, &data, a2, false); err != nil {
if err := outHandler(&CmdData{OutFolder: "folder", PkgName: "patrick"}, templateOutputs, &data, a2, false); err != nil {
t.Error(err)
}
if out := file.String(); out != "package patrick\n\nimport \"github.com/spf13/cobra\"\nhello world\npatrick's dreams\n" {
@ -118,7 +118,7 @@ func TestOutHandlerFiles(t *testing.T) {
sort.Sort(a3.standard)
sort.Sort(a3.thirdparty)
if err := outHandler("folder", templateOutputs, &data, a3, false); err != nil {
if err := outHandler(&CmdData{OutFolder: "folder", PkgName: "patrick"}, templateOutputs, &data, a3, false); err != nil {
t.Error(err)
}

344
cmds/sqlboiler.go
View file

@ -5,7 +5,6 @@ import (
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"text/template"
@ -18,166 +17,24 @@ const (
templatesTestDirectory = "/cmds/templates_test"
)
// cmdData is used globally by all commands to access the table schema data,
// the database driver and the output file. cmdData is initialized by
// the root SQLBoiler cobra command at run time, before other commands execute.
var cmdData *CmdData
// templates holds a slice of pointers to all templates in the templates directory.
var templates []*template.Template
// testTemplates holds a slice of pointers to all test templates in the templates directory.
var testTemplates []*template.Template
// SQLBoiler is the root app command
var SQLBoiler = &cobra.Command{
Use: "sqlboiler",
Short: "SQL Boiler generates boilerplate structs and statements",
Long: "SQL Boiler generates boilerplate structs and statements.\n" +
`Complete documentation is available at http://github.com/pobri19/sqlboiler`,
}
// init initializes the sqlboiler flags, such as driver, table, and output file.
// It also sets the global preRun hook and postRun hook. Every command will execute
// these hooks before and after running to initialize the shared state.
func init() {
SQLBoiler.PersistentFlags().StringP("driver", "d", "", "The name of the driver in your config.toml (mandatory)")
SQLBoiler.PersistentFlags().StringP("table", "t", "", "A comma seperated list of table names")
SQLBoiler.PersistentFlags().StringP("folder", "f", "", "The name of the output folder. If not specified will output to stdout")
SQLBoiler.PersistentFlags().StringP("pkgname", "p", "model", "The name you wish to assign to your generated package")
SQLBoiler.PersistentPreRun = sqlBoilerPreRun
SQLBoiler.PersistentPostRun = sqlBoilerPostRun
// Initialize the SQLBoiler commands and hook the custom Run functions
initCommands(SQLBoiler, sqlBoilerCommands, sqlBoilerCommandRuns)
}
// sqlBoilerPostRun cleans up the output file and database connection once
// all commands are finished running.
func sqlBoilerPostRun(cmd *cobra.Command, args []string) {
cmdData.Interface.Close()
}
// sqlBoilerPreRun executes before all commands start running. Its job is to
// initialize the shared state object (cmdData). Initialization tasks include
// assigning the database driver based off the driver flag and opening the database connection,
// retrieving a list of all the tables in the database (if specific tables are not provided
// via a flag), building the table schema for use in the templates, and opening the output file
// handle if one is specified with a flag.
func sqlBoilerPreRun(cmd *cobra.Command, args []string) {
// LoadTemplates loads all template folders into the cmdData object.
func (cmdData *CmdData) LoadTemplates() error {
var err error
cmdData = &CmdData{}
// Initialize the cmdData.Interface
initInterface()
// Connect to the driver database
if err = cmdData.Interface.Open(); err != nil {
errorQuit(fmt.Errorf("Unable to connect to the database: %s", err))
}
// Initialize the cmdData.Tables
initTables()
// Initialize the package name
initPkgName()
// Initialize the cmdData.OutFile
initOutFolder()
// Initialize the templates
templates, err = initTemplates(templatesDirectory)
cmdData.Templates, err = loadTemplates(templatesDirectory)
if err != nil {
errorQuit(fmt.Errorf("Unable to initialize templates: %s", err))
return err
}
// Initialize the test templates if the OutFolder
if cmdData.OutFolder != "" && cfg.TestPostgres != nil {
testTemplates, err = initTemplates(templatesTestDirectory)
cmdData.TestTemplates, err = loadTemplates(templatesTestDirectory)
if err != nil {
errorQuit(fmt.Errorf("Unable to initialize test templates: %s", err))
}
}
return err
}
// 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 initInterface() {
// Retrieve driver flag
driverName := SQLBoiler.PersistentFlags().Lookup("driver").Value.String()
if driverName == "" {
errorQuit(errors.New("Must supply a driver flag."))
return nil
}
// Create a driver based off driver flag
switch driverName {
case "postgres":
cmdData.Interface = dbdrivers.NewPostgresDriver(
cfg.Postgres.User,
cfg.Postgres.Pass,
cfg.Postgres.DBName,
cfg.Postgres.Host,
cfg.Postgres.Port,
)
}
if cmdData.Interface == nil {
errorQuit(errors.New("An invalid driver name was provided"))
}
cmdData.DriverName = driverName
}
// initTables will create a string slice out of the passed in table flag value
// if one is provided. If no flag is provided, it will attempt to connect to the
// database to retrieve all "public" table names, and build a slice out of that result.
func initTables() {
// Retrieve the list of tables
tn := SQLBoiler.PersistentFlags().Lookup("table").Value.String()
var tableNames []string
if len(tn) != 0 {
tableNames = strings.Split(tn, ",")
for i, name := range tableNames {
tableNames[i] = strings.TrimSpace(name)
}
}
var err error
cmdData.Tables, err = cmdData.Interface.Tables(tableNames...)
if err != nil {
errorQuit(fmt.Errorf("Unable to get all table names: %s", err))
}
if len(cmdData.Tables) == 0 {
errorQuit(errors.New("No tables found in database, migrate some tables first"))
}
}
// Initialize the package name provided by the flag
func initPkgName() {
cmdData.PkgName = SQLBoiler.PersistentFlags().Lookup("pkgname").Value.String()
}
// initOutFile opens a file handle to the file name specified by the out flag.
// If no file name is provided, out will remain nil and future output will be
// piped to Stdout instead of to a file.
func initOutFolder() {
// open the out file filehandle
cmdData.OutFolder = SQLBoiler.PersistentFlags().Lookup("folder").Value.String()
if cmdData.OutFolder == "" {
return
}
if err := os.MkdirAll(cmdData.OutFolder, os.ModePerm); err != nil {
errorQuit(fmt.Errorf("Unable to make output folder: %s", err))
}
}
// initTemplates loads all of the template files in the /cmds/templates directory
// and returns a slice of pointers to these templates.
func initTemplates(dir string) ([]*template.Template, error) {
// loadTemplates loads all of the template files in the specified directory.
func loadTemplates(dir string) ([]*template.Template, error) {
wd, err := os.Getwd()
if err != nil {
return nil, err
@ -193,39 +50,166 @@ func initTemplates(dir string) ([]*template.Template, error) {
return tpl.Templates(), err
}
// initCommands loads all of the commands in the sqlBoilerCommands and hooks their run functions.
func initCommands(rootCmd *cobra.Command, commands map[string]*cobra.Command, commandRuns map[string]CobraRunFunc) {
var commandNames []string
// Build a list of command names to alphabetically sort them for ordered loading.
for _, c := range commands {
// Skip the boil command load, we do it manually below.
if c.Name() == "boil" {
continue
// SQLBoilerPostRun cleans up the output file and db connection once all cmds are finished.
func (cmdData *CmdData) SQLBoilerPostRun(cmd *cobra.Command, args []string) error {
cmdData.Interface.Close()
return nil
}
commandNames = append(commandNames, c.Name())
// SQLBoilerPreRun performs the initialization tasks before the root command is run
func (cmdData *CmdData) SQLBoilerPreRun(cmd *cobra.Command, args []string) error {
var err error
// Initialize package name
cmdData.PkgName = cmd.PersistentFlags().Lookup("pkgname").Value.String()
err = initInterface(cmd, cmdData.Config, cmdData)
if err != nil {
return err
}
// Initialize the "boil" command first, and manually. It should be at the top of the help file.
commands["boil"].Run = commandRuns["boil"]
rootCmd.AddCommand(commands["boil"])
// Load commands alphabetically. This ensures proper order of help file.
sort.Strings(commandNames)
// Loop every command name, load it and hook it to its Run handler
for _, c := range commandNames {
// If there is a commandRun for the command (matched by name)
// then set the Run hook
r, ok := commandRuns[c]
if ok {
commands[c].Run = r
} else {
commands[c].Run = defaultRun // Load default run if no custom run is found
// Connect to the driver database
if err = cmdData.Interface.Open(); err != nil {
return fmt.Errorf("Unable to connect to the database: %s", err)
}
// Add the command
rootCmd.AddCommand(commands[c])
err = initTables(cmd, cmdData)
if err != nil {
return fmt.Errorf("Unable to initialize tables: %s", err)
}
err = initOutFolder(cmd, cmdData)
if err != nil {
return fmt.Errorf("Unable to initialize the output folder: %s", err)
}
return nil
}
// SQLBoilerRun executes every sqlboiler template and outputs them to files.
func (cmdData *CmdData) SQLBoilerRun(cmd *cobra.Command, args []string) error {
for _, table := range cmdData.Tables {
data := &tplData{
Table: table,
PkgName: cmdData.PkgName,
}
var out [][]byte
var imps imports
imps.standard = sqlBoilerImports.standard
imps.thirdparty = sqlBoilerImports.thirdparty
// Loop through and generate every command template (excluding skipTemplates)
for _, template := range cmdData.Templates {
imps = combineTypeImports(imps, sqlBoilerTypeImports, data.Table.Columns)
resp, err := generateTemplate(template, data)
if err != nil {
return err
}
out = append(out, resp)
}
err := outHandler(cmdData, out, data, imps, false)
if err != nil {
return err
}
// Generate the test templates for all commands
if len(cmdData.TestTemplates) != 0 {
var testOut [][]byte
var testImps imports
testImps.standard = sqlBoilerTestImports.standard
testImps.thirdparty = sqlBoilerTestImports.thirdparty
testImps = combineImports(testImps, sqlBoilerDriverTestImports[cmdData.DriverName])
// Loop through and generate every command test template (excluding skipTemplates)
for _, template := range cmdData.TestTemplates {
resp, err := generateTemplate(template, data)
if err != nil {
return err
}
testOut = append(testOut, resp)
}
err = outHandler(cmdData, testOut, data, testImps, true)
if err != nil {
return err
}
}
}
return nil
}
// initInterface attempts to set the cmdData Interface based off the passed in
// driver flag value. If an invalid flag string is provided an error is returned.
func initInterface(cmd *cobra.Command, cfg *Config, cmdData *CmdData) error {
// Retrieve driver flag
driverName := cmd.PersistentFlags().Lookup("driver").Value.String()
if driverName == "" {
return errors.New("Must supply a driver flag.")
}
// Create a driver based off driver flag
switch driverName {
case "postgres":
cmdData.Interface = dbdrivers.NewPostgresDriver(
cfg.Postgres.User,
cfg.Postgres.Pass,
cfg.Postgres.DBName,
cfg.Postgres.Host,
cfg.Postgres.Port,
)
}
if cmdData.Interface == nil {
return errors.New("An invalid driver name was provided")
}
cmdData.DriverName = driverName
return nil
}
// initTables will create a string slice out of the passed in table flag value
// if one is provided. If no flag is provided, it will attempt to connect to the
// database to retrieve all "public" table names, and build a slice out of that result.
func initTables(cmd *cobra.Command, cmdData *CmdData) error {
var tableNames []string
tn := cmd.PersistentFlags().Lookup("table").Value.String()
if len(tn) != 0 {
tableNames = strings.Split(tn, ",")
for i, name := range tableNames {
tableNames[i] = strings.TrimSpace(name)
}
}
var err error
cmdData.Tables, err = cmdData.Interface.Tables(tableNames...)
if err != nil {
return fmt.Errorf("Unable to get all table names: %s", err)
}
if len(cmdData.Tables) == 0 {
return errors.New("No tables found in database, migrate some tables first")
}
return nil
}
// initOutFolder creates the folder that will hold the generated output.
func initOutFolder(cmd *cobra.Command, cmdData *CmdData) error {
cmdData.OutFolder = cmd.PersistentFlags().Lookup("folder").Value.String()
if cmdData.OutFolder == "" {
return fmt.Errorf("No output folder specified.")
}
if err := os.MkdirAll(cmdData.OutFolder, os.ModePerm); err != nil {
return fmt.Errorf("Unable to make output folder: %s", err)
}
return nil
}

6
cmds/sqlboiler_test.go
View file

@ -11,6 +11,8 @@ import (
"github.com/pobri19/sqlboiler/dbdrivers"
)
var cmdData *CmdData
func init() {
cmdData = &CmdData{
Tables: []dbdrivers.Table{
@ -46,7 +48,7 @@ func TestTemplates(t *testing.T) {
// Initialize the templates
var err error
templates, err = initTemplates("templates")
cmdData.Templates, err = loadTemplates("templates")
if err != nil {
t.Fatalf("Unable to initialize templates: %s", err)
}
@ -57,7 +59,7 @@ func TestTemplates(t *testing.T) {
}
defer os.RemoveAll(cmdData.OutFolder)
boilRun(sqlBoilerCommands["boil"], []string{})
cmdData.SQLBoilerRun(nil, []string{})
tplFile := cmdData.OutFolder + "/templates_test.go"
tplTestHandle, err := os.Create(tplFile)

58
cmds/template_funcs.go
View file

@ -12,65 +12,13 @@ import (
)
// generateTemplate generates the template associated to the passed in command name.
func generateTemplate(commandName string, data *tplData) []byte {
template := getTemplate(commandName)
if template == nil {
errorQuit(fmt.Errorf("Unable to find the template: %s", commandName+".tpl"))
}
func generateTemplate(template *template.Template, data *tplData) ([]byte, error) {
output, err := processTemplate(template, data)
if err != nil {
errorQuit(fmt.Errorf("Unable to process the template %s for table %s: %s", template.Name(), data.Table.Name, err))
return nil, fmt.Errorf("Unable to process the template %s for table %s: %s", template.Name(), data.Table.Name, err)
}
return output
}
// generateTestTemplate generates the test template associated to the passed in command name.
func generateTestTemplate(commandName string, data *tplData) []byte {
template := getTestTemplate(commandName)
if template == nil {
return []byte{}
}
output, err := processTemplate(template, data)
if err != nil {
errorQuit(fmt.Errorf("Unable to process the test template %s for table %s: %s", template.Name(), data.Table.Name, err))
}
return output
}
// getTemplate returns a pointer to the template matching the passed in name
func getTemplate(name string) *template.Template {
var tpl *template.Template
// Find the template that matches the passed in template name
for _, t := range templates {
if t.Name() == name+".tpl" {
tpl = t
break
}
}
return tpl
}
// getTemplate returns a pointer to the template matching the passed in name
func getTestTemplate(name string) *template.Template {
var tpl *template.Template
// Find the template that matches the passed in template name
for _, t := range testTemplates {
if t.Name() == name+".tpl" {
tpl = t
break
}
}
return tpl
return output, nil
}
// processTemplate takes a template and returns the output of the template execution.

53
cmds/types.go Normal file
View file

@ -0,0 +1,53 @@
package cmds
import (
"text/template"
"github.com/pobri19/sqlboiler/dbdrivers"
"github.com/spf13/cobra"
)
// CobraRunFunc declares the cobra.Command.Run function definition
type CobraRunFunc func(cmd *cobra.Command, args []string)
// CmdData holds the table schema a slice of (column name, column type) slices.
// It also holds a slice of all of the table names sqlboiler is generating against,
// the database driver chosen by the driver flag at runtime, and a pointer to the
// output file, if one is specified with a flag.
type CmdData struct {
Tables []dbdrivers.Table
PkgName string
OutFolder string
Interface dbdrivers.Interface
DriverName string
Config *Config
Templates []*template.Template
TestTemplates []*template.Template
}
// tplData is used to pass data to the template
type tplData struct {
Table dbdrivers.Table
PkgName string
}
type importList []string
// imports defines the optional standard imports and
// thirdparty imports (from github for example)
type imports struct {
standard importList
thirdparty importList
}
type PostgresCfg struct {
User string `toml:"user"`
Pass string `toml:"pass"`
Host string `toml:"host"`
Port int `toml:"port"`
DBName string `toml:"dbname"`
}
type Config struct {
Postgres PostgresCfg `toml:"postgres"`
}

21
dbdrivers/postgres_driver.go
View file

@ -50,6 +50,7 @@ func (p *PostgresDriver) Tables(names ...string) ([]Table, error) {
var err error
if len(names) == 0 {
if names, err = p.tableNames(); err != nil {
fmt.Println("Unable to get table names.")
return nil, err
}
}
@ -59,14 +60,17 @@ func (p *PostgresDriver) Tables(names ...string) ([]Table, error) {
t := Table{Name: name}
if t.Columns, err = p.columns(name); err != nil {
fmt.Println("Unable to get columnss.")
return nil, err
}
if t.PKey, err = p.primaryKeyInfo(name); err != nil {
fmt.Println("Unable to get primary key info.")
return nil, err
}
if t.FKeys, err = p.foreignKeyInfo(name); err != nil {
fmt.Println("Unable to get foreign key info.")
return nil, err
}
@ -153,14 +157,25 @@ func (p *PostgresDriver) primaryKeyInfo(tableName string) (*PrimaryKey, error) {
pkey := &PrimaryKey{}
var err error
query := ``
query := `SELECT conname
FROM pg_constraint
WHERE conrelid =
(SELECT oid
FROM pg_class
WHERE relname LIKE $1)
AND contype='p';`
row := p.dbConn.QueryRow(query, tableName)
if err = row.Scan(&pkey.Name); err != nil {
return nil, err
}
queryColumns := ``
queryColumns := `SELECT a.attname AS column
FROM pg_index i
JOIN pg_attribute a ON a.attrelid = i.indrelid
AND a.attnum = ANY(i.indkey)
WHERE i.indrelid = $1::regclass
AND i.indisprimary;`
var rows *sql.Rows
if rows, err = p.dbConn.Query(queryColumns, tableName); err != nil {
@ -197,7 +212,7 @@ func (p *PostgresDriver) foreignKeyInfo(tableName string) ([]ForeignKey, error)
FROM information_schema.table_constraints as tc
JOIN information_schema.key_column_usage as kcu ON tc.constraint_name = kcu.constraint_name
JOIN information_schema.constraint_column_usage as ccu ON tc.constraint_name = ccu.constraint_name
WHERE source_table = $1, tc.constraint_type = 'FOREIGN KEY';`
WHERE tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY';`
var rows *sql.Rows
var err error

45
main.go
View file

@ -10,15 +10,52 @@ import (
"os"
"github.com/pobri19/sqlboiler/cmds"
"github.com/spf13/cobra"
)
func main() {
// Load the config.toml file
cmds.LoadConfigFile("config.toml")
var err error
cmdData := &cmds.CmdData{}
// Load the "config.toml" global config
err = cmdData.LoadConfigFile("config.toml")
if err != nil {
fmt.Printf("Failed to load config file: %s\n", err)
os.Exit(-1)
}
// Load all templates
err = cmdData.LoadTemplates()
if err != nil {
fmt.Printf("Failed to load templates: %s\n", err)
os.Exit(-1)
}
// Set up the cobra root command
var rootCmd = &cobra.Command{
Use: "sqlboiler",
Short: "SQL Boiler generates boilerplate structs and statements",
Long: "SQL Boiler generates boilerplate structs and statements from the template files.\n" +
`Complete documentation is available at http://github.com/pobri19/sqlboiler`,
PreRunE: func(cmd *cobra.Command, args []string) error {
return cmdData.SQLBoilerPreRun(cmd, args)
},
RunE: func(cmd *cobra.Command, args []string) error {
return cmdData.SQLBoilerRun(cmd, args)
},
PostRunE: func(cmd *cobra.Command, args []string) error {
return cmdData.SQLBoilerPostRun(cmd, args)
},
}
// Set up the cobra root command flags
rootCmd.PersistentFlags().StringP("driver", "d", "", "The name of the driver in your config.toml (mandatory)")
rootCmd.PersistentFlags().StringP("table", "t", "", "A comma seperated list of table names")
rootCmd.PersistentFlags().StringP("folder", "f", "output", "The name of the output folder")
rootCmd.PersistentFlags().StringP("pkgname", "p", "model", "The name you wish to assign to your generated package")
// Execute SQLBoiler
if err := cmds.SQLBoiler.Execute(); err != nil {
fmt.Printf("Failed to execute SQLBoiler: %s", err)
if err := rootCmd.Execute(); err != nil {
os.Exit(-1)
}
}