Improve serialization error handling.

sqlbuilder/delete_statement.go

@@ -29,6 +29,9 @@ func (d *deleteStatementImpl) WHERE(expression boolExpression) deleteStatement {
 }
 
 func (d *deleteStatementImpl) serializeImpl(out *queryData) error {
+	if d == nil {
+		return errors.New("Delete statement. ")
+	}
 	out.nextLine()
 	out.writeString("DELETE FROM")
 
@@ -68,10 +71,10 @@ func (d *deleteStatementImpl) DebugSql() (query string, err error) {
 	return DebugSql(d)
 }
 
-func (u *deleteStatementImpl) Query(db types.Db, destination interface{}) error {
+func (d *deleteStatementImpl) Query(db types.Db, destination interface{}) error {
-	return Query(u, db, destination)
+	return Query(d, db, destination)
 }
 
-func (u *deleteStatementImpl) Execute(db types.Db) (res sql.Result, err error) {
+func (d *deleteStatementImpl) Execute(db types.Db) (res sql.Result, err error) {
-	return Execute(u, db)
+	return Execute(d, db)
 }

sqlbuilder/expression.go

@@ -96,6 +96,9 @@ func isSimpleOperand(expression expression) bool {
 }
 
 func (c *binaryExpression) serialize(statement statementType, out *queryData) error {
+	if c == nil {
+		return errors.New("Binary expression is nil.")
+	}
 	if c.lhs == nil {
 		return errors.Newf("nil lhs.")
 	}
@@ -142,6 +145,10 @@ func newPrefixExpression(expression expression, operator string) prefixExpressio
 }
 
 func (p *prefixExpression) serialize(statement statementType, out *queryData) error {
+	if p == nil {
+		return errors.New("Prefix expression is nil.")
+	}
+
 	out.writeString(p.operator + " ")
 
 	if p.expression == nil {

sqlbuilder/expression_table.go

@@ -1,5 +1,7 @@
 package sqlbuilder
 
+import "errors"
+
 type expressionTable interface {
 	readableTable
 
@@ -14,60 +16,63 @@ type expressionTableImpl struct {
 }
 
 // Returns the tableName's name in the database
-func (t *expressionTableImpl) SchemaName() string {
+func (e *expressionTableImpl) SchemaName() string {
 	return ""
 }
 
-func (s *expressionTableImpl) TableName() string {
+func (e *expressionTableImpl) TableName() string {
-	return s.alias
+	return e.alias
 }
 
-func (s *expressionTableImpl) Columns() []column {
+func (e *expressionTableImpl) Columns() []column {
 	return []column{}
 }
 
-func (s *expressionTableImpl) RefIntColumnName(name string) *IntegerColumn {
+func (e *expressionTableImpl) RefIntColumnName(name string) *IntegerColumn {
 	intColumn := NewIntegerColumn(name, NotNullable)
-	intColumn.setTableName(s.alias)
+	intColumn.setTableName(e.alias)
 
 	return intColumn
 }
 
-func (s *expressionTableImpl) RefIntColumn(column column) *IntegerColumn {
+func (e *expressionTableImpl) RefIntColumn(column column) *IntegerColumn {
 	intColumn := NewIntegerColumn(column.TableName()+"."+column.Name(), NotNullable)
-	intColumn.setTableName(s.alias)
+	intColumn.setTableName(e.alias)
 
 	return intColumn
 }
 
-func (s *expressionTableImpl) RefStringColumn(column column) *StringColumn {
+func (e *expressionTableImpl) RefStringColumn(column column) *StringColumn {
 	strColumn := NewStringColumn(column.TableName()+"."+column.Name(), NotNullable)
-	strColumn.setTableName(s.alias)
+	strColumn.setTableName(e.alias)
 	return strColumn
 }
 
-func (s *expressionTableImpl) serialize(statement statementType, out *queryData) error {
+func (e *expressionTableImpl) serialize(statement statementType, out *queryData) error {
+	if e == nil {
+		return errors.New("Expression table is nil. ")
+	}
 	//out.writeString("( ")
-	err := s.statement.serialize(statement, out)
+	err := e.statement.serialize(statement, out)
 
 	if err != nil {
 		return err
 	}
 
 	out.writeString("AS")
-	out.writeString(s.alias)
+	out.writeString(e.alias)
 
 	return nil
 }
 
 // Generates a select query on the current tableName.
-func (s *expressionTableImpl) SELECT(projections ...projection) selectStatement {
+func (e *expressionTableImpl) SELECT(projections ...projection) selectStatement {
-	return newSelectStatement(s, projections)
+	return newSelectStatement(e, projections)
 }
 
 // Creates a inner join tableName expression using onCondition.
-func (s *expressionTableImpl) INNER_JOIN(table readableTable, onCondition boolExpression) readableTable {
+func (e *expressionTableImpl) INNER_JOIN(table readableTable, onCondition boolExpression) readableTable {
-	return InnerJoinOn(s, table, onCondition)
+	return InnerJoinOn(e, table, onCondition)
 }
 
 //func (s *expressionTableImpl) InnerJoinUsing(table readableTable, col1 column, col2 column) readableTable {
@@ -75,19 +80,19 @@ func (s *expressionTableImpl) INNER_JOIN(table readableTable, onCondition boolEx
 //}
 
 // Creates a left join tableName expression using onCondition.
-func (s *expressionTableImpl) LEFT_JOIN(table readableTable, onCondition boolExpression) readableTable {
+func (e *expressionTableImpl) LEFT_JOIN(table readableTable, onCondition boolExpression) readableTable {
-	return LeftJoinOn(s, table, onCondition)
+	return LeftJoinOn(e, table, onCondition)
 }
 
 // Creates a right join tableName expression using onCondition.
-func (s *expressionTableImpl) RIGHT_JOIN(table readableTable, onCondition boolExpression) readableTable {
+func (e *expressionTableImpl) RIGHT_JOIN(table readableTable, onCondition boolExpression) readableTable {
-	return RightJoinOn(s, table, onCondition)
+	return RightJoinOn(e, table, onCondition)
 }
 
-func (s *expressionTableImpl) FULL_JOIN(table readableTable, onCondition boolExpression) readableTable {
+func (e *expressionTableImpl) FULL_JOIN(table readableTable, onCondition boolExpression) readableTable {
-	return FullJoin(s, table, onCondition)
+	return FullJoin(e, table, onCondition)
 }
 
-func (s *expressionTableImpl) CROSS_JOIN(table readableTable) readableTable {
+func (e *expressionTableImpl) CROSS_JOIN(table readableTable) readableTable {
-	return CrossJoin(s, table)
+	return CrossJoin(e, table)
 }

sqlbuilder/func_expression.go

@@ -29,6 +29,10 @@ func newFunc(name string, expressions []expression, parent expression) *funcExpr
 }
 
 func (f *funcExpressionImpl) serialize(statement statementType, out *queryData) error {
+	if f == nil {
+		return errors.New("Function expression is nil. ")
+	}
+
 	out.writeString(f.name + "(")
 
 	err := serializeExpressionList(statement, f.expression, ", ", out)
@@ -108,6 +112,10 @@ func (c *caseExpression) ELSE(els expression) caseInterface {
 }
 
 func (c *caseExpression) serialize(statement statementType, out *queryData) error {
+	if c == nil {
+		return errors.New("Case expression is nil. ")
+	}
+
 	out.writeString("(CASE")
 
 	if c.expression != nil {

sqlbuilder/numeric_expression.go

@@ -1,5 +1,7 @@
 package sqlbuilder
 
+import "errors"
+
 type numericExpression interface {
 	expression
 
@@ -130,9 +132,12 @@ func newNumericExpressionWrap(expression expression) numericExpression {
 	return &numericExpressionWrap
 }
 
-func (c *numericExpressionWrapper) serialize(statement statementType, out *queryData) error {
+func (n *numericExpressionWrapper) serialize(statement statementType, out *queryData) error {
+	if n == nil {
+		return errors.New("Numeric expression wrapper is nil. ")
+	}
 	//out.writeString("(")
-	err := c.expression.serialize(statement, out)
+	err := n.expression.serialize(statement, out)
 	//out.writeString(")")
 
 	return err

sqlbuilder/select_statement.go

@@ -86,6 +86,9 @@ func (s *selectStatementImpl) FROM(table readableTable) selectStatement {
 }
 
 func (s *selectStatementImpl) serialize(statement statementType, out *queryData) error {
+	if s == nil {
+		return errors.New("Select statement is nil. ")
+	}
 	out.writeString("(")
 
 	out.increaseIdent()
@@ -103,6 +106,9 @@ func (s *selectStatementImpl) serialize(statement statementType, out *queryData)
 }
 
 func (s *selectStatementImpl) serializeImpl(out *queryData) error {
+	if s == nil {
+		return errors.New("Select statement is nil. ")
+	}
 
 	out.nextLine()
 	out.writeString("SELECT")

sqlbuilder/set_statement.go

@@ -6,12 +6,6 @@ import (
 	"github.com/sub0zero/go-sqlbuilder/types"
 )
 
-const (
-	union     = "UNION"
-	intersect = "INTERSECT"
-	except    = "EXCEPT"
-)
-
 type setStatement interface {
 	Statement
 	expression
@@ -24,6 +18,12 @@ type setStatement interface {
 	AsTable(alias string) expressionTable
 }
 
+const (
+	union     = "UNION"
+	intersect = "INTERSECT"
+	except    = "EXCEPT"
+)
+
 func UNION(selects ...rowsType) setStatement {
 	return newSetStatementImpl(union, false, selects...)
 }
@@ -99,6 +99,9 @@ func (us *setStatementImpl) AsTable(alias string) expressionTable {
 }
 
 func (s *setStatementImpl) serialize(statement statementType, out *queryData) error {
+	if s == nil {
+		return errors.New("Set statement is nil. ")
+	}
 
 	if s.orderBy != nil || s.limit >= 0 || s.offset >= 0 {
 		out.writeString("(")
@@ -121,6 +124,9 @@ func (s *setStatementImpl) serialize(statement statementType, out *queryData) er
 }
 
 func (s *setStatementImpl) serializeImpl(out *queryData) error {
+	if s == nil {
+		return errors.New("Set statement is nil. ")
+	}
 
 	if len(s.selects) < 2 {
 		return errors.Newf("UNION Statement must have at least two SELECT statements.")

sqlbuilder/table.go

@@ -109,7 +109,7 @@ func (t *Table) Columns() []column {
 // generated string may not be a valid/executable sql Statement.
 func (t *Table) serialize(statement statementType, out *queryData) error {
 	if t == nil {
-		return errors.Newf("nil tableName.")
+		return errors.Newf("Table is nil. ")
 	}
 
 	out.writeString(t.schemaName)
@@ -272,7 +272,9 @@ func (t *joinTable) Column(name string) column {
 }
 
 func (t *joinTable) serialize(statement statementType, out *queryData) (err error) {
-
+	if t == nil {
+		return errors.New("Join table is nil. ")
+	}
 	if t.lhs == nil {
 		return errors.Newf("nil lhs.")
 	}