Tests clean up.

cmd/generator/main.go

@@ -46,7 +46,7 @@ func main() {
 		SslMode:  sslmode,
 		Params:   params,
 
-		DbName:     dbName,
+		DBName:     dbName,
 		SchemaName: schemaName,
 	}
 

generator/generator.go

@@ -18,14 +18,14 @@ type GeneratorData struct {
 	SslMode  string
 	Params   string
 
-	DbName     string
+	DBName     string
 	SchemaName string
 }
 
 func Generate(destDir string, genData GeneratorData) error {
 
 	connectionString := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s %s",
-		genData.Host, genData.Port, genData.User, genData.Password, genData.DbName, genData.SslMode, genData.Params)
+		genData.Host, genData.Port, genData.User, genData.Password, genData.DBName, genData.SslMode, genData.Params)
 
 	db, err := sql.Open("postgres", connectionString)
 	if err != nil {
@@ -39,13 +39,13 @@ func Generate(destDir string, genData GeneratorData) error {
 		return err
 	}
 
-	err = cleanUpGeneratedFiles(path.Join(destDir, genData.DbName, genData.SchemaName))
+	err = cleanUpGeneratedFiles(path.Join(destDir, genData.DBName, genData.SchemaName))
 
 	if err != nil {
 		return err
 	}
 
-	schemaInfo, err := postgres_metadata.GetSchemaInfo(db, genData.DbName, genData.SchemaName)
+	schemaInfo, err := postgres_metadata.GetSchemaInfo(db, genData.DBName, genData.SchemaName)
 
 	if err != nil {
 		return err

sqlbuilder/clause.go

@@ -2,7 +2,10 @@ package sqlbuilder
 
 import (
 	"bytes"
+	"github.com/google/uuid"
 	"strconv"
+	"strings"
+	"time"
 )
 
 type serializeOption int
@@ -175,6 +178,10 @@ func (q *queryData) reset() {
 }
 
 func ArgToString(value interface{}) string {
+	if isNil(value) {
+		return "NULL"
+	}
+
 	switch bindVal := value.(type) {
 	case bool:
 		if bindVal {
@@ -210,11 +217,18 @@ func ArgToString(value interface{}) string {
 		return strconv.FormatFloat(float64(bindVal), 'f', -1, 64)
 
 	case string:
-		return `'` + bindVal + `'`
+		return stringQuote(bindVal)
 	case []byte:
-		return `'` + string(bindVal) + `'`
+		return stringQuote(string(bindVal))
-		//TODO: implement
+	case uuid.UUID:
+		return stringQuote(bindVal.String())
+	case time.Time:
+		return stringQuote(bindVal.String())
 	default:
 		return "[Unknown type]"
 	}
 }
+
+func stringQuote(value string) string {
+	return `'` + strings.Replace(value, "'", "''", -1) + `'`
+}

sqlbuilder/column.go

@@ -57,7 +57,7 @@ func (c *columnImpl) defaultAlias() string {
 	return c.name
 }
 
-func (c *columnImpl) serializeAsOrderBy(statement statementType, out *queryData) error {
+func (c *columnImpl) serializeForOrderBy(statement statementType, out *queryData) error {
 	if statement == set_statement {
 		// set Statement (UNION, EXCEPT ...) can reference only select projections in order by clause
 		columnRef := ""

sqlbuilder/expression.go

@@ -141,7 +141,7 @@ func (e *expressionInterfaceImpl) serializeForProjection(statement statementType
 	return e.parent.serialize(statement, out, NO_WRAP)
 }
 
-func (e *expressionInterfaceImpl) serializeAsOrderBy(statement statementType, out *queryData) error {
+func (e *expressionInterfaceImpl) serializeForOrderBy(statement statementType, out *queryData) error {
 	return e.parent.serialize(statement, out, NO_WRAP)
 }
 

sqlbuilder/expression_test.go

@@ -7,6 +7,7 @@ import (
 func TestExpressionIS_NULL(t *testing.T) {
 	assertClauseSerialize(t, table2Col3.IS_NULL(), "table2.col3 IS NULL")
 	assertClauseSerialize(t, table2Col3.ADD(table2Col3).IS_NULL(), "(table2.col3 + table2.col3) IS NULL")
+	assertClauseSerializeErr(t, table2Col3.ADD(nil), "nil rhs.")
 }
 
 func TestExpressionIS_NOT_NULL(t *testing.T) {

sqlbuilder/insert_statement.go

@@ -14,12 +14,12 @@ type InsertStatement interface {
 
 	// Add a row of values to the insert Statement.
 	VALUES(values ...interface{}) InsertStatement
-	// Map or stracture mapped to column names
+	// Model structure mapped to column names
-	VALUES_MAPPING(data interface{}) InsertStatement
+	MODEL(data interface{}) InsertStatement
-
-	RETURNING(projections ...projection) InsertStatement
 
 	QUERY(selectStatement SelectStatement) InsertStatement
+
+	RETURNING(projections ...projection) InsertStatement
 }
 
 func newInsertStatement(t WritableTable, columns ...Column) InsertStatement {
@@ -39,15 +39,14 @@ type insertStatementImpl struct {
 	errors []string
 }
 
-func (s *insertStatementImpl) Query(db execution.Db, destination interface{}) error {
+func (i *insertStatementImpl) Query(db execution.Db, destination interface{}) error {
-	return Query(s, db, destination)
+	return Query(i, db, destination)
 }
 
-func (u *insertStatementImpl) Execute(db execution.Db) (res sql.Result, err error) {
+func (i *insertStatementImpl) Execute(db execution.Db) (res sql.Result, err error) {
-	return Execute(u, db)
+	return Execute(i, db)
 }
 
-// Expression or default keyword
 func (i *insertStatementImpl) VALUES(values ...interface{}) InsertStatement {
 	if len(values) == 0 {
 		return i
@@ -67,20 +66,16 @@ func (i *insertStatementImpl) VALUES(values ...interface{}) InsertStatement {
 	return i
 }
 
-func (i *insertStatementImpl) VALUES_MAPPING(data interface{}) InsertStatement {
+func (i *insertStatementImpl) MODEL(data interface{}) InsertStatement {
 	if data == nil {
-		i.addError("ADD method data is nil.")
+		i.addError("MODEL : data is nil.")
 		return i
 	}
 
-	value := reflect.ValueOf(data)
+	value := reflect.Indirect(reflect.ValueOf(data))
-
-	if value.Kind() == reflect.Ptr {
-		value = value.Elem()
-	}
 
 	if value.Kind() != reflect.Struct {
-		i.addError("ADD method data is not struct or pointer to struct.")
+		i.addError("MODEL : data is not struct or pointer to struct.")
 		return i
 	}
 
@@ -93,11 +88,21 @@ func (i *insertStatementImpl) VALUES_MAPPING(data interface{}) InsertStatement {
 		structField := value.FieldByName(structFieldName)
 
 		if !structField.IsValid() {
-			i.addError("ADD() : Data structure doesn't contain field : " + structFieldName + " for column " + columnName)
+			i.addError("MODEL : Data structure doesn't contain field for column " + columnName)
 			return i
 		}
 
-		rowValues = append(rowValues, literal(structField.Interface()))
+		var field interface{}
+
+		fieldValue := reflect.Indirect(structField)
+
+		if fieldValue.IsValid() {
+			field = fieldValue.Interface()
+		} else {
+			field = nil
+		}
+
+		rowValues = append(rowValues, literal(field))
 	}
 
 	i.rows = append(i.rows, rowValues)
@@ -106,15 +111,12 @@ func (i *insertStatementImpl) VALUES_MAPPING(data interface{}) InsertStatement {
 }
 
 func (i *insertStatementImpl) RETURNING(projections ...projection) InsertStatement {
-	//i.returning = defaultProjectionAliasing(projections)
 	i.returning = projections
-
 	return i
 }
 
 func (i *insertStatementImpl) QUERY(selectStatement SelectStatement) InsertStatement {
 	i.query = selectStatement
-
 	return i
 }
 
@@ -126,9 +128,9 @@ func (i *insertStatementImpl) DebugSql() (query string, err error) {
 	return DebugSql(i)
 }
 
-func (s *insertStatementImpl) Sql() (sql string, args []interface{}, err error) {
+func (i *insertStatementImpl) Sql() (sql string, args []interface{}, err error) {
-	if len(s.errors) > 0 {
+	if len(i.errors) > 0 {
-		return "", nil, errors.New("sql builder errors: " + strings.Join(s.errors, ", "))
+		return "", nil, errors.New("errors: " + strings.Join(i.errors, ", "))
 	}
 
 	queryData := &queryData{}
@@ -136,42 +138,40 @@ func (s *insertStatementImpl) Sql() (sql string, args []interface{}, err error)
 	queryData.nextLine()
 	queryData.writeString("INSERT INTO")
 
-	if s.table == nil {
+	if isNil(i.table) {
-		return "", nil, errors.New("nil tableName.")
+		return "", nil, errors.New("table is nil")
 	}
 
-	err = s.table.serialize(insert_statement, queryData)
+	err = i.table.serialize(insert_statement, queryData)
-
-	queryData.writeByte(' ')
 
 	if err != nil {
-		return "", nil, err
+		return
 	}
 
-	if len(s.columns) > 0 {
+	if len(i.columns) > 0 {
 		queryData.writeString("(")
 
-		err = serializeColumnList(insert_statement, s.columns, queryData)
+		err = serializeColumnList(insert_statement, i.columns, queryData)
 
 		if err != nil {
-			return "", nil, err
+			return
 		}
 
 		queryData.writeString(")")
 	}
 
-	if len(s.rows) == 0 && s.query == nil {
+	if len(i.rows) == 0 && i.query == nil {
-		return "", nil, errors.New("No row or query  specified.")
+		return "", nil, errors.New("no row values or query  specified")
 	}
 
-	if len(s.rows) > 0 && s.query != nil {
+	if len(i.rows) > 0 && i.query != nil {
-		return "", nil, errors.New("Only new rows or query has to be specified.")
+		return "", nil, errors.New("only row values or query has to be specified")
 	}
 
-	if len(s.rows) > 0 {
+	if len(i.rows) > 0 {
 		queryData.writeString("VALUES")
 
-		for row_i, row := range s.rows {
+		for row_i, row := range i.rows {
 			if row_i > 0 {
 				queryData.writeString(",")
 			}
@@ -180,8 +180,8 @@ func (s *insertStatementImpl) Sql() (sql string, args []interface{}, err error)
 			queryData.nextLine()
 			queryData.writeString("(")
 
-			if len(row) != len(s.columns) {
+			if len(row) != len(i.columns) {
-				return "", nil, errors.New("# of values does not match # of columns.")
+				return "", nil, errors.New("number of values does not match number of columns")
 			}
 
 			err = serializeClauseList(insert_statement, row, queryData)
@@ -195,19 +195,19 @@ func (s *insertStatementImpl) Sql() (sql string, args []interface{}, err error)
 		}
 	}
 
-	if s.query != nil {
+	if i.query != nil {
-		err = s.query.serialize(insert_statement, queryData)
+		err = i.query.serialize(insert_statement, queryData)
 
 		if err != nil {
 			return
 		}
 	}
 
-	if len(s.returning) > 0 {
+	if len(i.returning) > 0 {
 		queryData.nextLine()
 		queryData.writeString("RETURNING")
 
-		err = queryData.writeProjections(insert_statement, s.returning)
+		err = queryData.writeProjections(insert_statement, i.returning)
 
 		if err != nil {
 			return

sqlbuilder/insert_statement_test.go

@@ -105,28 +105,28 @@ INSERT INTO db.table1 (col1,colFloat) VALUES
 
 func TestInsertValuesFromModel(t *testing.T) {
 	type Table1Model struct {
-		Col1     int
+		Col1     *int
 		ColFloat float64
 	}
 
+	one := 1
+
 	toInsert := Table1Model{
-		Col1:     1,
+		Col1:     &one,
 		ColFloat: 1.11,
 	}
 
 	stmt := table1.INSERT(table1Col1, table1ColFloat).
-		VALUES_MAPPING(toInsert)
+		MODEL(toInsert).
+		MODEL(&toInsert)
 
-	sql, _, err := stmt.Sql()
+	expectedSql := `
-
-	assert.NilError(t, err)
-
-	fmt.Println(sql)
-
-	assert.Equal(t, sql, `
 INSERT INTO db.table1 (col1,colFloat) VALUES
-     ($1, $2);
+     ($1, $2),
-`)
+     ($3, $4);
+`
+
+	assertQuery(t, stmt, expectedSql, int(1), float64(1.11), int(1), float64(1.11))
 }
 
 func TestInsertValuesFromModelColumnMismatch(t *testing.T) {
@@ -141,11 +141,11 @@ func TestInsertValuesFromModelColumnMismatch(t *testing.T) {
 	}
 
 	stmt := table1.INSERT(table1Col1, table1ColFloat).
-		VALUES_MAPPING(toInsert)
+		MODEL(toInsert)
 
 	_, _, err := stmt.Sql()
 
-	//fmt.Println(err)
+	fmt.Println(err)
 	assert.Assert(t, err != nil)
 }
 

sqlbuilder/order_by_clause.go

@@ -3,7 +3,7 @@ package sqlbuilder
 import "errors"
 
 type OrderByClause interface {
-	serializeAsOrderBy(statement statementType, out *queryData) error
+	serializeForOrderBy(statement statementType, out *queryData) error
 }
 
 type orderByClauseImpl struct {
@@ -11,12 +11,12 @@ type orderByClauseImpl struct {
 	ascent     bool
 }
 
-func (o *orderByClauseImpl) serializeAsOrderBy(statement statementType, out *queryData) error {
+func (o *orderByClauseImpl) serializeForOrderBy(statement statementType, out *queryData) error {
 	if o.expression == nil {
 		return errors.New("nil orderBy by clause.")
 	}
 
-	if err := o.expression.serializeAsOrderBy(statement, out); err != nil {
+	if err := o.expression.serializeForOrderBy(statement, out); err != nil {
 		return err
 	}
 

sqlbuilder/set_statement.go

@@ -57,7 +57,7 @@ type setStatementImpl struct {
 	selects       []rowsType
 	orderBy       []OrderByClause
 	limit, offset int64
-	// True if results of the union should be deduped.
+
 	all bool
 }
 
@@ -76,7 +76,6 @@ func newSetStatementImpl(operator string, all bool, selects ...rowsType) SetStat
 }
 
 func (us *setStatementImpl) ORDER_BY(orderBy ...OrderByClause) SetStatement {
-
 	us.orderBy = orderBy
 	return us
 }
@@ -100,7 +99,9 @@ func (s *setStatementImpl) serialize(statement statementType, out *queryData, op
 		return errors.New("Set expression is nil. ")
 	}
 
-	if s.orderBy != nil || s.limit >= 0 || s.offset >= 0 {
+	wrap := s.orderBy != nil || s.limit >= 0 || s.offset >= 0
+
+	if wrap {
 		out.writeString("(")
 		out.increaseIdent()
 	}
@@ -111,7 +112,7 @@ func (s *setStatementImpl) serialize(statement statementType, out *queryData, op
 		return err
 	}
 
-	if s.orderBy != nil || s.limit >= 0 || s.offset >= 0 {
+	if wrap {
 		out.decreaseIdent()
 		out.nextLine()
 		out.writeString(")")

sqlbuilder/set_statement_test.go

@@ -162,3 +162,123 @@ func TestUnionInUnion(t *testing.T) {
 	assert.Equal(t, len(args), 0)
 	assert.Equal(t, queryStr, expectedSql)
 }
+
+func TestUnionALL(t *testing.T) {
+	query, args, err := UNION_ALL(
+		table1.SELECT(table1Col1),
+		table2.SELECT(table2Col3),
+	).Sql()
+
+	assert.NilError(t, err)
+	fmt.Println(query)
+	assert.Equal(t, query, `
+(
+     (
+          SELECT table1.col1 AS "table1.col1"
+          FROM db.table1
+     )
+     UNION ALL
+     (
+          SELECT table2.col3 AS "table2.col3"
+          FROM db.table2
+     )
+);
+`)
+	assert.Equal(t, len(args), 0)
+}
+
+func TestINTERSECT(t *testing.T) {
+	query, args, err := INTERSECT(
+		table1.SELECT(table1Col1),
+		table2.SELECT(table2Col3),
+	).Sql()
+
+	assert.NilError(t, err)
+	fmt.Println(query)
+	assert.Equal(t, query, `
+(
+     (
+          SELECT table1.col1 AS "table1.col1"
+          FROM db.table1
+     )
+     INTERSECT
+     (
+          SELECT table2.col3 AS "table2.col3"
+          FROM db.table2
+     )
+);
+`)
+	assert.Equal(t, len(args), 0)
+}
+
+func TestINTERSECT_ALL(t *testing.T) {
+	query, args, err := INTERSECT_ALL(
+		table1.SELECT(table1Col1),
+		table2.SELECT(table2Col3),
+	).Sql()
+
+	assert.NilError(t, err)
+	fmt.Println(query)
+	assert.Equal(t, query, `
+(
+     (
+          SELECT table1.col1 AS "table1.col1"
+          FROM db.table1
+     )
+     INTERSECT ALL
+     (
+          SELECT table2.col3 AS "table2.col3"
+          FROM db.table2
+     )
+);
+`)
+	assert.Equal(t, len(args), 0)
+}
+
+func TestEXCEPT(t *testing.T) {
+	query, args, err := EXCEPT(
+		table1.SELECT(table1Col1),
+		table2.SELECT(table2Col3),
+	).Sql()
+
+	assert.NilError(t, err)
+	fmt.Println(query)
+	assert.Equal(t, query, `
+(
+     (
+          SELECT table1.col1 AS "table1.col1"
+          FROM db.table1
+     )
+     EXCEPT
+     (
+          SELECT table2.col3 AS "table2.col3"
+          FROM db.table2
+     )
+);
+`)
+	assert.Equal(t, len(args), 0)
+}
+
+func TestEXCEPT_ALL(t *testing.T) {
+	query, args, err := EXCEPT_ALL(
+		table1.SELECT(table1Col1),
+		table2.SELECT(table2Col3),
+	).Sql()
+
+	assert.NilError(t, err)
+	fmt.Println(query)
+	assert.Equal(t, query, `
+(
+     (
+          SELECT table1.col1 AS "table1.col1"
+          FROM db.table1
+     )
+     EXCEPT ALL
+     (
+          SELECT table2.col3 AS "table2.col3"
+          FROM db.table2
+     )
+);
+`)
+	assert.Equal(t, len(args), 0)
+}

sqlbuilder/test_utils.go

@@ -80,3 +80,10 @@ func assertProjectionSerialize(t *testing.T, projection projection, query string
 	assert.DeepEqual(t, out.buff.String(), query)
 	assert.DeepEqual(t, out.args, args)
 }
+
+func assertQuery(t *testing.T, query Statement, expectedQuery string, expectedArgs ...interface{}) {
+	queryStr, args, err := query.Sql()
+	assert.NilError(t, err)
+	assert.Equal(t, queryStr, expectedQuery)
+	assert.DeepEqual(t, args, expectedArgs)
+}

sqlbuilder/utils.go

@@ -14,7 +14,7 @@ func serializeOrderByClauseList(statement statementType, orderByClauses []OrderB
 			out.writeString(", ")
 		}
 
-		err := value.serializeAsOrderBy(statement, out)
+		err := value.serializeForOrderBy(statement, out)
 
 		if err != nil {
 			return err

tests/dbconfig/dbconfig.go

@@ -0,0 +1,13 @@
+package dbconfig
+
+import "fmt"
+
+const (
+	Host     = "localhost"
+	Port     = 5432
+	User     = "postgres"
+	Password = "postgres"
+	DBName   = "dvd_rental"
+)
+
+var ConnectString = fmt.Sprintf("host=%s port=%d user=%s "+"password=%s dbname=%s sslmode=disable", Host, Port, User, Password, DBName)

tests/init/data/test_sample.sql

@@ -1,4 +1,6 @@
 
+-- AllTypes table -----------------------------
+
 DROP TABLE IF EXISTS test_sample.all_types;
 
 CREATE TABLE test_sample.all_types
@@ -135,4 +137,55 @@ VALUES (1, 1, 300, 300, 50000, 5000, 11.44, 11.44, 55.77, 55.77, 99.1, 99.1, 111
         NULL, '{1, 2, 3}', NULL, '{"breakfast", "consulting"}', ARRAY['{"a": 1, "b": 2}'::jsonb, '{"a":3, "b": 4}'::jsonb], NULL, '{{"meeting", "lunch"}, {"training", "presentation"}}')
        ;
 
+-- Link table --------------------
 
+DROP TABLE IF EXISTS test_sample.link;
+
+CREATE TABLE IF NOT EXISTS test_sample.link (
+                                                ID serial PRIMARY KEY,
+                                                url VARCHAR (255) NOT NULL,
+                                                name VARCHAR (255) NOT NULL,
+                                                description VARCHAR (255),
+                                                rel VARCHAR (50)
+);
+
+
+-- Employee table ---------------
+
+DROP TABLE IF EXISTS test_sample.employee;
+
+CREATE TABLE test_sample.employee (
+  employee_id INT PRIMARY KEY,
+  first_name VARCHAR (255) NOT NULL,
+  last_name VARCHAR (255) NOT NULL,
+  manager_id INT,
+  FOREIGN KEY (manager_id)
+      REFERENCES test_sample.employee (employee_id)
+      ON DELETE CASCADE
+);
+INSERT INTO test_sample.employee (
+    employee_id,
+    first_name,
+    last_name,
+    manager_id
+)
+VALUES
+(1, 'Windy', 'Hays', NULL),
+(2, 'Ava', 'Christensen', 1),
+(3, 'Hassan', 'Conner', 1),
+(4, 'Anna', 'Reeves', 2),
+(5, 'Sau', 'Norman', 2),
+(6, 'Kelsie', 'Hays', 3),
+(7, 'Tory', 'Goff', 3),
+(8, 'Salley', 'Lester', 3);
+
+
+-- Person table ------------------
+
+DROP TABLE IF EXISTS test_sample.person;
+
+CREATE TABLE test_sample.person(
+    person_id uuid,
+    first_name varchar(100),
+    last_name varchar(100)
+)

tests/init/init.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"database/sql"
+	"github.com/go-jet/jet/generator"
+	"github.com/go-jet/jet/tests/dbconfig"
+	"io/ioutil"
+)
+
+func main() {
+	db, err := sql.Open("postgres", dbconfig.ConnectString)
+	if err != nil {
+		panic("Failed to connect to test db")
+	}
+	defer db.Close()
+
+	testSampleSql, err := ioutil.ReadFile("./init/data/test_sample.sql")
+
+	panicOnError(err)
+
+	_, err = db.Exec(string(testSampleSql))
+
+	panicOnError(err)
+
+	dvdsSql, err := ioutil.ReadFile("./init/data/dvds.sql")
+
+	panicOnError(err)
+
+	_, err = db.Exec(string(dvdsSql))
+
+	panicOnError(err)
+
+	err = generator.Generate("./.test_files", generator.GeneratorData{
+		Host:       dbconfig.Host,
+		Port:       "5432",
+		User:       dbconfig.User,
+		Password:   dbconfig.Password,
+		DBName:     dbconfig.DBName,
+		SchemaName: "dvds",
+	})
+
+	panicOnError(err)
+
+	err = generator.Generate("./.test_files", generator.GeneratorData{
+		Host:       dbconfig.Host,
+		Port:       "5432",
+		User:       dbconfig.User,
+		Password:   dbconfig.Password,
+		DBName:     dbconfig.DBName,
+		SchemaName: "test_sample",
+	})
+
+	panicOnError(err)
+}
+
+func panicOnError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

tests/insert_test.go

@@ -3,20 +3,20 @@ package tests
 import (
 	"fmt"
 	"github.com/davecgh/go-spew/spew"
-	"github.com/go-jet/jet/sqlbuilder"
+	. "github.com/go-jet/jet/sqlbuilder"
 	"github.com/go-jet/jet/tests/.test_files/dvd_rental/test_sample/model"
-	"github.com/go-jet/jet/tests/.test_files/dvd_rental/test_sample/table"
+	. "github.com/go-jet/jet/tests/.test_files/dvd_rental/test_sample/table"
 	"gotest.tools/assert"
 	"testing"
 )
 
 func TestInsertValues(t *testing.T) {
-	insertQuery := table.Link.INSERT(table.Link.URL, table.Link.Name, table.Link.Rel).
+	insertQuery := Link.INSERT(Link.URL, Link.Name, Link.Rel).
-		VALUES("http://www.postgresqltutorial.com", "PostgreSQL Tutorial", sqlbuilder.DEFAULT).
+		VALUES("http://www.postgresqltutorial.com", "PostgreSQL Tutorial", DEFAULT).
-		VALUES("http://www.google.com", "Google", sqlbuilder.DEFAULT).
+		VALUES("http://www.google.com", "Google", DEFAULT).
-		VALUES("http://www.yahoo.com", "Yahoo", sqlbuilder.DEFAULT).
+		VALUES("http://www.yahoo.com", "Yahoo", DEFAULT).
-		VALUES("http://www.bing.com", "Bing", sqlbuilder.DEFAULT).
+		VALUES("http://www.bing.com", "Bing", DEFAULT).
-		RETURNING(table.Link.ID)
+		RETURNING(Link.ID)
 
 	insertQueryStr, args, err := insertQuery.Sql()
 
@@ -44,7 +44,7 @@ RETURNING link.id AS "link.id";
 
 	link := []model.Link{}
 
-	err = table.Link.SELECT(table.Link.AllColumns).Query(db, &link)
+	err = Link.SELECT(Link.AllColumns).Query(db, &link)
 
 	assert.NilError(t, err)
 
@@ -72,9 +72,9 @@ func TestInsertDataObject(t *testing.T) {
 		Rel:  nil,
 	}
 
-	query := table.Link.
+	query := Link.
-		INSERT(table.Link.URL, table.Link.Name).
+		INSERT(Link.URL, Link.Name).
-		VALUES_MAPPING(linkData)
+		MODEL(linkData)
 
 	queryStr, args, err := query.Sql()
 
@@ -92,14 +92,14 @@ func TestInsertDataObject(t *testing.T) {
 
 func TestInsertQuery(t *testing.T) {
 
-	_, err := table.Link.INSERT(table.Link.URL, table.Link.Name).
+	_, err := Link.INSERT(Link.URL, Link.Name).
 		VALUES("http://www.postgresqltutorial.com", "PostgreSQL Tutorial").Execute(db)
 
 	assert.NilError(t, err)
 
-	query := table.Link.
+	query := Link.
-		INSERT(table.Link.URL, table.Link.Name).
+		INSERT(Link.URL, Link.Name).
-		QUERY(table.Link.SELECT(table.Link.URL, table.Link.Name))
+		QUERY(Link.SELECT(Link.URL, Link.Name))
 
 	queryStr, args, err := query.Sql()
 
@@ -113,7 +113,7 @@ func TestInsertQuery(t *testing.T) {
 	assert.NilError(t, err)
 
 	allLinks := []model.Link{}
-	err = table.Link.SELECT(table.Link.AllColumns).Query(db, &allLinks)
+	err = Link.SELECT(Link.AllColumns).Query(db, &allLinks)
 	assert.NilError(t, err)
 
 	spew.Dump(allLinks)

tests/main_test.go

@@ -2,8 +2,8 @@ package tests
 
 import (
 	"database/sql"
-	"fmt"
 	"github.com/go-jet/jet/tests/.test_files/dvd_rental/dvds/model"
+	"github.com/go-jet/jet/tests/dbconfig"
 	_ "github.com/lib/pq"
 	"github.com/pkg/profile"
 	"gotest.tools/assert"
@@ -12,103 +12,23 @@ import (
 	"testing"
 )
 
-const (
-	host     = "localhost"
-	port     = 5432
-	user     = "postgres"
-	password = "postgres"
-	dbname   = "dvd_rental"
-)
-
-var connectString = fmt.Sprintf("host=%s port=%d user=%s "+"password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
 var db *sql.DB
 
-//var tx *sql.Tx
-
-//go:generate generator -host=localhost -port=5432 -user=postgres -password=postgres -dbname=dvd_rental -schema dvds -path .test_files
-//go:generate generator -host=localhost -port=5432 -user=postgres -password=postgres -dbname=dvd_rental -sslmode=disable -schema test_sample -path .test_files
-
 func TestMain(m *testing.M) {
-	fmt.Println("Begin")
-
 	defer profile.Start().Stop()
 
 	var err error
-	db, err = sql.Open("postgres", connectString)
+	db, err = sql.Open("postgres", dbconfig.ConnectString)
 	if err != nil {
 		panic("Failed to connect to test db")
 	}
-	//tx, _ = db.Begin()
+	defer db.Close()
-	defer cleanUp()
-
-	dbInit()
 
 	ret := m.Run()
 
-	cleanUp()
-	fmt.Println("END")
-
 	os.Exit(ret)
 }
 
-func cleanUp() {
-	fmt.Println("CLEAN UP")
-
-	//tx.Rollback()
-	db.Close()
-}
-
-func dbInit() {
-	linkTableCreate := `
-DROP TABLE IF EXISTS test_sample.link;
-
-CREATE TABLE IF NOT EXISTS test_sample.link (
- ID serial PRIMARY KEY,
- url VARCHAR (255) NOT NULL,
- name VARCHAR (255) NOT NULL,
- description VARCHAR (255),
- rel VARCHAR (50)
-);
-
-DROP TABLE IF EXISTS test_sample.employee;
-
-CREATE TABLE test_sample.employee (
- employee_id INT PRIMARY KEY,
- first_name VARCHAR (255) NOT NULL,
- last_name VARCHAR (255) NOT NULL,
- manager_id INT,
- FOREIGN KEY (manager_id) 
- REFERENCES test_sample.employee (employee_id) 
- ON DELETE CASCADE
-);
-INSERT INTO test_sample.employee (
- employee_id,
- first_name,
- last_name,
- manager_id
-)
-VALUES
- (1, 'Windy', 'Hays', NULL),
- (2, 'Ava', 'Christensen', 1),
- (3, 'Hassan', 'Conner', 1),
- (4, 'Anna', 'Reeves', 2),
- (5, 'Sau', 'Norman', 2),
- (6, 'Kelsie', 'Hays', 3),
- (7, 'Tory', 'Goff', 3),
- (8, 'Salley', 'Lester', 3);
-
-`
-
-	result, err := db.Exec(linkTableCreate)
-
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Println(result)
-
-}
-
 func TestGenerateModel(t *testing.T) {
 
 	actor := model.Actor{}

tests/types_test.go

@@ -25,6 +25,18 @@ func TestAllTypesSelect(t *testing.T) {
 	assert.DeepEqual(t, dest[1], allTypesRow1)
 }
 
+func TestAllTypesInsert(t *testing.T) {
+	query := AllTypes.INSERT(AllTypes.AllColumns...).
+		MODEL(allTypesRow0).
+		MODEL(&allTypesRow1)
+
+	_, err := query.Execute(db)
+
+	assert.NilError(t, err)
+
+	fmt.Println(query.DebugSql())
+}
+
 func TestExpressionOperators(t *testing.T) {
 	query := AllTypes.SELECT(
 		AllTypes.Integer.IS_NULL(),