Cloning files from https://github.com/dropbox/godropbox/tree/master/database

sqlbuilder/column.go

@@ -0,0 +1,302 @@
+// Modeling of columns
+
+package sqlbuilder
+
+import (
+	"bytes"
+	"regexp"
+
+	"github.com/dropbox/godropbox/errors"
+)
+
+// XXX: Maybe add UIntColumn
+
+// Representation of a table for query generation
+type Column interface {
+	isProjectionInterface
+
+	Name() string
+	// Serialization for use in column lists
+	SerializeSqlForColumnList(out *bytes.Buffer) error
+	// Serialization for use in an expression (Clause)
+	SerializeSql(out *bytes.Buffer) error
+
+	// Internal function for tracking table that a column belongs to
+	// for the purpose of serialization
+	setTableName(table string) error
+}
+
+type NullableColumn bool
+
+const (
+	Nullable    NullableColumn = true
+	NotNullable NullableColumn = false
+)
+
+// A column that can be refer to outside of the projection list
+type NonAliasColumn interface {
+	Column
+	isOrderByClauseInterface
+	isExpressionInterface
+}
+
+type Collation string
+
+const (
+	UTF8CaseInsensitive Collation = "utf8_unicode_ci"
+	UTF8CaseSensitive   Collation = "utf8_unicode"
+	UTF8Binary          Collation = "utf8_bin"
+)
+
+// Representation of MySQL charsets
+type Charset string
+
+const (
+	UTF8 Charset = "utf8"
+)
+
+// The base type for real materialized columns.
+type baseColumn struct {
+	isProjection
+	isExpression
+	name     string
+	nullable NullableColumn
+	table    string
+}
+
+func (c *baseColumn) Name() string {
+	return c.name
+}
+
+func (c *baseColumn) setTableName(table string) error {
+	c.table = table
+	return nil
+}
+
+func (c *baseColumn) SerializeSqlForColumnList(out *bytes.Buffer) error {
+	if c.table != "" {
+		_ = out.WriteByte('`')
+		_, _ = out.WriteString(c.table)
+		_, _ = out.WriteString("`.")
+	}
+	_, _ = out.WriteString("`")
+	_, _ = out.WriteString(c.name)
+	_ = out.WriteByte('`')
+	return nil
+}
+
+func (c *baseColumn) SerializeSql(out *bytes.Buffer) error {
+	return c.SerializeSqlForColumnList(out)
+}
+
+type bytesColumn struct {
+	baseColumn
+	isExpression
+}
+
+// Representation of VARBINARY/BLOB columns
+// This function will panic if name is not valid
+func BytesColumn(name string, nullable NullableColumn) NonAliasColumn {
+	if !validIdentifierName(name) {
+		panic("Invalid column name in bytes column")
+	}
+	bc := &bytesColumn{}
+	bc.name = name
+	bc.nullable = nullable
+	return bc
+}
+
+type stringColumn struct {
+	baseColumn
+	isExpression
+	charset   Charset
+	collation Collation
+}
+
+// Representation of VARCHAR/TEXT columns
+// This function will panic if name is not valid
+func StrColumn(
+	name string,
+	charset Charset,
+	collation Collation,
+	nullable NullableColumn) NonAliasColumn {
+
+	if !validIdentifierName(name) {
+		panic("Invalid column name in str column")
+	}
+	sc := &stringColumn{charset: charset, collation: collation}
+	sc.name = name
+	sc.nullable = nullable
+	return sc
+}
+
+type dateTimeColumn struct {
+	baseColumn
+	isExpression
+}
+
+// Representation of DateTime columns
+// This function will panic if name is not valid
+func DateTimeColumn(name string, nullable NullableColumn) NonAliasColumn {
+	if !validIdentifierName(name) {
+		panic("Invalid column name in datetime column")
+	}
+	dc := &dateTimeColumn{}
+	dc.name = name
+	dc.nullable = nullable
+	return dc
+}
+
+type integerColumn struct {
+	baseColumn
+	isExpression
+}
+
+// Representation of any integer column
+// This function will panic if name is not valid
+func IntColumn(name string, nullable NullableColumn) NonAliasColumn {
+	if !validIdentifierName(name) {
+		panic("Invalid column name in int column")
+	}
+	ic := &integerColumn{}
+	ic.name = name
+	ic.nullable = nullable
+	return ic
+}
+
+type doubleColumn struct {
+	baseColumn
+	isExpression
+}
+
+// Representation of any double column
+// This function will panic if name is not valid
+func DoubleColumn(name string, nullable NullableColumn) NonAliasColumn {
+	if !validIdentifierName(name) {
+		panic("Invalid column name in int column")
+	}
+	ic := &doubleColumn{}
+	ic.name = name
+	ic.nullable = nullable
+	return ic
+}
+
+type booleanColumn struct {
+	baseColumn
+	isExpression
+
+	// XXX: Maybe allow isBoolExpression (for now, not included because
+	// the deferred lookup equivalent can never be isBoolExpression)
+}
+
+// Representation of TINYINT used as a bool
+// This function will panic if name is not valid
+func BoolColumn(name string, nullable NullableColumn) NonAliasColumn {
+	if !validIdentifierName(name) {
+		panic("Invalid column name in bool column")
+	}
+	bc := &booleanColumn{}
+	bc.name = name
+	bc.nullable = nullable
+	return bc
+}
+
+type aliasColumn struct {
+	baseColumn
+	expression Expression
+}
+
+func (c *aliasColumn) SerializeSql(out *bytes.Buffer) error {
+	_ = out.WriteByte('`')
+	_, _ = out.WriteString(c.name)
+	_ = out.WriteByte('`')
+	return nil
+}
+
+func (c *aliasColumn) SerializeSqlForColumnList(out *bytes.Buffer) error {
+	if !validIdentifierName(c.name) {
+		return errors.Newf(
+			"Invalid alias name `%s`.  Generated sql: %s",
+			c.name,
+			out.String())
+	}
+	if c.expression == nil {
+		return errors.Newf(
+			"Cannot alias a nil expression.  Generated sql: %s",
+			out.String())
+	}
+
+	_ = out.WriteByte('(')
+	if c.expression == nil {
+		return errors.Newf("nil alias clause.  Generate sql: %s", out.String())
+	}
+	if err := c.expression.SerializeSql(out); err != nil {
+		return err
+	}
+	_, _ = out.WriteString(") AS `")
+	_, _ = out.WriteString(c.name)
+	_ = out.WriteByte('`')
+	return nil
+}
+
+func (c *aliasColumn) setTableName(table string) error {
+	return errors.Newf(
+		"Alias column '%s' should never have setTableName called on it",
+		c.name)
+}
+
+// Representation of aliased clauses (expression AS name)
+func Alias(name string, c Expression) Column {
+	ac := &aliasColumn{}
+	ac.name = name
+	ac.expression = c
+	return ac
+}
+
+// This is a strict subset of the actual allowed identifiers
+var validIdentifierRegexp = regexp.MustCompile("^[a-zA-Z_]\\w*$")
+
+// Returns true if the given string is suitable as an identifier.
+func validIdentifierName(name string) bool {
+	return validIdentifierRegexp.MatchString(name)
+}
+
+// Pseudo Column type returned by table.C(name)
+type deferredLookupColumn struct {
+	isProjection
+	isExpression
+	table   *Table
+	colName string
+
+	cachedColumn NonAliasColumn
+}
+
+func (c *deferredLookupColumn) Name() string {
+	return c.colName
+}
+
+func (c *deferredLookupColumn) SerializeSqlForColumnList(
+	out *bytes.Buffer) error {
+
+	return c.SerializeSql(out)
+}
+
+func (c *deferredLookupColumn) SerializeSql(out *bytes.Buffer) error {
+	if c.cachedColumn != nil {
+		return c.cachedColumn.SerializeSql(out)
+	}
+
+	col, err := c.table.getColumn(c.colName)
+	if err != nil {
+		return err
+	}
+
+	c.cachedColumn = col
+	return col.SerializeSql(out)
+}
+
+func (c *deferredLookupColumn) setTableName(table string) error {
+	return errors.Newf(
+		"Lookup column '%s' should never have setTableName called on it",
+		c.colName)
+}

sqlbuilder/column_test.go

@@ -0,0 +1,208 @@
+package sqlbuilder
+
+import (
+	"bytes"
+	"testing"
+
+	gc "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) {
+	gc.TestingT(t)
+}
+
+type ColumnSuite struct {
+}
+
+var _ = gc.Suite(&ColumnSuite{})
+
+//
+// tests for baseColumn and columns that extends baseColumn
+//
+
+func (s *ColumnSuite) TestRealColumnName(c *gc.C) {
+	col := IntColumn("col", Nullable)
+
+	c.Assert(col.Name(), gc.Equals, "col")
+}
+
+func (s *ColumnSuite) TestRealColumnSerializeSqlForColumnList(c *gc.C) {
+	col := IntColumn("col", Nullable)
+
+	// Without table name
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSqlForColumnList(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`col`")
+
+	// With table name
+	err = col.setTableName("foo")
+	c.Assert(err, gc.IsNil)
+
+	buf = &bytes.Buffer{}
+
+	err = col.SerializeSqlForColumnList(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql = buf.String()
+	c.Assert(sql, gc.Equals, "`foo`.`col`")
+}
+
+func (s *ColumnSuite) TestRealColumnSerializeSql(c *gc.C) {
+	col := IntColumn("col", Nullable)
+
+	// Without table name
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`col`")
+
+	// With table name
+	err = col.setTableName("foo")
+	c.Assert(err, gc.IsNil)
+
+	buf = &bytes.Buffer{}
+
+	err = col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql = buf.String()
+	c.Assert(sql, gc.Equals, "`foo`.`col`")
+}
+
+//
+// tests for AliasCoulmns
+//
+
+func (s *ColumnSuite) TestAliasColumnName(c *gc.C) {
+	col := Alias("foo", SqlFunc("max", table1Col1))
+
+	c.Assert(col.Name(), gc.Equals, "foo")
+}
+
+func (s *ColumnSuite) TestAliasColumnSerializeSqlForColumnList(c *gc.C) {
+	col := Alias("foo", SqlFunc("max", table1Col1))
+
+	buf := &bytes.Buffer{}
+	err := col.SerializeSqlForColumnList(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(sql, gc.Equals, "(max(`table1`.`col1`)) AS `foo`")
+}
+
+func (s *ColumnSuite) TestAliasColumnSerializeSqlForColumnListNilExpr(c *gc.C) {
+	col := Alias("foo", nil)
+
+	buf := &bytes.Buffer{}
+	err := col.SerializeSqlForColumnList(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ColumnSuite) TestAliasColumnSerializeSqlForColumnListInvalidAlias(
+	c *gc.C) {
+
+	col := Alias("1234", SqlFunc("max", table1Col1))
+
+	buf := &bytes.Buffer{}
+	err := col.SerializeSqlForColumnList(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ColumnSuite) TestAliasColumnSerializeSql(c *gc.C) {
+	col := Alias("foo", SqlFunc("max", table1Col1))
+
+	buf := &bytes.Buffer{}
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`foo`")
+}
+
+func (s *ColumnSuite) TestAliasColumnSetTableName(c *gc.C) {
+	col := Alias("foo", SqlFunc("max", table1Col1))
+
+	// should always error
+	err := col.setTableName("test")
+	c.Assert(err, gc.NotNil)
+}
+
+//
+// tests for deferredLookkupColumnName
+//
+
+func (s *ColumnSuite) TestDeferredLookupColumnName(c *gc.C) {
+	col := table1.C("foo")
+
+	c.Assert(col.Name(), gc.Equals, "foo")
+}
+
+func (s *ColumnSuite) TestDeferredLookupColumnSerializeSqlForColumnList(
+	c *gc.C) {
+
+	col := table1.C("col1")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`")
+
+	// check cached lookup
+	buf = &bytes.Buffer{}
+
+	err = col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql = buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`")
+}
+
+func (s *ColumnSuite) TestDeferredLookupColumnSerializeSqlForColumnListInvalidName(
+	c *gc.C) {
+	col := table1.C("foo")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ColumnSuite) TestDeferredLookupColumnSerializeSql(c *gc.C) {
+	col := table1.C("col1")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`")
+}
+
+func (s *ColumnSuite) TestDeferredLookupColumnSerializeSqlInvalidName(c *gc.C) {
+	col := table1.C("foo")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ColumnSuite) TestDeferredLookupColumnSetTableName(c *gc.C) {
+	col := table1.C("col1")
+
+	err := col.setTableName("foo")
+	c.Assert(err, gc.NotNil)
+}

sqlbuilder/doc.go

@@ -0,0 +1,25 @@
+// A library for generating sql programmatically.
+//
+// SQL COMPATIBILITY NOTE: sqlbuilder is designed to generate valid MySQL sql
+// statements.  The generated statements may not work for other sql variants.
+// For instances, the generated statements does not currently work for
+// PostgreSQL since column identifiers are escaped with backquotes.
+// Patches to support other sql flavors are welcome! (see
+// https://godropbox/issues/33 for additional details).
+//
+// Known limitations for SELECT queries:
+//  - does not support subqueries (since mysql is bad at it)
+//  - does not currently support join table alias (and hence self join)
+//  - does not support NATURAL joins and join USING
+//
+// Known limitation for INSERT statements:
+//  - does not support "INSERT INTO SELECT"
+//
+// Known limitation for UPDATE statements:
+//  - does not support update without a WHERE clause (since it is dangerous)
+//  - does not support multi-table update
+//
+// Known limitation for DELETE statements:
+//  - does not support delete without a WHERE clause (since it is dangerous)
+//  - does not support multi-table delete
+package sqlbuilder

sqlbuilder/example_test.go

@@ -0,0 +1,38 @@
+package sqlbuilder
+
+import "fmt"
+
+func Example() {
+	t1 := NewTable(
+		"parent_prefix",
+		IntColumn("ns_id", NotNullable),
+		IntColumn("hash", NotNullable),
+		StrColumn("prefix",
+			UTF8,
+			UTF8CaseInsensitive,
+			NotNullable))
+
+	t2 := NewTable(
+		"sfj",
+		IntColumn("ns_id", NotNullable),
+		IntColumn("sjid", NotNullable),
+		StrColumn("filename",
+			UTF8,
+			UTF8CaseInsensitive,
+			NotNullable))
+
+	ns_id1 := t1.C("ns_id")
+	prefix := t1.C("prefix")
+	ns_id2 := t2.C("ns_id")
+	sjid := t2.C("sjid")
+	filename := t2.C("filename")
+
+	in := []int32{1, 2, 3}
+	join := t2.LeftJoinOn(t1, Eq(ns_id1, ns_id2))
+	q := join.Select(ns_id2, sjid, prefix, filename).Where(
+		And(EqL(ns_id2, 456), In(sjid, in)))
+	text, _ := q.String("shard1")
+	fmt.Println(text)
+	// Output:
+	// SELECT `sfj`.`ns_id`,`sfj`.`sjid`,`parent_prefix`.`prefix`,`sfj`.`filename` FROM `shard1`.`sfj` LEFT JOIN `shard1`.`parent_prefix` ON `parent_prefix`.`ns_id`=`sfj`.`ns_id` WHERE (`sfj`.`ns_id`=456 AND `sfj`.`sjid` IN (1,2,3))
+}

sqlbuilder/expression.go

@@ -0,0 +1,732 @@
+// Query building functions for expression components
+package sqlbuilder
+
+import (
+	"bytes"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/dropbox/godropbox/database/sqltypes"
+	"github.com/dropbox/godropbox/errors"
+)
+
+type orderByClause struct {
+	isOrderByClause
+	expression Expression
+	ascent     bool
+}
+
+func (o *orderByClause) SerializeSql(out *bytes.Buffer) error {
+	if o.expression == nil {
+		return errors.Newf(
+			"nil order by clause.  Generated sql: %s",
+			out.String())
+	}
+
+	if err := o.expression.SerializeSql(out); err != nil {
+		return err
+	}
+
+	if o.ascent {
+		_, _ = out.WriteString(" ASC")
+	} else {
+		_, _ = out.WriteString(" DESC")
+	}
+
+	return nil
+}
+
+func Asc(expression Expression) OrderByClause {
+	return &orderByClause{expression: expression, ascent: true}
+}
+
+func Desc(expression Expression) OrderByClause {
+	return &orderByClause{expression: expression, ascent: false}
+}
+
+// Representation of an escaped literal
+type literalExpression struct {
+	isExpression
+	value sqltypes.Value
+}
+
+func (c literalExpression) SerializeSql(out *bytes.Buffer) error {
+	sqltypes.Value(c.value).EncodeSql(out)
+	return nil
+}
+
+func serializeClauses(
+	clauses []Clause,
+	separator []byte,
+	out *bytes.Buffer) (err error) {
+
+	if clauses == nil || len(clauses) == 0 {
+		return errors.Newf("Empty clauses.  Generated sql: %s", out.String())
+	}
+
+	if clauses[0] == nil {
+		return errors.Newf("nil clause.  Generated sql: %s", out.String())
+	}
+	if err = clauses[0].SerializeSql(out); err != nil {
+		return
+	}
+
+	for _, c := range clauses[1:] {
+		_, _ = out.Write(separator)
+
+		if c == nil {
+			return errors.Newf("nil clause.  Generated sql: %s", out.String())
+		}
+		if err = c.SerializeSql(out); err != nil {
+			return
+		}
+	}
+
+	return nil
+}
+
+// Representation of n-ary conjunctions (AND/OR)
+type conjunctExpression struct {
+	isExpression
+	isBoolExpression
+	expressions []BoolExpression
+	conjunction []byte
+}
+
+func (conj *conjunctExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	if len(conj.expressions) == 0 {
+		return errors.Newf(
+			"Empty conjunction.  Generated sql: %s",
+			out.String())
+	}
+
+	clauses := make([]Clause, len(conj.expressions), len(conj.expressions))
+	for i, expr := range conj.expressions {
+		clauses[i] = expr
+	}
+
+	useParentheses := len(clauses) > 1
+	if useParentheses {
+		_ = out.WriteByte('(')
+	}
+
+	if err = serializeClauses(clauses, conj.conjunction, out); err != nil {
+		return
+	}
+
+	if useParentheses {
+		_ = out.WriteByte(')')
+	}
+
+	return nil
+}
+
+// Representation of n-ary arithmetic (+ - * /)
+type arithmeticExpression struct {
+	isExpression
+	expressions []Expression
+	operator    []byte
+}
+
+func (arith *arithmeticExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	if len(arith.expressions) == 0 {
+		return errors.Newf(
+			"Empty arithmetic expression.  Generated sql: %s",
+			out.String())
+	}
+
+	clauses := make([]Clause, len(arith.expressions), len(arith.expressions))
+	for i, expr := range arith.expressions {
+		clauses[i] = expr
+	}
+
+	useParentheses := len(clauses) > 1
+	if useParentheses {
+		_ = out.WriteByte('(')
+	}
+
+	if err = serializeClauses(clauses, arith.operator, out); err != nil {
+		return
+	}
+
+	if useParentheses {
+		_ = out.WriteByte(')')
+	}
+
+	return nil
+}
+
+type tupleExpression struct {
+	isExpression
+	elements listClause
+}
+
+func (tuple *tupleExpression) SerializeSql(out *bytes.Buffer) error {
+	if len(tuple.elements.clauses) < 1 {
+		return errors.Newf("Tuples must include at least one element")
+	}
+	return tuple.elements.SerializeSql(out)
+}
+
+func Tuple(exprs ...Expression) Expression {
+	clauses := make([]Clause, 0, len(exprs))
+	for _, expr := range exprs {
+		clauses = append(clauses, expr)
+	}
+	return &tupleExpression{
+		elements: listClause{
+			clauses:            clauses,
+			includeParentheses: true,
+		},
+	}
+}
+
+// Representation of a tuple enclosed, comma separated list of clauses
+type listClause struct {
+	clauses            []Clause
+	includeParentheses bool
+}
+
+func (list *listClause) SerializeSql(out *bytes.Buffer) error {
+	if list.includeParentheses {
+		_ = out.WriteByte('(')
+	}
+
+	if err := serializeClauses(list.clauses, []byte(","), out); err != nil {
+		return err
+	}
+
+	if list.includeParentheses {
+		_ = out.WriteByte(')')
+	}
+	return nil
+}
+
+// A not expression which negates a expression value
+type negateExpression struct {
+	isExpression
+	isBoolExpression
+
+	nested BoolExpression
+}
+
+func (c *negateExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	_, _ = out.WriteString("NOT (")
+
+	if c.nested == nil {
+		return errors.Newf("nil nested.  Generated sql: %s", out.String())
+	}
+	if err = c.nested.SerializeSql(out); err != nil {
+		return
+	}
+
+	_ = out.WriteByte(')')
+	return nil
+}
+
+// Returns a representation of "not expr"
+func Not(expr BoolExpression) BoolExpression {
+	return &negateExpression{
+		nested: expr,
+	}
+}
+
+// Representation of binary operations (e.g. comparisons, arithmetic)
+type binaryExpression struct {
+	isExpression
+	lhs, rhs Expression
+	operator []byte
+}
+
+func (c *binaryExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	if c.lhs == nil {
+		return errors.Newf("nil lhs.  Generated sql: %s", out.String())
+	}
+	if err = c.lhs.SerializeSql(out); err != nil {
+		return
+	}
+
+	_, _ = out.Write(c.operator)
+
+	if c.rhs == nil {
+		return errors.Newf("nil rhs.  Generated sql: %s", out.String())
+	}
+	if err = c.rhs.SerializeSql(out); err != nil {
+		return
+	}
+
+	return nil
+}
+
+// A binary expression that evaluates to a boolean value.
+type boolExpression struct {
+	isBoolExpression
+	binaryExpression
+}
+
+func newBoolExpression(lhs, rhs Expression, operator []byte) *boolExpression {
+	// go does not allow {} syntax for initializing promoted fields ...
+	expr := new(boolExpression)
+	expr.lhs = lhs
+	expr.rhs = rhs
+	expr.operator = operator
+	return expr
+}
+
+type funcExpression struct {
+	isExpression
+	funcName string
+	args     *listClause
+}
+
+func (c *funcExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	if !validIdentifierName(c.funcName) {
+		return errors.Newf(
+			"Invalid function name: %s.  Generated sql: %s",
+			c.funcName,
+			out.String())
+	}
+	_, _ = out.WriteString(c.funcName)
+	if c.args == nil {
+		_, _ = out.WriteString("()")
+	} else {
+		return c.args.SerializeSql(out)
+	}
+	return nil
+}
+
+// Returns a representation of sql function call "func_call(c[0], ..., c[n-1])
+func SqlFunc(funcName string, expressions ...Expression) Expression {
+	f := &funcExpression{
+		funcName: funcName,
+	}
+	if len(expressions) > 0 {
+		args := make([]Clause, len(expressions), len(expressions))
+		for i, expr := range expressions {
+			args[i] = expr
+		}
+
+		f.args = &listClause{
+			clauses:            args,
+			includeParentheses: true,
+		}
+	}
+	return f
+}
+
+type intervalExpression struct {
+	isExpression
+	duration time.Duration
+	negative bool
+}
+
+var intervalSep = ":"
+
+func (c *intervalExpression) SerializeSql(out *bytes.Buffer) (err error) {
+	hours := c.duration / time.Hour
+	minutes := (c.duration % time.Hour) / time.Minute
+	sec := (c.duration % time.Minute) / time.Second
+	msec := (c.duration % time.Second) / time.Microsecond
+	_, _ = out.WriteString("INTERVAL '")
+	if c.negative {
+		_, _ = out.WriteString("-")
+	}
+	_, _ = out.WriteString(strconv.FormatInt(int64(hours), 10))
+	_, _ = out.WriteString(intervalSep)
+	_, _ = out.WriteString(strconv.FormatInt(int64(minutes), 10))
+	_, _ = out.WriteString(intervalSep)
+	_, _ = out.WriteString(strconv.FormatInt(int64(sec), 10))
+	_, _ = out.WriteString(intervalSep)
+	_, _ = out.WriteString(strconv.FormatInt(int64(msec), 10))
+	_, _ = out.WriteString("' HOUR_MICROSECOND")
+	return nil
+}
+
+// Interval returns a representation of duration
+// in a form "INTERVAL `hour:min:sec:microsec` HOUR_MICROSECOND"
+func Interval(duration time.Duration) Expression {
+	negative := false
+	if duration < 0 {
+		negative = true
+		duration = -duration
+	}
+	return &intervalExpression{
+		duration: duration,
+		negative: negative,
+	}
+}
+
+var likeEscaper = strings.NewReplacer("_", "\\_", "%", "\\%")
+
+func EscapeForLike(s string) string {
+	return likeEscaper.Replace(s)
+}
+
+// Returns an escaped literal string
+func Literal(v interface{}) Expression {
+	value, err := sqltypes.BuildValue(v)
+	if err != nil {
+		panic(errors.Wrap(err, "Invalid literal value"))
+	}
+	return &literalExpression{value: value}
+}
+
+// Returns a representation of "c[0] AND ... AND c[n-1]" for c in clauses
+func And(expressions ...BoolExpression) BoolExpression {
+	return &conjunctExpression{
+		expressions: expressions,
+		conjunction: []byte(" AND "),
+	}
+}
+
+// Returns a representation of "c[0] OR ... OR c[n-1]" for c in clauses
+func Or(expressions ...BoolExpression) BoolExpression {
+	return &conjunctExpression{
+		expressions: expressions,
+		conjunction: []byte(" OR "),
+	}
+}
+
+func Like(lhs, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte(" LIKE "))
+}
+
+func LikeL(lhs Expression, val string) BoolExpression {
+	return Like(lhs, Literal(val))
+}
+
+func Regexp(lhs, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte(" REGEXP "))
+}
+
+func RegexpL(lhs Expression, val string) BoolExpression {
+	return Regexp(lhs, Literal(val))
+}
+
+// Returns a representation of "c[0] + ... + c[n-1]" for c in clauses
+func Add(expressions ...Expression) Expression {
+	return &arithmeticExpression{
+		expressions: expressions,
+		operator:    []byte(" + "),
+	}
+}
+
+// Returns a representation of "c[0] - ... - c[n-1]" for c in clauses
+func Sub(expressions ...Expression) Expression {
+	return &arithmeticExpression{
+		expressions: expressions,
+		operator:    []byte(" - "),
+	}
+}
+
+// Returns a representation of "c[0] * ... * c[n-1]" for c in clauses
+func Mul(expressions ...Expression) Expression {
+	return &arithmeticExpression{
+		expressions: expressions,
+		operator:    []byte(" * "),
+	}
+}
+
+// Returns a representation of "c[0] / ... / c[n-1]" for c in clauses
+func Div(expressions ...Expression) Expression {
+	return &arithmeticExpression{
+		expressions: expressions,
+		operator:    []byte(" / "),
+	}
+}
+
+// Returns a representation of "a=b"
+func Eq(lhs, rhs Expression) BoolExpression {
+	lit, ok := rhs.(*literalExpression)
+	if ok && sqltypes.Value(lit.value).IsNull() {
+		return newBoolExpression(lhs, rhs, []byte(" IS "))
+	}
+	return newBoolExpression(lhs, rhs, []byte("="))
+}
+
+// Returns a representation of "a=b", where b is a literal
+func EqL(lhs Expression, val interface{}) BoolExpression {
+	return Eq(lhs, Literal(val))
+}
+
+// Returns a representation of "a!=b"
+func Neq(lhs, rhs Expression) BoolExpression {
+	lit, ok := rhs.(*literalExpression)
+	if ok && sqltypes.Value(lit.value).IsNull() {
+		return newBoolExpression(lhs, rhs, []byte(" IS NOT "))
+	}
+	return newBoolExpression(lhs, rhs, []byte("!="))
+}
+
+// Returns a representation of "a!=b", where b is a literal
+func NeqL(lhs Expression, val interface{}) BoolExpression {
+	return Neq(lhs, Literal(val))
+}
+
+// Returns a representation of "a<b"
+func Lt(lhs Expression, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte("<"))
+}
+
+// Returns a representation of "a<b", where b is a literal
+func LtL(lhs Expression, val interface{}) BoolExpression {
+	return Lt(lhs, Literal(val))
+}
+
+// Returns a representation of "a<=b"
+func Lte(lhs, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte("<="))
+}
+
+// Returns a representation of "a<=b", where b is a literal
+func LteL(lhs Expression, val interface{}) BoolExpression {
+	return Lte(lhs, Literal(val))
+}
+
+// Returns a representation of "a>b"
+func Gt(lhs, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte(">"))
+}
+
+// Returns a representation of "a>b", where b is a literal
+func GtL(lhs Expression, val interface{}) BoolExpression {
+	return Gt(lhs, Literal(val))
+}
+
+// Returns a representation of "a>=b"
+func Gte(lhs, rhs Expression) BoolExpression {
+	return newBoolExpression(lhs, rhs, []byte(">="))
+}
+
+// Returns a representation of "a>=b", where b is a literal
+func GteL(lhs Expression, val interface{}) BoolExpression {
+	return Gte(lhs, Literal(val))
+}
+
+func BitOr(lhs, rhs Expression) Expression {
+	return &binaryExpression{
+		lhs:      lhs,
+		rhs:      rhs,
+		operator: []byte(" | "),
+	}
+}
+
+func BitAnd(lhs, rhs Expression) Expression {
+	return &binaryExpression{
+		lhs:      lhs,
+		rhs:      rhs,
+		operator: []byte(" & "),
+	}
+}
+
+func BitXor(lhs, rhs Expression) Expression {
+	return &binaryExpression{
+		lhs:      lhs,
+		rhs:      rhs,
+		operator: []byte(" ^ "),
+	}
+}
+
+func Plus(lhs, rhs Expression) Expression {
+	return &binaryExpression{
+		lhs:      lhs,
+		rhs:      rhs,
+		operator: []byte(" + "),
+	}
+}
+
+func Minus(lhs, rhs Expression) Expression {
+	return &binaryExpression{
+		lhs:      lhs,
+		rhs:      rhs,
+		operator: []byte(" - "),
+	}
+}
+
+// in expression representation
+type inExpression struct {
+	isExpression
+	isBoolExpression
+
+	lhs Expression
+	rhs *listClause
+
+	err error
+}
+
+func (c *inExpression) SerializeSql(out *bytes.Buffer) error {
+	if c.err != nil {
+		return errors.Wrap(c.err, "Invalid IN expression")
+	}
+
+	if c.lhs == nil {
+		return errors.Newf(
+			"lhs of in expression is nil.  Generated sql: %s",
+			out.String())
+	}
+
+	// We'll serialize the lhs even if we don't need it to ensure no error
+	buf := &bytes.Buffer{}
+
+	err := c.lhs.SerializeSql(buf)
+	if err != nil {
+		return err
+	}
+
+	if c.rhs == nil {
+		_, _ = out.WriteString("FALSE")
+		return nil
+	}
+
+	_, _ = out.WriteString(buf.String())
+	_, _ = out.WriteString(" IN ")
+
+	err = c.rhs.SerializeSql(out)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Returns a representation of "a IN (b[0], ..., b[n-1])", where b is a list
+// of literals valList must be a slice type
+func In(lhs Expression, valList interface{}) BoolExpression {
+	var clauses []Clause
+	switch val := valList.(type) {
+	// This atrocious body of copy-paste code is due to the fact that if you
+	// try to merge the cases, you can't treat val as a list
+	case []int:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []int32:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []int64:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []uint:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []uint32:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []uint64:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []float64:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []string:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case [][]byte:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []time.Time:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []sqltypes.Numeric:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []sqltypes.Fractional:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []sqltypes.String:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	case []sqltypes.Value:
+		clauses = make([]Clause, 0, len(val))
+		for _, v := range val {
+			clauses = append(clauses, Literal(v))
+		}
+	default:
+		return &inExpression{
+			err: errors.Newf(
+				"Unknown value list type in IN clause: %s",
+				reflect.TypeOf(valList)),
+		}
+	}
+
+	expr := &inExpression{lhs: lhs}
+	if len(clauses) > 0 {
+		expr.rhs = &listClause{clauses: clauses, includeParentheses: true}
+	}
+	return expr
+}
+
+type ifExpression struct {
+	isExpression
+	conditional     BoolExpression
+	trueExpression  Expression
+	falseExpression Expression
+}
+
+func (exp *ifExpression) SerializeSql(out *bytes.Buffer) error {
+	_, _ = out.WriteString("IF(")
+	_ = exp.conditional.SerializeSql(out)
+	_, _ = out.WriteString(",")
+	_ = exp.trueExpression.SerializeSql(out)
+	_, _ = out.WriteString(",")
+	_ = exp.falseExpression.SerializeSql(out)
+	_, _ = out.WriteString(")")
+	return nil
+}
+
+// Returns a representation of an if-expression, of the form:
+//   IF (BOOLEAN TEST, VALUE-IF-TRUE, VALUE-IF-FALSE)
+func If(conditional BoolExpression,
+	trueExpression Expression,
+	falseExpression Expression) Expression {
+	return &ifExpression{
+		conditional:     conditional,
+		trueExpression:  trueExpression,
+		falseExpression: falseExpression,
+	}
+}
+
+type columnValueExpression struct {
+	isExpression
+	column NonAliasColumn
+}
+
+func ColumnValue(col NonAliasColumn) Expression {
+	return &columnValueExpression{
+		column: col,
+	}
+}
+
+func (cv *columnValueExpression) SerializeSql(out *bytes.Buffer) error {
+	_, _ = out.WriteString("VALUES(")
+	_ = cv.column.SerializeSqlForColumnList(out)
+	_ = out.WriteByte(')')
+	return nil
+}

sqlbuilder/expression_test.go

@@ -0,0 +1,547 @@
+package sqlbuilder
+
+import (
+	"bytes"
+	"time"
+
+	gc "gopkg.in/check.v1"
+)
+
+type ExprSuite struct {
+}
+
+var _ = gc.Suite(&ExprSuite{})
+
+func (s *ExprSuite) TestConjunctExprEmptyList(c *gc.C) {
+	expr := And()
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestConjunctExprNilInList(c *gc.C) {
+	expr := And(nil, EqL(table1Col1, 1))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestConjunctExprSingleElement(c *gc.C) {
+	expr := And(EqL(table1Col1, 1))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`=1")
+}
+
+func (s *ExprSuite) TestTupleExpr(c *gc.C) {
+
+	expr := Tuple()
+	buf := &bytes.Buffer{}
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+
+	expr = Tuple(table1Col1, Literal(1), Literal("five"))
+	err = expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"(`table1`.`col1`,1,'five')")
+
+}
+
+func (s *ExprSuite) TestLikeExpr(c *gc.C) {
+	expr := LikeL(table1Col1, EscapeForLike("%my_prefix")+"%")
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`table1`.`col1` LIKE '\\%my\\_prefix%'")
+
+}
+
+func (s *ExprSuite) TestRegexExpr(c *gc.C) {
+	expr := RegexpL(table1Col1, "[[:<:]]log|[[.low-line.]]log")
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`table1`.`col1` REGEXP '[[:<:]]log|[[.low-line.]]log'")
+
+}
+
+func (s *ExprSuite) TestAndExpr(c *gc.C) {
+	expr := And(EqL(table1Col1, 1), EqL(table1Col2, 2), EqL(table1Col3, 3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"(`table1`.`col1`=1 AND `table1`.`col2`=2 AND `table1`.`col3`=3)")
+}
+
+func (s *ExprSuite) TestOrExpr(c *gc.C) {
+	expr := Or(EqL(table1Col1, 1), EqL(table1Col2, 2), EqL(table1Col3, 3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"(`table1`.`col1`=1 OR `table1`.`col2`=2 OR `table1`.`col3`=3)")
+}
+
+func (s *ExprSuite) TestAddExpr(c *gc.C) {
+	expr := Add(Literal(1), Literal(2), Literal(3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "(1 + 2 + 3)")
+}
+
+func (s *ExprSuite) TestSubExpr(c *gc.C) {
+	expr := Sub(Literal(1), Literal(2), Literal(3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "(1 - 2 - 3)")
+}
+
+func (s *ExprSuite) TestMulExpr(c *gc.C) {
+	expr := Mul(Literal(1), Literal(2), Literal(3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "(1 * 2 * 3)")
+}
+
+func (s *ExprSuite) TestDivExpr(c *gc.C) {
+	expr := Div(Literal(1), Literal(2), Literal(3))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "(1 / 2 / 3)")
+}
+
+func (s *ExprSuite) TestBinaryExprNilLHS(c *gc.C) {
+	expr := Gt(nil, table1Col1)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestNegateExpr(c *gc.C) {
+	expr := Not(EqL(table1Col1, 123))
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "NOT (`table1`.`col1`=123)")
+}
+
+func (s *ExprSuite) TestBinaryExprNilRHS(c *gc.C) {
+	expr := Lt(table1Col1, nil)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestEqExpr(c *gc.C) {
+	expr := EqL(table1Col1, 321)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`=321")
+}
+
+func (s *ExprSuite) TestEqExprNilLHS(c *gc.C) {
+	expr := EqL(table1Col1, nil)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1` IS null")
+}
+
+func (s *ExprSuite) TestNeqExpr(c *gc.C) {
+	expr := NeqL(table1Col1, 123)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`!=123")
+}
+
+func (s *ExprSuite) TestNeqExprNilLHS(c *gc.C) {
+	expr := NeqL(table1Col1, nil)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1` IS NOT null")
+}
+
+func (s *ExprSuite) TestLtExpr(c *gc.C) {
+	expr := LtL(table1Col1, -1.5)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`<-1.5")
+}
+
+func (s *ExprSuite) TestLteExpr(c *gc.C) {
+	expr := LteL(table1Col1, "foo\"';drop user table;")
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`table1`.`col1`<='foo\\\"\\';drop user table;'")
+}
+
+func (s *ExprSuite) TestGtExpr(c *gc.C) {
+	expr := GtL(table1Col1, 1.1)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`>1.1")
+}
+
+func (s *ExprSuite) TestGteExpr(c *gc.C) {
+	expr := GteL(table1Col1, 1)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`>=1")
+}
+
+func (s *ExprSuite) TestInExpr(c *gc.C) {
+	values := []int32{1, 2, 3}
+	expr := In(table1Col1, values)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1` IN (1,2,3)")
+}
+
+func (s *ExprSuite) TestInExprEmptyList(c *gc.C) {
+	values := []int32{}
+	expr := In(table1Col1, values)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "FALSE")
+}
+
+func (s *ExprSuite) TestSqlFuncExprNilInArgList(c *gc.C) {
+	expr := SqlFunc("rand", nil)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestSqlFuncExprEmptyArgList(c *gc.C) {
+	expr := SqlFunc("rand")
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "rand()")
+}
+
+func (s *ExprSuite) TestSqlFuncExprNonEmptyArgList(c *gc.C) {
+	expr := SqlFunc("add", table1Col1, table1Col2)
+
+	buf := &bytes.Buffer{}
+
+	err := expr.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "add(`table1`.`col1`,`table1`.`col2`)")
+}
+
+func (s *ExprSuite) TestOrderByClauseNilExpr(c *gc.C) {
+	clause := Asc(nil)
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *ExprSuite) TestAsc(c *gc.C) {
+	clause := Asc(table1Col1)
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1` ASC")
+}
+
+func (s *ExprSuite) TestDesc(c *gc.C) {
+	clause := Desc(table1Col1)
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1` DESC")
+}
+
+func (s *ExprSuite) TestIf(c *gc.C) {
+	test := GtL(table1Col1, 1.1)
+	clause := If(test, table1Col1, table1Col2)
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"IF(`table1`.`col1`>1.1,`table1`.`col1`,`table1`.`col2`)")
+}
+
+func (s *ExprSuite) TestColumnValue(c *gc.C) {
+	clause := ColumnValue(table1Col1)
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "VALUES(`table1`.`col1`)")
+}
+
+func (s *ExprSuite) TestBitwiseOr(c *gc.C) {
+	clause := BitOr(Literal(1), Literal(2))
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "1 | 2")
+}
+
+func (s *ExprSuite) TestBitwiseAnd(c *gc.C) {
+	clause := BitAnd(Literal(1), Literal(2))
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "1 & 2")
+}
+
+func (s *ExprSuite) TestBitwiseXor(c *gc.C) {
+	clause := BitXor(Literal(1), Literal(2))
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "1 ^ 2")
+}
+
+func (s *ExprSuite) TestPlus(c *gc.C) {
+	clause := Plus(Literal(1), Literal(2))
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "1 + 2")
+}
+
+func (s *ExprSuite) TestMinus(c *gc.C) {
+	clause := Minus(Literal(1), Literal(2))
+
+	buf := &bytes.Buffer{}
+
+	err := clause.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "1 - 2")
+}
+
+func (s *ExprSuite) TestInterval(c *gc.C) {
+	testTable := []struct {
+		interval    time.Duration
+		expected    string
+		expectedErr error
+	}{
+		{
+			interval: 50 * time.Microsecond,
+			expected: "INTERVAL '0:0:0:50' HOUR_MICROSECOND",
+		},
+		{
+			interval: -50 * time.Microsecond,
+			expected: "INTERVAL '-0:0:0:50' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50*time.Microsecond + 50*time.Second,
+			expected: "INTERVAL '0:0:50:50' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50*time.Microsecond +
+				50*time.Second +
+				50*time.Minute,
+			expected: "INTERVAL '0:50:50:50' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50*time.Microsecond +
+				50*time.Second +
+				50*time.Minute +
+				50*time.Hour,
+			expected: "INTERVAL '50:50:50:50' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50 * time.Hour,
+			expected: "INTERVAL '50:0:0:0' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50*time.Hour + 50*time.Minute,
+			expected: "INTERVAL '50:50:0:0' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50*time.Hour + 50*time.Minute + 50*time.Second,
+			expected: "INTERVAL '50:50:50:0' HOUR_MICROSECOND",
+		},
+		{
+			interval: 0,
+			expected: "INTERVAL '0:0:0:0' HOUR_MICROSECOND",
+		},
+		{
+			interval: 50 * time.Nanosecond,
+			expected: "INTERVAL '0:0:0:0' HOUR_MICROSECOND",
+		},
+	}
+	buf := &bytes.Buffer{}
+
+	for i, tt := range testTable {
+		buf.Reset()
+		err := Interval(tt.interval).SerializeSql(buf)
+		c.Assert(err, gc.Equals, tt.expectedErr,
+			gc.Commentf("experiment #%d", i))
+		if err == nil {
+			c.Assert(buf.String(), gc.Equals, tt.expected,
+				gc.Commentf("experiment #%d", i))
+		}
+	}
+}

sqlbuilder/statement_test.go

@@ -0,0 +1,660 @@
+package sqlbuilder
+
+import (
+	"time"
+
+	gc "gopkg.in/check.v1"
+
+	"github.com/dropbox/godropbox/errors"
+)
+
+type StmtSuite struct {
+}
+
+var _ = gc.Suite(&StmtSuite{})
+
+// NOTE: tables / columns are defined in test_utils.go
+
+//
+// SELECT statement tests
+//
+
+func (s *StmtSuite) TestSelectEmptyProjection(c *gc.C) {
+	_, err := table1.Select().String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestSelectSingleColumn(c *gc.C) {
+	sql, err := table1.Select(table1Col1).String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1`")
+}
+
+func (s *StmtSuite) TestSelectMultiColumns(c *gc.C) {
+	sql, err := table1.Select(table1Col1, table1Col2).String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2` FROM `db`.`table1`")
+}
+
+func (s *StmtSuite) TestSelectWhere(c *gc.C) {
+	q := table1.Select(table1Col1).Where(GtL(table1Col1, 123))
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`>123")
+}
+
+func (s *StmtSuite) TestSelectWhereDate(c *gc.C) {
+	date := time.Date(1999, 1, 2, 3, 4, 5, 0, time.UTC)
+
+	q := table1.Select(table1Col1).Where(GtL(table1Col4, date))
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` "+
+			"WHERE `table1`.`col4`>'1999-01-02 03:04:05.000000'")
+}
+
+func (s *StmtSuite) TestSelectAndWhere(c *gc.C) {
+	q := table1.Select(table1Col1).AndWhere(GtL(table1Col1, 123))
+	q.AndWhere(LtL(table1Col1, 321))
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` WHERE (`table1`.`col1`>123 AND `table1`.`col1`<321)")
+}
+
+func (s *StmtSuite) TestSelectCopy(c *gc.C) {
+	q := table1.Select(table1Col1).Where(GtL(table1Col1, 123))
+	qq := q.Copy().Where(GtL(table1Col1, 321)).OrderBy(table1Col1)
+
+	// Initial query unchanged
+	sql, err := q.String("db")
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`>123")
+	// New query changed
+	sql, err = qq.String("db")
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`>321 ORDER BY `table1`.`col1`")
+
+}
+
+func (s *StmtSuite) TestSelectLimitWithoutOffset(c *gc.C) {
+	q := table1.Select(table1Col1).Limit(5)
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` LIMIT 5")
+}
+
+func (s *StmtSuite) TestSelectLimitWithOffset(c *gc.C) {
+	q := table1.Select(table1Col1).Limit(5).Offset(2)
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` LIMIT 2, 5")
+}
+
+func (s *StmtSuite) TestSelectGroupBy(c *gc.C) {
+	q := table1.Select(
+		table1Col1,
+		table1Col2,
+		Alias("total", SqlFunc("sum", table1Col3)))
+	q.GroupBy(table1Col1, table1Col2)
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2`,"+
+			"(sum(`table1`.`col3`)) AS `total` "+
+			"FROM `db`.`table1` GROUP BY `table1`.`col1`,`table1`.`col2`")
+}
+
+func (s *StmtSuite) TestSelectSingleOrderBy(c *gc.C) {
+	q := table1.Select(table1Col1, table1Col2).OrderBy(table1Col2)
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2` "+
+			"FROM `db`.`table1` ORDER BY `table1`.`col2`")
+}
+
+func (s *StmtSuite) TestSelectOrderByAsc(c *gc.C) {
+	q := table1.Select(table1Col1, table1Col2).OrderBy(Asc(table1Col2))
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2` "+
+			"FROM `db`.`table1` ORDER BY `table1`.`col2` ASC")
+}
+
+func (s *StmtSuite) TestSelectOrderByDesc(c *gc.C) {
+	q := table1.Select(table1Col1, table1Col2).OrderBy(Desc(table1Col2))
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2` "+
+			"FROM `db`.`table1` ORDER BY `table1`.`col2` DESC")
+}
+
+func (s *StmtSuite) TestSelectMultiOrderBy(c *gc.C) {
+	q := table1.Select(table1Col1, table1Col2)
+	q.OrderBy(table1Col2, table1Col1)
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table1`.`col2` "+
+			"FROM `db`.`table1` "+
+			"ORDER BY `table1`.`col2`,`table1`.`col1`")
+}
+
+func (s *StmtSuite) TestSelectOnJoin(c *gc.C) {
+
+	join := table1.InnerJoinOn(table2, Eq(table1Col3, table2Col3))
+	sql, err := join.Select(table1Col1, table2Col4).String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1`,`table2`.`col4` "+
+			"FROM `db`.`table1` JOIN `db`.`table2` "+
+			"ON `table1`.`col3`=`table2`.`col3`")
+}
+
+func (s *StmtSuite) TestSelectWithSharedLock(c *gc.C) {
+
+	q := table1.Select(table1Col1).Where(GtL(table1Col1, 123)).WithSharedLock()
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT `table1`.`col1` FROM `db`.`table1` "+
+			"WHERE `table1`.`col1`>123 LOCK IN SHARE MODE")
+}
+
+func (s *StmtSuite) TestSelectDistinct(c *gc.C) {
+	q := table1.Select(table1Col1).Distinct()
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"SELECT DISTINCT `table1`.`col1` FROM `db`.`table1`")
+}
+
+//
+// INSERT statement tests
+//
+
+func (s *StmtSuite) TestInsertNoColumn(c *gc.C) {
+	_, err := table1.Insert().Add().String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestInsertNoRow(c *gc.C) {
+	_, err := table1.Insert(table1Col1).String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestInsertColumnLengthMismatch(c *gc.C) {
+	_, err := table1.Insert(table1Col1, table1Col2).Add(nil).String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestInsertNilValue(c *gc.C) {
+	_, err := table1.Insert(table1Col1).Add(nil).String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestInsertNilColumn(c *gc.C) {
+	_, err := table1.Insert(nil).Add(Literal(1)).String("db")
+
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestInsertSingleValue(c *gc.C) {
+	sql, err := table1.Insert(table1Col1).Add(Literal(1)).String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` (`table1`.`col1`) VALUES (1)")
+}
+
+func (s *StmtSuite) TestInsertDate(c *gc.C) {
+	date := time.Date(1999, 1, 2, 3, 4, 5, 0, time.UTC)
+
+	sql, err := table1.Insert(table1Col4).Add(Literal(date)).String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` (`table1`.`col4`) "+
+			"VALUES ('1999-01-02 03:04:05.000000')")
+}
+
+func (s *StmtSuite) TestInsertIgnore(c *gc.C) {
+	stmt := table1.Insert(table1Col1).Add(Literal(1)).IgnoreDuplicates(true)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT IGNORE INTO `db`.`table1` (`table1`.`col1`) VALUES (1)")
+}
+
+func (s *StmtSuite) TestInsertMultipleValues(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2, table1Col3)
+	stmt.Add(Literal(1), Literal(2), Literal(3))
+
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` "+
+			"(`table1`.`col1`,`table1`.`col2`,`table1`.`col3`) "+
+			"VALUES (1,2,3)")
+}
+
+func (s *StmtSuite) TestInsertMultipleRows(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2)
+	stmt.Add(Literal(1), Literal(2))
+	stmt.Add(Literal(11), Literal(22))
+	stmt.Add(Literal(111), Literal(222))
+
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` "+
+			"(`table1`.`col1`,`table1`.`col2`) "+
+			"VALUES (1,2), (11,22), (111,222)")
+}
+
+func (s *StmtSuite) TestOnDuplicateKeyUpdateNilCol(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2)
+	stmt.Add(Literal(1), Literal(2))
+	stmt.AddOnDuplicateKeyUpdate(nil, Literal(3))
+
+	_, err := stmt.String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestOnDuplicateKeyUpdateNilExpr(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2)
+	stmt.Add(Literal(1), Literal(2))
+	stmt.AddOnDuplicateKeyUpdate(table1Col1, nil)
+
+	_, err := stmt.String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestOnDuplicateKeyUpdateSingle(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2)
+	stmt.Add(Literal(1), Literal(2))
+	stmt.AddOnDuplicateKeyUpdate(table1Col3, Literal(3))
+
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` "+
+			"(`table1`.`col1`,`table1`.`col2`) "+
+			"VALUES (1,2) "+
+			"ON DUPLICATE KEY UPDATE `table1`.`col3`=3")
+}
+
+func (s *StmtSuite) TestOnDuplicateKeyUpdateMulti(c *gc.C) {
+	stmt := table1.Insert(table1Col1, table1Col2)
+	stmt.Add(Literal(1), Literal(2))
+	stmt.AddOnDuplicateKeyUpdate(table1Col3, Literal(3))
+	stmt.AddOnDuplicateKeyUpdate(table1Col2, Literal(4))
+
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"INSERT INTO `db`.`table1` "+
+			"(`table1`.`col1`,`table1`.`col2`) "+
+			"VALUES (1,2) "+
+			"ON DUPLICATE KEY UPDATE `table1`.`col3`=3, `table1`.`col2`=4")
+}
+
+//
+// UPDATE statement tests =====================================================
+//
+
+func (s *StmtSuite) TestUpdateNilColumn(c *gc.C) {
+	stmt := table1.Update().Set(nil, Literal(1))
+	_, err := stmt.String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestUpdateNilExpr(c *gc.C) {
+	stmt := table1.Update().Set(table1Col1, nil)
+	_, err := stmt.String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestUpdateUnconditionally(c *gc.C) {
+	stmt := table1.Update().Set(table1Col1, Literal(1))
+	_, err := stmt.String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestUpdateSingleValue(c *gc.C) {
+	stmt := table1.Update().Set(table1Col1, Literal(1))
+	stmt.Where(EqL(table1Col2, 2))
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"UPDATE `db`.`table1` SET `table1`.`col1`=1 WHERE `table1`.`col2`=2")
+}
+
+func (s *StmtSuite) TestUpdateUsingDeferredLookupColumns(c *gc.C) {
+	stmt := table1.Update().Set(table1.C("col1"), Literal(1))
+	stmt.Where(EqL(table1Col2, 2))
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"UPDATE `db`.`table1` SET `table1`.`col1`=1 WHERE `table1`.`col2`=2")
+}
+
+func (s *StmtSuite) TestUpdateMultiValues(c *gc.C) {
+	stmt := table1.Update()
+	stmt.Set(table1Col1, Literal(1))
+	stmt.Set(table1Col2, Literal(2))
+	stmt.Where(EqL(table1Col2, 3))
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"UPDATE `db`.`table1` "+
+			"SET `table1`.`col1`=1, `table1`.`col2`=2 "+
+			"WHERE `table1`.`col2`=3")
+}
+
+func (s *StmtSuite) TestUpdateWithOrderBy(c *gc.C) {
+	stmt := table1.Update().Set(table1Col1, Literal(1))
+	stmt.Where(EqL(table1Col2, 2))
+	stmt.OrderBy(table1Col2)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"UPDATE `db`.`table1` "+
+			"SET `table1`.`col1`=1 "+
+			"WHERE `table1`.`col2`=2 "+
+			"ORDER BY `table1`.`col2`")
+}
+
+func (s *StmtSuite) TestUpdateWithLimit(c *gc.C) {
+	stmt := table1.Update().Set(table1Col1, Literal(1))
+	stmt.Where(EqL(table1Col2, 2))
+	stmt.Limit(5)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"UPDATE `db`.`table1` "+
+			"SET `table1`.`col1`=1 "+
+			"WHERE `table1`.`col2`=2 "+
+			"LIMIT 5")
+}
+
+//
+// DELETE statement tests =====================================================
+//
+
+func (s *StmtSuite) TestDeleteUnconditionally(c *gc.C) {
+	_, err := table1.Delete().String("db")
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *StmtSuite) TestDeleteWithWhere(c *gc.C) {
+	sql, err := table1.Delete().Where(EqL(table1Col1, 1)).String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"DELETE FROM `db`.`table1` WHERE `table1`.`col1`=1")
+}
+
+func (s *StmtSuite) TestDeleteWithOrderBy(c *gc.C) {
+	stmt := table1.Delete().Where(EqL(table1Col1, 1)).OrderBy(table1Col1)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"DELETE FROM `db`.`table1` "+
+			"WHERE `table1`.`col1`=1 "+
+			"ORDER BY `table1`.`col1`")
+}
+
+func (s *StmtSuite) TestDeleteWithLimit(c *gc.C) {
+	stmt := table1.Delete().Where(EqL(table1Col1, 1)).Limit(5)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(
+		sql,
+		gc.Equals,
+		"DELETE FROM `db`.`table1` WHERE `table1`.`col1`=1 LIMIT 5")
+}
+
+//
+// LOCK/UNLOCK statement tests ================================================
+//
+
+func (s *StmtSuite) TestLockStatement(c *gc.C) {
+	stmt := NewLockStatement().AddReadLock(table1).AddWriteLock(table2)
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(sql, gc.Equals, "LOCK TABLES `db`.`table1` READ, `db`.`table2` WRITE")
+}
+
+func (s *StmtSuite) TestUnlockStatement(c *gc.C) {
+	stmt := NewUnlockStatement()
+	sql, err := stmt.String("db")
+	c.Assert(err, gc.IsNil)
+	c.Assert(sql, gc.Equals, "UNLOCK TABLES")
+
+}
+
+func (s *StmtSuite) TestUnionSelectStatement(c *gc.C) {
+	select_queries := make([]SelectStatement, 0, 3)
+
+	select_queries = append(select_queries,
+		table1.Select(table1Col1).Where(GtL(table1Col1, 123)),
+		table1.Select(table1Col1).Where(GtL(table1Col1, 456)),
+		table1.Select(table1Col1).Where(LtL(table1Col1, 23)),
+	)
+
+	q := Union(select_queries...)
+
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"(SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`>123) "+
+			"UNION (SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`>456) "+
+			"UNION (SELECT `table1`.`col1` FROM `db`.`table1` WHERE `table1`.`col1`<23)")
+}
+
+func (s *StmtSuite) TestUnionLimitWithoutOrderBy(c *gc.C) {
+	select_queries := make([]SelectStatement, 0, 3)
+
+	select_queries = append(select_queries,
+		table1.Select(table1Col1).Where(GtL(table1Col1, 123)).OrderBy(table1Col2),
+		table1.Select(table1Col1).Where(GtL(table1Col1, 456)),
+		table1.Select(table1Col1).Where(LtL(table1Col1, 23)),
+	)
+
+	q := Union(select_queries...)
+
+	_, err := q.String("db")
+
+	c.Assert(err, gc.NotNil)
+	c.Assert(
+		errors.GetMessage(err),
+		gc.Equals,
+		"All inner selects in Union statement must have LIMIT if they have ORDER BY")
+}
+
+func (s *StmtSuite) TestUnionSelectWithMismatchedColumns(c *gc.C) {
+	select_queries := make([]SelectStatement, 0, 3)
+
+	select_queries = append(select_queries,
+
+		table1.Select(
+			table1Col1,
+			table1Col2,
+			table1Col3,
+			table1Col4).AndWhere(GtL(table1Col1, 123)).AndWhere(LtL(table1Col1, 321)),
+		table1.Select(table1Col1).Where(And(GtL(table1Col1, 123), LtL(table1Col1, 321))),
+		table1.Select(table1Col1).Where(LtL(table1Col1, 23)).OrderBy(table1Col4).Limit(20),
+	)
+
+	q := Union(select_queries...)
+	q = q.Where(And(LtL(table1Col1, 1000), GtL(table1Col1, 15)))
+	q = q.OrderBy(Desc(table1Col4), Asc(table1Col3))
+	q = q.Limit(5)
+
+	_, err := q.String("db")
+
+	c.Assert(err, gc.NotNil)
+	c.Assert(
+		errors.GetMessage(err),
+		gc.Equals,
+		"All inner selects in Union statement must select the "+
+			"same number of columns.  For sanity, you probably "+
+			"want to select the same table columns in the same "+
+			"order.  If you are selecting on multiple tables, "+
+			"use Null to pad to the right number of fields.")
+}
+
+func (s *StmtSuite) TestComplicatedUnionSelectWithWhereStatement(c *gc.C) {
+
+	// tests on outer statement: Group By, Order By, Limit
+	// on inner statement: AndWhere, Where (with And), Order By, Limit
+	select_queries := make([]SelectStatement, 0, 3)
+
+	// We're not trying to write a SQL parser, so we won't warn if you do something silly like
+	// try to apply a where clause on more columns than you've selected in your union select
+	select_queries = append(select_queries,
+		table1.Select(
+			table1Col1,
+		).AndWhere(GtL(table1Col1, 123)).AndWhere(LtL(table1Col1, 321)),
+		table1.Select(
+			table1Col1,
+		).Where(And(GtL(table1Col1, 456), LtL(table1Col1, 654))),
+		table1.Select(
+			table1Col1,
+		).Where(LtL(table1Col1, 23)).OrderBy(table1Col4).Limit(20),
+	)
+
+	q := Union(select_queries...)
+	q = q.Where(And(LtL(table1Col1, 1000), GtL(table1Col1, 15)))
+
+	q = q.OrderBy(Desc(table1Col4), Asc(table1Col3))
+	q = q.Limit(5)
+	q = q.GroupBy(table1Col4)
+
+	sql, err := q.String("db")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(
+		sql,
+		gc.Equals,
+		"(SELECT `table1`.`col1` FROM `db`.`table1` WHERE "+
+			"(`table1`.`col1`>123 AND `table1`.`col1`<321)) "+
+			"UNION (SELECT `table1`.`col1` FROM `db`.`table1` "+
+			"WHERE (`table1`.`col1`>456 AND `table1`.`col1`<654)) "+
+			"UNION (SELECT `table1`.`col1` FROM `db`.`table1` "+
+			"WHERE `table1`.`col1`<23 ORDER BY `table1`.`col4` LIMIT 20) "+
+			"WHERE (`table1`.`col1`<1000 AND `table1`.`col1`>15) "+
+			"GROUP BY `table1`.`col4` ORDER BY `table1`.`col4` DESC,`table1`.`col3` ASC "+
+			"LIMIT 5")
+
+}

sqlbuilder/table.go

@@ -0,0 +1,317 @@
+// Modeling of tables.  This is where query preparation starts
+
+package sqlbuilder
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/dropbox/godropbox/errors"
+)
+
+// The sql table read interface.  NOTE: NATURAL JOINs, and join "USING" clause
+// are not supported.
+type ReadableTable interface {
+	// Returns the list of columns that are in the current table expression.
+	Columns() []NonAliasColumn
+
+	// Generates the sql string for the current table expression.  Note: the
+	// generated string may not be a valid/executable sql statement.
+	// The database is the name of the database the table is on
+	SerializeSql(database string, out *bytes.Buffer) error
+
+	// Generates a select query on the current table.
+	Select(projections ...Projection) SelectStatement
+
+	// Creates a inner join table expression using onCondition.
+	InnerJoinOn(table ReadableTable, onCondition BoolExpression) ReadableTable
+
+	// Creates a left join table expression using onCondition.
+	LeftJoinOn(table ReadableTable, onCondition BoolExpression) ReadableTable
+
+	// Creates a right join table expression using onCondition.
+	RightJoinOn(table ReadableTable, onCondition BoolExpression) ReadableTable
+}
+
+// The sql table write interface.
+type WritableTable interface {
+	// Returns the list of columns that are in the table.
+	Columns() []NonAliasColumn
+
+	// Generates the sql string for the current table expression.  Note: the
+	// generated string may not be a valid/executable sql statement.
+	// The database is the name of the database the table is on
+	SerializeSql(database string, out *bytes.Buffer) error
+
+	Insert(columns ...NonAliasColumn) InsertStatement
+	Update() UpdateStatement
+	Delete() DeleteStatement
+}
+
+// Defines a physical table in the database that is both readable and writable.
+// This function will panic if name is not valid
+func NewTable(name string, columns ...NonAliasColumn) *Table {
+	if !validIdentifierName(name) {
+		panic("Invalid table name")
+	}
+
+	t := &Table{
+		name:         name,
+		columns:      columns,
+		columnLookup: make(map[string]NonAliasColumn),
+	}
+	for _, c := range columns {
+		err := c.setTableName(name)
+		if err != nil {
+			panic(err)
+		}
+		t.columnLookup[c.Name()] = c
+	}
+
+	if len(columns) == 0 {
+		panic(fmt.Sprintf("Table %s has no columns", name))
+	}
+
+	return t
+}
+
+type Table struct {
+	name         string
+	columns      []NonAliasColumn
+	columnLookup map[string]NonAliasColumn
+	// If not empty, the name of the index to force
+	forcedIndex string
+}
+
+// Returns the specified column, or errors if it doesn't exist in the table
+func (t *Table) getColumn(name string) (NonAliasColumn, error) {
+	if c, ok := t.columnLookup[name]; ok {
+		return c, nil
+	}
+	return nil, errors.Newf("No such column '%s' in table '%s'", name, t.name)
+}
+
+// Returns a pseudo column representation of the column name.  Error checking
+// is deferred to SerializeSql.
+func (t *Table) C(name string) NonAliasColumn {
+	return &deferredLookupColumn{
+		table:   t,
+		colName: name,
+	}
+}
+
+// Returns all columns for a table as a slice of projections
+func (t *Table) Projections() []Projection {
+	result := make([]Projection, 0)
+
+	for _, col := range t.columns {
+		result = append(result, col)
+	}
+
+	return result
+}
+
+// Returns the table's name in the database
+func (t *Table) Name() string {
+	return t.name
+}
+
+// Returns a list of the table's columns
+func (t *Table) Columns() []NonAliasColumn {
+	return t.columns
+}
+
+// Returns a copy of this table, but with the specified index forced.
+func (t *Table) ForceIndex(index string) *Table {
+	newTable := *t
+	newTable.forcedIndex = index
+	return &newTable
+}
+
+// Generates the sql string for the current table expression.  Note: the
+// generated string may not be a valid/executable sql statement.
+func (t *Table) SerializeSql(database string, out *bytes.Buffer) error {
+	_, _ = out.WriteString("`")
+	_, _ = out.WriteString(database)
+	_, _ = out.WriteString("`.`")
+	_, _ = out.WriteString(t.Name())
+	_, _ = out.WriteString("`")
+
+	if t.forcedIndex != "" {
+		if !validIdentifierName(t.forcedIndex) {
+			return errors.Newf("'%s' is not a valid identifier for an index", t.forcedIndex)
+		}
+		_, _ = out.WriteString(" FORCE INDEX (`")
+		_, _ = out.WriteString(t.forcedIndex)
+		_, _ = out.WriteString("`)")
+	}
+
+	return nil
+}
+
+// Generates a select query on the current table.
+func (t *Table) Select(projections ...Projection) SelectStatement {
+	return newSelectStatement(t, projections)
+}
+
+// Creates a inner join table expression using onCondition.
+func (t *Table) InnerJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return InnerJoinOn(t, table, onCondition)
+}
+
+// Creates a left join table expression using onCondition.
+func (t *Table) LeftJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return LeftJoinOn(t, table, onCondition)
+}
+
+// Creates a right join table expression using onCondition.
+func (t *Table) RightJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return RightJoinOn(t, table, onCondition)
+}
+
+func (t *Table) Insert(columns ...NonAliasColumn) InsertStatement {
+	return newInsertStatement(t, columns...)
+}
+
+func (t *Table) Update() UpdateStatement {
+	return newUpdateStatement(t)
+}
+
+func (t *Table) Delete() DeleteStatement {
+	return newDeleteStatement(t)
+}
+
+type joinType int
+
+const (
+	INNER_JOIN joinType = iota
+	LEFT_JOIN
+	RIGHT_JOIN
+)
+
+// Join expressions are pseudo readable tables.
+type joinTable struct {
+	lhs         ReadableTable
+	rhs         ReadableTable
+	join_type   joinType
+	onCondition BoolExpression
+}
+
+func newJoinTable(
+	lhs ReadableTable,
+	rhs ReadableTable,
+	join_type joinType,
+	onCondition BoolExpression) ReadableTable {
+
+	return &joinTable{
+		lhs:         lhs,
+		rhs:         rhs,
+		join_type:   join_type,
+		onCondition: onCondition,
+	}
+}
+
+func InnerJoinOn(
+	lhs ReadableTable,
+	rhs ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return newJoinTable(lhs, rhs, INNER_JOIN, onCondition)
+}
+
+func LeftJoinOn(
+	lhs ReadableTable,
+	rhs ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return newJoinTable(lhs, rhs, LEFT_JOIN, onCondition)
+}
+
+func RightJoinOn(
+	lhs ReadableTable,
+	rhs ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return newJoinTable(lhs, rhs, RIGHT_JOIN, onCondition)
+}
+
+func (t *joinTable) Columns() []NonAliasColumn {
+	columns := make([]NonAliasColumn, 0)
+	columns = append(columns, t.lhs.Columns()...)
+	columns = append(columns, t.rhs.Columns()...)
+
+	return columns
+}
+
+func (t *joinTable) SerializeSql(
+	database string,
+	out *bytes.Buffer) (err error) {
+
+	if t.lhs == nil {
+		return errors.Newf("nil lhs.  Generated sql: %s", out.String())
+	}
+	if t.rhs == nil {
+		return errors.Newf("nil rhs.  Generated sql: %s", out.String())
+	}
+	if t.onCondition == nil {
+		return errors.Newf("nil onCondition.  Generated sql: %s", out.String())
+	}
+
+	if err = t.lhs.SerializeSql(database, out); err != nil {
+		return
+	}
+
+	switch t.join_type {
+	case INNER_JOIN:
+		_, _ = out.WriteString(" JOIN ")
+	case LEFT_JOIN:
+		_, _ = out.WriteString(" LEFT JOIN ")
+	case RIGHT_JOIN:
+		_, _ = out.WriteString(" RIGHT JOIN ")
+	}
+
+	if err = t.rhs.SerializeSql(database, out); err != nil {
+		return
+	}
+
+	_, _ = out.WriteString(" ON ")
+	if err = t.onCondition.SerializeSql(out); err != nil {
+		return
+	}
+
+	return nil
+}
+
+func (t *joinTable) Select(projections ...Projection) SelectStatement {
+	return newSelectStatement(t, projections)
+}
+
+func (t *joinTable) InnerJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return InnerJoinOn(t, table, onCondition)
+}
+
+func (t *joinTable) LeftJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return LeftJoinOn(t, table, onCondition)
+}
+
+func (t *joinTable) RightJoinOn(
+	table ReadableTable,
+	onCondition BoolExpression) ReadableTable {
+
+	return RightJoinOn(t, table, onCondition)
+}

sqlbuilder/table_test.go

@@ -0,0 +1,209 @@
+package sqlbuilder
+
+import (
+	"bytes"
+
+	gc "gopkg.in/check.v1"
+)
+
+type TableSuite struct {
+}
+
+var _ = gc.Suite(&TableSuite{})
+
+// NOTE: tables / columns are defined in statement_test.go
+
+func (s *TableSuite) TestBasicColumns(c *gc.C) {
+	cols := table1.Columns()
+
+	c.Assert(len(cols), gc.Equals, 4)
+	c.Assert(cols[0], gc.Equals, table1Col1)
+	c.Assert(cols[1], gc.Equals, table1Col2)
+	c.Assert(cols[2], gc.Equals, table1Col3)
+	c.Assert(cols[3], gc.Equals, table1Col4)
+}
+
+func (s *TableSuite) TestCValidLookup(c *gc.C) {
+	col := table1.C("col1")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`table1`.`col1`")
+}
+
+func (s *TableSuite) TestCInvalidLookup(c *gc.C) {
+	col := table1.C("foo")
+
+	buf := &bytes.Buffer{}
+
+	err := col.SerializeSql(buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *TableSuite) TestValidForcedIndex(c *gc.C) {
+	t := table1.ForceIndex("foo")
+	buf := &bytes.Buffer{}
+	err := t.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+	sql := buf.String()
+	c.Assert(sql, gc.Equals, "`db`.`table1` FORCE INDEX (`foo`)")
+
+	// Ensure the original table is unchanged
+	buf = &bytes.Buffer{}
+	err = table1.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+	sql = buf.String()
+	c.Assert(sql, gc.Equals, "`db`.`table1`")
+}
+
+func (s *TableSuite) TestInvalidForcedIndex(c *gc.C) {
+	t := table1.ForceIndex("foo\x00")
+	buf := &bytes.Buffer{}
+	err := t.SerializeSql("db", buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *TableSuite) TestJoinNilLeftTable(c *gc.C) {
+	join := InnerJoinOn(nil, table2, EqL(table2Col3, 123))
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *TableSuite) TestJoinNilRightTable(c *gc.C) {
+	join := InnerJoinOn(table1, nil, EqL(table2Col3, 123))
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *TableSuite) TestJoinNilOnCondition(c *gc.C) {
+	join := InnerJoinOn(table1, table2, nil)
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.NotNil)
+}
+
+func (s *TableSuite) TestInnerJoin(c *gc.C) {
+	join := table1.InnerJoinOn(table2, Eq(table1Col3, table2Col3))
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` JOIN `db`.`table2` ON `table1`.`col3`=`table2`.`col3`")
+}
+
+func (s *TableSuite) TestLeftJoin(c *gc.C) {
+	join := table1.LeftJoinOn(table2, Eq(table1Col3, table2Col3))
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` LEFT JOIN `db`.`table2` "+
+			"ON `table1`.`col3`=`table2`.`col3`")
+}
+
+func (s *TableSuite) TestRightJoin(c *gc.C) {
+	join := table1.RightJoinOn(table2, Eq(table1Col3, table2Col3))
+
+	buf := &bytes.Buffer{}
+
+	err := join.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` RIGHT JOIN `db`.`table2` "+
+			"ON `table1`.`col3`=`table2`.`col3`")
+}
+
+func (s *TableSuite) TestJoinColumns(c *gc.C) {
+	join := table1.RightJoinOn(table2, Eq(table1Col3, table2Col3))
+
+	cols := join.Columns()
+	c.Assert(len(cols), gc.Equals, 6)
+	c.Assert(cols[0], gc.Equals, table1Col1)
+	c.Assert(cols[1], gc.Equals, table1Col2)
+	c.Assert(cols[2], gc.Equals, table1Col3)
+	c.Assert(cols[3], gc.Equals, table1Col4)
+	c.Assert(cols[4], gc.Equals, table2Col3)
+	c.Assert(cols[5], gc.Equals, table2Col4)
+}
+
+func (s *TableSuite) TestNestedInnerJoin(c *gc.C) {
+	join1 := table1.InnerJoinOn(table2, Eq(table1Col3, table2Col3))
+	join2 := join1.InnerJoinOn(table3, Eq(table1Col1, table3Col1))
+
+	buf := &bytes.Buffer{}
+
+	err := join2.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` "+
+			"JOIN `db`.`table2` ON `table1`.`col3`=`table2`.`col3` "+
+			"JOIN `db`.`table3` ON `table1`.`col1`=`table3`.`col1`")
+}
+
+func (s *TableSuite) TestNestedLeftJoin(c *gc.C) {
+	join1 := table1.InnerJoinOn(table2, Eq(table1Col3, table2Col3))
+	join2 := join1.LeftJoinOn(table3, Eq(table1Col1, table3Col1))
+
+	buf := &bytes.Buffer{}
+
+	err := join2.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` "+
+			"JOIN `db`.`table2` ON `table1`.`col3`=`table2`.`col3` "+
+			"LEFT JOIN `db`.`table3` ON `table1`.`col1`=`table3`.`col1`")
+}
+
+func (s *TableSuite) TestNestedRightJoin(c *gc.C) {
+	join1 := table1.InnerJoinOn(table2, Eq(table1Col3, table2Col3))
+	join2 := join1.RightJoinOn(table3, Eq(table1Col1, table3Col1))
+
+	buf := &bytes.Buffer{}
+
+	err := join2.SerializeSql("db", buf)
+	c.Assert(err, gc.IsNil)
+
+	sql := buf.String()
+	c.Assert(
+		sql,
+		gc.Equals,
+		"`db`.`table1` "+
+			"JOIN `db`.`table2` ON `table1`.`col3`=`table2`.`col3` "+
+			"RIGHT JOIN `db`.`table3` ON `table1`.`col1`=`table3`.`col1`")
+}

sqlbuilder/test_utils.go

@@ -0,0 +1,26 @@
+package sqlbuilder
+
+var table1Col1 = IntColumn("col1", Nullable)
+var table1Col2 = IntColumn("col2", Nullable)
+var table1Col3 = IntColumn("col3", Nullable)
+var table1Col4 = DateTimeColumn("col4", Nullable)
+var table1 = NewTable(
+	"table1",
+	table1Col1,
+	table1Col2,
+	table1Col3,
+	table1Col4)
+
+var table2Col3 = IntColumn("col3", Nullable)
+var table2Col4 = IntColumn("col4", Nullable)
+var table2 = NewTable(
+	"table2",
+	table2Col3,
+	table2Col4)
+
+var table3Col1 = IntColumn("col1", Nullable)
+var table3Col2 = IntColumn("col2", Nullable)
+var table3 = NewTable(
+	"table3",
+	table3Col1,
+	table3Col2)

sqlbuilder/types.go

@@ -0,0 +1,79 @@
+package sqlbuilder
+
+import (
+	"bytes"
+)
+
+type Clause interface {
+	SerializeSql(out *bytes.Buffer) error
+}
+
+// A clause that can be used in order by
+type OrderByClause interface {
+	Clause
+	isOrderByClauseInterface
+}
+
+// An expression
+type Expression interface {
+	Clause
+	isExpressionInterface
+}
+
+type BoolExpression interface {
+	Clause
+	isBoolExpressionInterface
+}
+
+// A clause that is selectable.
+type Projection interface {
+	Clause
+	isProjectionInterface
+	SerializeSqlForColumnList(out *bytes.Buffer) error
+}
+
+//
+// Boiler plates ...
+//
+
+type isOrderByClauseInterface interface {
+	isOrderByClauseType()
+}
+
+type isOrderByClause struct {
+}
+
+func (o *isOrderByClause) isOrderByClauseType() {
+}
+
+type isExpressionInterface interface {
+	isExpressionType()
+}
+
+type isExpression struct {
+	isOrderByClause // can always use expression in order by.
+}
+
+func (e *isExpression) isExpressionType() {
+}
+
+type isBoolExpressionInterface interface {
+	isExpressionInterface
+	isBoolExpressionType()
+}
+
+type isBoolExpression struct {
+}
+
+func (e *isBoolExpression) isBoolExpressionType() {
+}
+
+type isProjectionInterface interface {
+	isProjectionType()
+}
+
+type isProjection struct {
+}
+
+func (p *isProjection) isProjectionType() {
+}