Model refactor cleanup.

sqlbuilder/bool_expresion.go

@@ -1,51 +1,51 @@
 package sqlbuilder
 
-type BoolExpression interface {
-	Expression
+type boolExpression interface {
+	expression
 
-	Eq(expression BoolExpression) BoolExpression
-	NotEq(expression BoolExpression) BoolExpression
-	GtEq(rhs Expression) BoolExpression
-	LtEq(rhs Expression) BoolExpression
+	Eq(expression boolExpression) boolExpression
+	NotEq(expression boolExpression) boolExpression
+	GtEq(rhs expression) boolExpression
+	LtEq(rhs expression) boolExpression
 
-	AND(expression BoolExpression) BoolExpression
-	OR(expression BoolExpression) BoolExpression
-	IS_TRUE() BoolExpression
-	IS_FALSE() BoolExpression
+	AND(expression boolExpression) boolExpression
+	OR(expression boolExpression) boolExpression
+	IS_TRUE() boolExpression
+	IS_FALSE() boolExpression
 }
 
 type boolInterfaceImpl struct {
-	parent BoolExpression
+	parent boolExpression
 }
 
-func (b *boolInterfaceImpl) Eq(expression BoolExpression) BoolExpression {
+func (b *boolInterfaceImpl) Eq(expression boolExpression) boolExpression {
 	return Eq(b.parent, expression)
 }
 
-func (b *boolInterfaceImpl) NotEq(expression BoolExpression) BoolExpression {
+func (b *boolInterfaceImpl) NotEq(expression boolExpression) boolExpression {
 	return NotEq(b.parent, expression)
 }
 
-func (b *boolInterfaceImpl) GtEq(rhs Expression) BoolExpression {
+func (b *boolInterfaceImpl) GtEq(rhs expression) boolExpression {
 	return GtEq(b.parent, rhs)
 }
 
-func (b *boolInterfaceImpl) LtEq(rhs Expression) BoolExpression {
+func (b *boolInterfaceImpl) LtEq(rhs expression) boolExpression {
 	return LtEq(b.parent, rhs)
 }
 
-func (b *boolInterfaceImpl) AND(expression BoolExpression) BoolExpression {
+func (b *boolInterfaceImpl) AND(expression boolExpression) boolExpression {
 	return And(b.parent, expression)
 }
 
-func (b *boolInterfaceImpl) OR(expression BoolExpression) BoolExpression {
+func (b *boolInterfaceImpl) OR(expression boolExpression) boolExpression {
 	return Or(b.parent, expression)
 }
-func (b *boolInterfaceImpl) IS_TRUE() BoolExpression {
+func (b *boolInterfaceImpl) IS_TRUE() boolExpression {
 	return IsTrue(b.parent)
 }
 
-func (b *boolInterfaceImpl) IS_FALSE() BoolExpression {
+func (b *boolInterfaceImpl) IS_FALSE() boolExpression {
 	return nil
 }
 
@@ -55,7 +55,7 @@ type boolLiteralExpression struct {
 	literalExpression
 }
 
-func newBoolLiteralExpression(value bool) BoolExpression {
+func newBoolLiteralExpression(value bool) boolExpression {
 	boolLiteralExpression := boolLiteralExpression{}
 
 	boolLiteralExpression.literalExpression = *Literal(value)
@@ -72,7 +72,7 @@ type binaryBoolExpression struct {
 	binaryExpression
 }
 
-func newBinaryBoolExpression(lhs, rhs Expression, operator string) BoolExpression {
+func newBinaryBoolExpression(lhs, rhs expression, operator string) boolExpression {
 	boolExpression := binaryBoolExpression{}
 
 	boolExpression.binaryExpression = newBinaryExpression(lhs, rhs, operator)
@@ -90,7 +90,7 @@ type prefixBoolExpression struct {
 	prefixExpression
 }
 
-func newPrefixBoolExpression(expression Expression, operator string) BoolExpression {
+func newPrefixBoolExpression(expression expression, operator string) boolExpression {
 	boolExpression := prefixBoolExpression{}
 	boolExpression.prefixExpression = newPrefixExpression(expression, operator)
 
@@ -100,100 +100,100 @@ func newPrefixBoolExpression(expression Expression, operator string) BoolExpress
 	return &boolExpression
 }
 
-func EXISTS(subQuery SelectStatement) BoolExpression {
+func EXISTS(subQuery selectStatement) boolExpression {
 	return newPrefixBoolExpression(subQuery, "EXISTS")
 }
 
 // Returns a representation of "a=b"
-func Eq(lhs, rhs Expression) BoolExpression {
+func Eq(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "=")
 }
 
 // Returns a representation of "a=b", where b is a literal
-func EqL(lhs Expression, val interface{}) BoolExpression {
+func EqL(lhs expression, val interface{}) boolExpression {
 	return Eq(lhs, Literal(val))
 }
 
 // Returns a representation of "a!=b"
-func NotEq(lhs, rhs Expression) BoolExpression {
+func NotEq(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "!=")
 }
 
 // Returns a representation of "a!=b", where b is a literal
-func NeqL(lhs Expression, val interface{}) BoolExpression {
+func NeqL(lhs expression, val interface{}) boolExpression {
 	return NotEq(lhs, Literal(val))
 }
 
 // Returns a representation of "a<b"
-func Lt(lhs Expression, rhs Expression) BoolExpression {
+func Lt(lhs expression, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "<")
 }
 
 // Returns a representation of "a<b", where b is a literal
-func LtL(lhs Expression, val interface{}) BoolExpression {
+func LtL(lhs expression, val interface{}) boolExpression {
 	return Lt(lhs, Literal(val))
 }
 
 // Returns a representation of "a<=b"
-func LtEq(lhs, rhs Expression) BoolExpression {
+func LtEq(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "<=")
 }
 
 // Returns a representation of "a<=b", where b is a literal
-func LteL(lhs Expression, val interface{}) BoolExpression {
+func LteL(lhs expression, val interface{}) boolExpression {
 	return LtEq(lhs, Literal(val))
 }
 
 // Returns a representation of "a>b"
-func Gt(lhs, rhs Expression) BoolExpression {
+func Gt(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, ">")
 }
 
 // Returns a representation of "a>b", where b is a literal
-func GtL(lhs Expression, val interface{}) BoolExpression {
+func GtL(lhs expression, val interface{}) boolExpression {
 	return Gt(lhs, Literal(val))
 }
 
 // Returns a representation of "a>=b"
-func GtEq(lhs, rhs Expression) BoolExpression {
+func GtEq(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, ">=")
 }
 
 // Returns a representation of "a>=b", where b is a literal
-func GteL(lhs Expression, val interface{}) BoolExpression {
+func GteL(lhs expression, val interface{}) boolExpression {
 	return GtEq(lhs, Literal(val))
 }
 
 // Returns a representation of "not expr"
-func Not(expr BoolExpression) BoolExpression {
+func Not(expr boolExpression) boolExpression {
 	return newPrefixBoolExpression(expr, "NOT")
 }
 
-func IsTrue(expr BoolExpression) BoolExpression {
+func IsTrue(expr boolExpression) boolExpression {
 	return newPrefixBoolExpression(expr, "IS TRUE")
 }
 
-func And(lhs, rhs Expression) BoolExpression {
+func And(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "AND")
 }
 
 // Returns a representation of "c[0] OR ... OR c[n-1]" for c in clauses
-func Or(lhs, rhs Expression) BoolExpression {
+func Or(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "OR")
 }
 
-func Like(lhs, rhs Expression) BoolExpression {
+func Like(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "LIKE")
 }
 
-func LikeL(lhs Expression, val string) BoolExpression {
+func LikeL(lhs expression, val string) boolExpression {
 	return Like(lhs, Literal(val))
 }
 
-func Regexp(lhs, rhs Expression) BoolExpression {
+func Regexp(lhs, rhs expression) boolExpression {
 	return newBinaryBoolExpression(lhs, rhs, "REGEXP")
 }
 
-func RegexpL(lhs Expression, val string) BoolExpression {
+func RegexpL(lhs expression, val string) boolExpression {
 	return Regexp(lhs, Literal(val))
 }