139 lines
4 KiB
Go
139 lines
4 KiB
Go
package sqlbuilder
|
|
|
|
type NumericExpression interface {
|
|
Expression
|
|
|
|
Eq(expression NumericExpression) BoolExpression
|
|
EqL(literal interface{}) BoolExpression
|
|
NotEq(expression NumericExpression) BoolExpression
|
|
NotEqL(literal interface{}) BoolExpression
|
|
|
|
Gt(rhs NumericExpression) 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
|
|
Mul(expression NumericExpression) NumericExpression
|
|
Div(expression NumericExpression) NumericExpression
|
|
}
|
|
|
|
type numericInterfaceImpl struct {
|
|
parent NumericExpression
|
|
}
|
|
|
|
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 NotEq(n.parent, expression)
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) NotEqL(literal interface{}) BoolExpression {
|
|
return NotEq(n.parent, Literal(literal))
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) Gt(expression NumericExpression) BoolExpression {
|
|
return Gt(n.parent, expression)
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) GtEq(expression NumericExpression) BoolExpression {
|
|
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 LtEq(n.parent, expression)
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) LtEqL(literal interface{}) BoolExpression {
|
|
return LtEq(n.parent, Literal(literal))
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) Add(expression NumericExpression) NumericExpression {
|
|
return newBinaryNumericExpression(n.parent, expression, " + ")
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) Sub(expression NumericExpression) NumericExpression {
|
|
return newBinaryNumericExpression(n.parent, expression, " - ")
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) Mul(expression NumericExpression) NumericExpression {
|
|
return newBinaryNumericExpression(n.parent, expression, " * ")
|
|
}
|
|
|
|
func (n *numericInterfaceImpl) Div(expression NumericExpression) NumericExpression {
|
|
return newBinaryNumericExpression(n.parent, expression, " / ")
|
|
}
|
|
|
|
//---------------------------------------------------//
|
|
type numericLiteral struct {
|
|
numericInterfaceImpl
|
|
literalExpression
|
|
}
|
|
|
|
func NewNumericLiteral(value interface{}) NumericExpression {
|
|
numericLiteral := numericLiteral{}
|
|
numericLiteral.literalExpression = *Literal(value)
|
|
|
|
numericLiteral.numericInterfaceImpl.parent = &numericLiteral
|
|
|
|
return &numericLiteral
|
|
}
|
|
|
|
//---------------------------------------------------//
|
|
type binaryNumericExpression struct {
|
|
expressionInterfaceImpl
|
|
numericInterfaceImpl
|
|
|
|
binaryExpression
|
|
}
|
|
|
|
func newBinaryNumericExpression(lhs, rhs Expression, operator string) NumericExpression {
|
|
numericExpression := binaryNumericExpression{}
|
|
|
|
numericExpression.binaryExpression = newBinaryExpression(lhs, rhs, operator)
|
|
|
|
numericExpression.expressionInterfaceImpl.parent = &numericExpression
|
|
numericExpression.numericInterfaceImpl.parent = &numericExpression
|
|
|
|
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) Serialize(out *queryData, options ...serializeOption) error {
|
|
out.WriteString("(")
|
|
err := c.expression.Serialize(out, options...)
|
|
out.WriteString(")")
|
|
|
|
return err
|
|
}
|