From 5ed7cf2b1cb4ede7af273821c231e38a194c3c5f Mon Sep 17 00:00:00 2001 From: zer0sub Date: Mon, 13 May 2019 12:33:11 +0200 Subject: [PATCH] Improve serialization error handling. --- sqlbuilder/delete_statement.go | 11 ++++--- sqlbuilder/expression.go | 7 ++++ sqlbuilder/expression_table.go | 55 +++++++++++++++++--------------- sqlbuilder/func_expression.go | 8 +++++ sqlbuilder/numeric_expression.go | 9 ++++-- sqlbuilder/select_statement.go | 6 ++++ sqlbuilder/set_statement.go | 18 +++++++---- sqlbuilder/table.go | 6 ++-- 8 files changed, 81 insertions(+), 39 deletions(-) diff --git a/sqlbuilder/delete_statement.go b/sqlbuilder/delete_statement.go index 54dcef6..228a335 100644 --- a/sqlbuilder/delete_statement.go +++ b/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 { - return Query(u, db, destination) +func (d *deleteStatementImpl) Query(db types.Db, destination interface{}) error { + return Query(d, db, destination) } -func (u *deleteStatementImpl) Execute(db types.Db) (res sql.Result, err error) { - return Execute(u, db) +func (d *deleteStatementImpl) Execute(db types.Db) (res sql.Result, err error) { + return Execute(d, db) } diff --git a/sqlbuilder/expression.go b/sqlbuilder/expression.go index 4e55fe2..d6cf022 100644 --- a/sqlbuilder/expression.go +++ b/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 { diff --git a/sqlbuilder/expression_table.go b/sqlbuilder/expression_table.go index 147c744..77ddd2d 100644 --- a/sqlbuilder/expression_table.go +++ b/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 { - return s.alias +func (e *expressionTableImpl) TableName() string { + 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 { - return newSelectStatement(s, projections) +func (e *expressionTableImpl) SELECT(projections ...projection) selectStatement { + return newSelectStatement(e, projections) } // Creates a inner join tableName expression using onCondition. -func (s *expressionTableImpl) INNER_JOIN(table readableTable, onCondition boolExpression) readableTable { - return InnerJoinOn(s, table, onCondition) +func (e *expressionTableImpl) INNER_JOIN(table readableTable, onCondition boolExpression) readableTable { + 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 { - return LeftJoinOn(s, table, onCondition) +func (e *expressionTableImpl) LEFT_JOIN(table readableTable, onCondition boolExpression) readableTable { + return LeftJoinOn(e, table, onCondition) } // Creates a right join tableName expression using onCondition. -func (s *expressionTableImpl) RIGHT_JOIN(table readableTable, onCondition boolExpression) readableTable { - return RightJoinOn(s, table, onCondition) +func (e *expressionTableImpl) RIGHT_JOIN(table readableTable, onCondition boolExpression) readableTable { + return RightJoinOn(e, table, onCondition) } -func (s *expressionTableImpl) FULL_JOIN(table readableTable, onCondition boolExpression) readableTable { - return FullJoin(s, table, onCondition) +func (e *expressionTableImpl) FULL_JOIN(table readableTable, onCondition boolExpression) readableTable { + return FullJoin(e, table, onCondition) } -func (s *expressionTableImpl) CROSS_JOIN(table readableTable) readableTable { - return CrossJoin(s, table) +func (e *expressionTableImpl) CROSS_JOIN(table readableTable) readableTable { + return CrossJoin(e, table) } diff --git a/sqlbuilder/func_expression.go b/sqlbuilder/func_expression.go index 71b99d3..5695294 100644 --- a/sqlbuilder/func_expression.go +++ b/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 { diff --git a/sqlbuilder/numeric_expression.go b/sqlbuilder/numeric_expression.go index 17fc60a..05dc258 100644 --- a/sqlbuilder/numeric_expression.go +++ b/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 diff --git a/sqlbuilder/select_statement.go b/sqlbuilder/select_statement.go index 6b20e2c..af2c613 100644 --- a/sqlbuilder/select_statement.go +++ b/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") diff --git a/sqlbuilder/set_statement.go b/sqlbuilder/set_statement.go index d58e4f3..a1bfe5e 100644 --- a/sqlbuilder/set_statement.go +++ b/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.") diff --git a/sqlbuilder/table.go b/sqlbuilder/table.go index 325dbcd..a2b09e1 100644 --- a/sqlbuilder/table.go +++ b/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.") }