Add StringColumn type and expression

Add Projection type
Alias refactoring
More numeric operations

sqlbuilder/numeric_expression.go

@@ -1,6 +1,7 @@
 package sqlbuilder
 
 import (
+	"bytes"
 	"github.com/dropbox/godropbox/database/sqltypes"
 	"github.com/pkg/errors"
 )
@@ -9,9 +10,13 @@ type NumericExpression interface {
 	Expression
 
 	Eq(expression NumericExpression) BoolExpression
+	EqL(literal interface{}) BoolExpression
 	NotEq(expression NumericExpression) BoolExpression
+	NotEqL(literal interface{}) BoolExpression
 	GtEq(rhs NumericExpression) BoolExpression
+	GtEqL(literal interface{}) BoolExpression
 	LtEq(rhs NumericExpression) BoolExpression
+	LtEqL(literal interface{}) BoolExpression
 
 	Add(expression NumericExpression) NumericExpression
 	Sub(expression NumericExpression) NumericExpression
@@ -27,16 +32,32 @@ func (n *numericInterfaceImpl) Eq(expression NumericExpression) BoolExpression {
 	return Eq(n.parent, expression)
 }
 
+func (n *numericInterfaceImpl) EqL(literal interface{}) BoolExpression {
+	return Eq(n.parent, Literal(literal))
+}
+
 func (n *numericInterfaceImpl) NotEq(expression NumericExpression) BoolExpression {
-	return Neq(n.parent, expression)
+	return NotEq(n.parent, expression)
+}
+
+func (n *numericInterfaceImpl) NotEqL(literal interface{}) BoolExpression {
+	return NotEq(n.parent, Literal(literal))
 }
 
 func (n *numericInterfaceImpl) GtEq(expression NumericExpression) BoolExpression {
-	return Gte(n.parent, expression)
+	return GtEq(n.parent, expression)
+}
+
+func (n *numericInterfaceImpl) GtEqL(literal interface{}) BoolExpression {
+	return GtEq(n.parent, Literal(literal))
 }
 
 func (n *numericInterfaceImpl) LtEq(expression NumericExpression) BoolExpression {
-	return Lte(n.parent, expression)
+	return LtEq(n.parent, expression)
+}
+
+func (n *numericInterfaceImpl) LtEqL(literal interface{}) BoolExpression {
+	return LtEq(n.parent, Literal(literal))
 }
 
 func (n *numericInterfaceImpl) Add(expression NumericExpression) NumericExpression {
@@ -92,3 +113,30 @@ func newBinaryNumericExpression(lhs, rhs Expression, operator []byte) NumericExp
 
 	return &numericExpression
 }
+
+//---------------------------------------------------//
+type numericExpressionWrapper struct {
+	expressionInterfaceImpl
+	numericInterfaceImpl
+
+	expression Expression
+}
+
+func newNumericExpressionWrap(expression Expression) NumericExpression {
+	numericExpressionWrap := numericExpressionWrapper{}
+
+	numericExpressionWrap.expression = expression
+
+	numericExpressionWrap.expressionInterfaceImpl.parent = &numericExpressionWrap
+	numericExpressionWrap.numericInterfaceImpl.parent = &numericExpressionWrap
+
+	return &numericExpressionWrap
+}
+
+func (c *numericExpressionWrapper) SerializeSql(out *bytes.Buffer, options ...serializeOption) (err error) {
+	out.WriteString("(")
+	err = c.expression.SerializeSql(out, options...)
+	out.WriteString(")")
+
+	return nil
+}