Strictly type Integer and Real expressions.

sqlbuilder/float_expression.go

@@ -0,0 +1,123 @@
+package sqlbuilder
+
+import "errors"
+
+type FloatExpression interface {
+	expression
+
+	EQ(rhs FloatExpression) BoolExpression
+	NOT_EQ(rhs FloatExpression) BoolExpression
+	IS_DISTINCT_FROM(rhs FloatExpression) BoolExpression
+	IS_NOT_DISTINCT_FROM(rhs FloatExpression) BoolExpression
+
+	LT(rhs FloatExpression) BoolExpression
+	LT_EQ(rhs FloatExpression) BoolExpression
+	GT(rhs FloatExpression) BoolExpression
+	GT_EQ(rhs FloatExpression) BoolExpression
+
+	ADD(rhs FloatExpression) FloatExpression
+	SUB(rhs FloatExpression) FloatExpression
+	MUL(rhs FloatExpression) FloatExpression
+	DIV(rhs FloatExpression) FloatExpression
+}
+
+type floatInterfaceImpl struct {
+	parent FloatExpression
+}
+
+func (n *floatInterfaceImpl) EQ(rhs FloatExpression) BoolExpression {
+	return EQ(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) NOT_EQ(rhs FloatExpression) BoolExpression {
+	return NOT_EQ(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) IS_DISTINCT_FROM(rhs FloatExpression) BoolExpression {
+	return IS_DISTINCT_FROM(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs FloatExpression) BoolExpression {
+	return IS_NOT_DISTINCT_FROM(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) GT(rhs FloatExpression) BoolExpression {
+	return GT(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) GT_EQ(rhs FloatExpression) BoolExpression {
+	return GT_EQ(n.parent, rhs)
+}
+
+func (n *floatInterfaceImpl) LT(expression FloatExpression) BoolExpression {
+	return LT(n.parent, expression)
+}
+
+func (n *floatInterfaceImpl) LT_EQ(expression FloatExpression) BoolExpression {
+	return LT_EQ(n.parent, expression)
+}
+
+func (n *floatInterfaceImpl) ADD(expression FloatExpression) FloatExpression {
+	return newBinaryFloatExpression(n.parent, expression, "+")
+}
+
+func (n *floatInterfaceImpl) SUB(expression FloatExpression) FloatExpression {
+	return newBinaryFloatExpression(n.parent, expression, "-")
+}
+
+func (n *floatInterfaceImpl) MUL(expression FloatExpression) FloatExpression {
+	return newBinaryFloatExpression(n.parent, expression, "*")
+}
+
+func (n *floatInterfaceImpl) DIV(expression FloatExpression) FloatExpression {
+	return newBinaryFloatExpression(n.parent, expression, "/")
+}
+
+//---------------------------------------------------//
+type binaryFloatExpression struct {
+	expressionInterfaceImpl
+	floatInterfaceImpl
+
+	binaryOpExpression
+}
+
+func newBinaryFloatExpression(lhs, rhs FloatExpression, operator string) FloatExpression {
+	floatExpression := binaryFloatExpression{}
+
+	floatExpression.binaryOpExpression = newBinaryExpression(lhs, rhs, operator)
+
+	floatExpression.expressionInterfaceImpl.parent = &floatExpression
+	floatExpression.floatInterfaceImpl.parent = &floatExpression
+
+	return &floatExpression
+}
+
+////---------------------------------------------------//
+type floatExpressionWrapper struct {
+	expressionInterfaceImpl
+	floatInterfaceImpl
+
+	expression expression
+}
+
+func newFloatExpressionWrap(expression expression) FloatExpression {
+	floatExpressionWrap := floatExpressionWrapper{}
+
+	floatExpressionWrap.expression = expression
+
+	floatExpressionWrap.expressionInterfaceImpl.parent = &floatExpressionWrap
+	floatExpressionWrap.floatInterfaceImpl.parent = &floatExpressionWrap
+
+	return &floatExpressionWrap
+}
+
+func (n *floatExpressionWrapper) serialize(statement statementType, out *queryData) error {
+	if n == nil {
+		return errors.New("Float expression wrapper is nil. ")
+	}
+	//out.writeString("(")
+	err := n.expression.serialize(statement, out)
+	//out.writeString(")")
+
+	return err
+}