feat: Create, Drop and Extended Select

create.go

@@ -0,0 +1,235 @@
+package squirrel
+
+import (
+	"bytes"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+
+	"github.com/lann/builder"
+)
+
+type createStmt struct {
+	PlaceholderFormat PlaceholderFormat
+	RunWith           BaseRunner
+	Prefixes          []Sqlizer
+	StatementKeyword  string
+	Table             string
+	Columns           []string
+	Types             []string
+	PrimaryKey        []Sqlizer
+	Suffixes          []Sqlizer
+}
+
+func (d *createStmt) Exec() (sql.Result, error) {
+	if d.RunWith == nil {
+		return nil, RunnerNotSet
+	}
+	return ExecWith(d.RunWith, d)
+}
+
+func (d *createStmt) Query() (*sql.Rows, error) {
+	if d.RunWith == nil {
+		return nil, RunnerNotSet
+	}
+	return QueryWith(d.RunWith, d)
+}
+
+func (d *createStmt) ToSql() (sqlStr string, args []interface{}, err error) {
+	if len(d.Table) == 0 {
+		err = errors.New("create statements must specify a table")
+		return
+	}
+	if len(d.Columns) == 0 {
+		err = errors.New("create statements must have at least one set of columns")
+		return
+	}
+
+	sql := &bytes.Buffer{}
+
+	if len(d.Prefixes) > 0 {
+		args, err = appendToSql(d.Prefixes, sql, " ", args)
+		if err != nil {
+			return
+		}
+
+		sql.WriteString(" ")
+	}
+	if d.StatementKeyword == "" {
+		sql.WriteString("CREATE ")
+	} else {
+		sql.WriteString(d.StatementKeyword)
+		sql.WriteString(" ")
+	}
+	sql.WriteString("TABLE ")
+	sql.WriteString(d.Table)
+	sql.WriteString(" ")
+	sql.WriteString("( ")
+	err = d.appendValuesToSQL(sql)
+	if len(d.PrimaryKey) > 0 {
+		sql.WriteString(", PRIMARY KEY ")
+		sql.WriteString("(")
+		args, err = appendToSql(d.PrimaryKey, sql, ", ", args)
+		sql.WriteString(")")
+		if err != nil {
+			return
+		}
+	}
+	sql.WriteString(" )")
+
+	if err != nil {
+		return
+	}
+	if len(d.Suffixes) > 0 {
+		sql.WriteString(" ")
+		args, err = appendToSql(d.Suffixes, sql, " ", args)
+		if err != nil {
+			return
+		}
+	}
+	sqlStr, err = d.PlaceholderFormat.ReplacePlaceholders(sql.String())
+	return
+}
+
+func (d *createStmt) appendValuesToSQL(w io.Writer) error {
+	if len(d.Columns) == 0 {
+		return errors.New("columns for create statements are not set")
+	}
+	if len(d.Types) == 0 {
+		return errors.New("types for create statements are not set")
+	}
+	if len(d.Types) != len(d.Columns) {
+		return errors.New("types size are not equal to columns for create statements are not set")
+	}
+	valueStrings := make([]string, len(d.Columns))
+	for i, col := range d.Columns {
+		valueStrings[i] = fmt.Sprintf("%s %s", col, d.Types[i])
+		valueStrings[i] = strings.TrimSuffix(valueStrings[i], " ")
+	}
+	io.WriteString(w, strings.Join(valueStrings, ", "))
+
+	return nil
+}
+
+// Builder
+
+// CreateBuilder builds SQL CREATE statements.
+type CreateBuilder builder.Builder
+
+func init() {
+	builder.Register(CreateBuilder{}, createStmt{})
+}
+
+// Format methods
+
+// PlaceholderFormat sets PlaceholderFormat (e.g. Question or Dollar) for the
+// query.
+func (b CreateBuilder) PlaceholderFormat(f PlaceholderFormat) CreateBuilder {
+	return builder.Set(b, "PlaceholderFormat", f).(CreateBuilder)
+}
+
+// Runner methods
+
+// RunWith sets a Runner (like database/sql.DB) to be used with e.g. Exec.
+func (b CreateBuilder) RunWith(runner BaseRunner) CreateBuilder {
+	return setRunWith(b, runner).(CreateBuilder)
+}
+
+// Exec builds and Execs the query with the Runner set by RunWith.
+func (b CreateBuilder) Exec() (sql.Result, error) {
+	data := builder.GetStruct(b).(createStmt)
+	return data.Exec()
+}
+
+// Query builds and Querys the query with the Runner set by RunWith.
+func (b CreateBuilder) Query() (*sql.Rows, error) {
+	data := builder.GetStruct(b).(createStmt)
+	return data.Query()
+}
+
+// SQL methods
+
+// ToSql builds the query into a SQL string and bound args.
+func (b CreateBuilder) ToSql() (string, []interface{}, error) {
+	data := builder.GetStruct(b).(createStmt)
+	return data.ToSql()
+}
+
+// MustSql builds the query into a SQL string and bound args.
+// It panics if there are any errors.
+func (b CreateBuilder) MustSql() (string, []interface{}) {
+	sql, args, err := b.ToSql()
+	if err != nil {
+		panic(err)
+	}
+	return sql, args
+}
+
+// Prefix adds an expression to the beginning of the query
+func (b CreateBuilder) Prefix(sql string, args ...interface{}) CreateBuilder {
+	return b.PrefixExpr(Expr(sql, args...))
+}
+
+// PrefixExpr adds an expression to the very beginning of the query
+func (b CreateBuilder) PrefixExpr(expr Sqlizer) CreateBuilder {
+	return builder.Append(b, "Prefixes", expr).(CreateBuilder)
+}
+
+// Table sets the TABLE clause of the query.
+func (b CreateBuilder) Table(table string) CreateBuilder {
+	return builder.Set(b, "Table", table).(CreateBuilder)
+}
+
+// Columns adds create columns to the query.
+func (b CreateBuilder) Columns(columns ...string) CreateBuilder {
+	return builder.Extend(b, "Columns", columns).(CreateBuilder)
+}
+
+// Types adds create types to the query.
+func (b CreateBuilder) Types(types ...string) CreateBuilder {
+	return builder.Extend(b, "Types", types).(CreateBuilder)
+}
+
+// PrimaryKey adds an primary key to the query
+func (b CreateBuilder) PrimaryKey(sql string, args ...interface{}) CreateBuilder {
+	return b.PrimaryKeyExpr(Expr(sql, args...))
+}
+
+// PrimaryKeyExpr adds an expression to the query
+func (b CreateBuilder) PrimaryKeyExpr(expr Sqlizer) CreateBuilder {
+	return builder.Append(b, "PrimaryKey", expr).(CreateBuilder)
+}
+
+// Suffix adds an expression to the end of the query
+func (b CreateBuilder) Suffix(sql string, args ...interface{}) CreateBuilder {
+	return b.SuffixExpr(Expr(sql, args...))
+}
+
+// SuffixExpr adds an expression to the end of the query
+func (b CreateBuilder) SuffixExpr(expr Sqlizer) CreateBuilder {
+	return builder.Append(b, "Suffixes", expr).(CreateBuilder)
+}
+
+// SetMap set columns and values for insert builder from a map of column name and value
+// note that it will reset all previous columns and values was set if any
+func (b CreateBuilder) SetMap(clauses map[string]string) CreateBuilder {
+	// Keep the columns in a consistent order by sorting the column key string.
+	cols := make([]string, 0, len(clauses))
+	for col := range clauses {
+		cols = append(cols, col+" "+clauses[col])
+	}
+	sort.Strings(cols)
+
+	vals := make([]string, 0, len(clauses))
+	for _, col := range cols {
+		vals = append(vals, clauses[col])
+	}
+
+	b = builder.Set(b, "Columns", cols).(CreateBuilder)
+	b = builder.Set(b, "Types", vals).(CreateBuilder)
+
+	return b
+}

create_test.go

@@ -0,0 +1,98 @@
+package squirrel
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateBuilderToSql(t *testing.T) {
+	b := Create("test").
+		Prefix("WITH prefix AS ?", 0).
+		Columns("id", "a", "b").
+		Types("INT", "TEXT", "DATE").
+		PrimaryKey("id").
+		Suffix("RETURNING ?", 4)
+
+	sql, args, err := b.ToSql()
+	assert.NoError(t, err)
+
+	expectedSql :=
+		"WITH prefix AS ? " +
+			"CREATE TABLE test ( id INT, a TEXT, b DATE, PRIMARY KEY (id) ) " +
+			"RETURNING ?"
+	assert.Equal(t, expectedSql, sql)
+
+	expectedArgs := []interface{}{0, 4}
+	assert.Equal(t, expectedArgs, args)
+}
+
+func TestCreateBuilderSetMapToSql(t *testing.T) {
+	b := Create("test").
+		SetMap(map[string]string{
+			"a": "INT",
+			"b": "TEXT",
+			"c": "DATE",
+			"d": "TIMESTAMP",
+		})
+
+	sql, _, err := b.ToSql()
+	assert.NoError(t, err)
+
+	expectedSql := "CREATE TABLE test ( a INT, b TEXT, c DATE, d TIMESTAMP )"
+	assert.Equal(t, expectedSql, sql)
+}
+
+func TestCreateBuilderToSqlErr(t *testing.T) {
+	_, _, err := Create("").ToSql()
+	assert.Error(t, err)
+}
+
+func TestCreateBuilderMustSql(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("TestCreateBuilderMustSql should have panicked!")
+		}
+	}()
+	Create("").MustSql()
+}
+
+func TestCreateBuilderPlaceholders(t *testing.T) {
+	b := Create("test").Columns("id", "a", "b").
+		Types("INT", "TEXT", "DATE").Suffix("SUFFIX x = ? AND y = ?")
+
+	sql, _, _ := b.PlaceholderFormat(Question).ToSql()
+	assert.Equal(t, "CREATE TABLE test ( id INT, a TEXT, b DATE ) SUFFIX x = ? AND y = ?", sql)
+
+	sql, _, _ = b.PlaceholderFormat(Dollar).ToSql()
+	assert.Equal(t, "CREATE TABLE test ( id INT, a TEXT, b DATE ) SUFFIX x = $1 AND y = $2", sql)
+}
+
+func TestCreateBuilderRunners(t *testing.T) {
+	db := &DBStub{}
+	b := Create("test").Columns("id", "a", "b").
+		Types("INT", "TEXT", "DATE").Suffix("SUFFIX x = ?").RunWith(db)
+
+	expectedSql := "CREATE TABLE test ( id INT, a TEXT, b DATE ) SUFFIX x = ?"
+
+	b.Exec()
+	assert.Equal(t, expectedSql, db.LastExecSql)
+}
+
+func TestCreateBuilderNoRunner(t *testing.T) {
+	b := Create("test")
+
+	_, err := b.Exec()
+	assert.Equal(t, RunnerNotSet, err)
+}
+
+func TestCreateWithQuery(t *testing.T) {
+	db := &DBStub{}
+	b := Create("test").Columns("id", "a", "b").
+		Types("INT", "TEXT", "DATE").Suffix("RETURNING path").RunWith(db)
+
+	expectedSql := "CREATE TABLE test ( id INT, a TEXT, b DATE ) RETURNING path"
+	b.Query()
+
+	assert.Equal(t, expectedSql, db.LastQuerySql)
+}