init - add project files

tools/jet-2.12.0/internal/jet/operators.go

@@ -0,0 +1,194 @@
+package jet
+
+// Operators
+const (
+	StringConcatOperator        = "||"
+	StringRegexpLikeOperator    = "REGEXP"
+	StringNotRegexpLikeOperator = "NOT REGEXP"
+)
+
+//----------- Logical operators ---------------//
+
+// NOT returns negation of bool expression result
+func NOT(exp BoolExpression) BoolExpression {
+	return newPrefixBoolOperatorExpression(exp, "NOT")
+}
+
+// BIT_NOT inverts every bit in integer expression result
+func BIT_NOT(expr IntegerExpression) IntegerExpression {
+	if literalExp, ok := expr.(LiteralExpression); ok {
+		literalExp.SetConstant(true)
+	}
+	return newPrefixIntegerOperatorExpression(expr, "~")
+}
+
+//----------- Comparison operators ---------------//
+
+// EXISTS checks for existence of the rows in subQuery
+func EXISTS(subQuery Expression) BoolExpression {
+	return newPrefixBoolOperatorExpression(subQuery, "EXISTS")
+}
+
+// Eq returns a representation of "a=b"
+func Eq(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "=")
+}
+
+// NotEq returns a representation of "a!=b"
+func NotEq(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "!=")
+}
+
+// IsDistinctFrom returns a representation of "a IS DISTINCT FROM b"
+func IsDistinctFrom(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "IS DISTINCT FROM")
+}
+
+// IsNotDistinctFrom returns a representation of "a IS NOT DISTINCT FROM b"
+func IsNotDistinctFrom(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "IS NOT DISTINCT FROM")
+}
+
+// Lt returns a representation of "a<b"
+func Lt(lhs Expression, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "<")
+}
+
+// LtEq returns a representation of "a<=b"
+func LtEq(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "<=")
+}
+
+// Gt returns a representation of "a>b"
+func Gt(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, ">")
+}
+
+// GtEq returns a representation of "a>=b"
+func GtEq(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, ">=")
+}
+
+// Contains returns a representation of "a @> b"
+func Contains(lhs Expression, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "@>")
+}
+
+// Overlap returns a representation of "a && b"
+func Overlap(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "&&")
+}
+
+// Add notEq returns a representation of "a + b"
+func Add(lhs, rhs Serializer) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, "+")
+}
+
+// Sub notEq returns a representation of "a - b"
+func Sub(lhs, rhs Serializer) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, "-")
+}
+
+// Mul returns a representation of "a * b"
+func Mul(lhs, rhs Serializer) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, "*")
+}
+
+// Div returns a representation of "a / b"
+func Div(lhs, rhs Serializer) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, "/")
+}
+
+// Mod returns a representation of "a % b"
+func Mod(lhs, rhs Serializer) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, "%")
+}
+
+// --------------- CASE operator -------------------//
+
+// CaseOperator is interface for SQL case operator
+type CaseOperator interface {
+	Expression
+
+	WHEN(condition Expression) CaseOperator
+	THEN(then Expression) CaseOperator
+	ELSE(els Expression) CaseOperator
+}
+
+type caseOperatorImpl struct {
+	ExpressionInterfaceImpl
+
+	expression Expression
+	when       []Expression
+	then       []Expression
+	els        Expression
+}
+
+// CASE create CASE operator with optional list of expressions
+func CASE(expression ...Expression) CaseOperator {
+	caseExp := &caseOperatorImpl{}
+
+	if len(expression) > 0 {
+		caseExp.expression = expression[0]
+	}
+
+	caseExp.ExpressionInterfaceImpl.Parent = caseExp
+
+	return caseExp
+}
+
+func (c *caseOperatorImpl) WHEN(when Expression) CaseOperator {
+	c.when = append(c.when, when)
+	return c
+}
+
+func (c *caseOperatorImpl) THEN(then Expression) CaseOperator {
+	c.then = append(c.then, then)
+	return c
+}
+
+func (c *caseOperatorImpl) ELSE(els Expression) CaseOperator {
+	c.els = els
+
+	return c
+}
+
+func (c *caseOperatorImpl) serialize(statement StatementType, out *SQLBuilder, options ...SerializeOption) {
+	out.WriteString("(CASE")
+
+	if c.expression != nil {
+		c.expression.serialize(statement, out, FallTrough(options)...)
+	}
+
+	if len(c.when) == 0 || len(c.then) == 0 {
+		panic("jet: invalid case Statement. There should be at least one WHEN/THEN pair. ")
+	}
+
+	if len(c.when) != len(c.then) {
+		panic("jet: WHEN and THEN expression count mismatch. ")
+	}
+
+	for i, when := range c.when {
+		out.WriteString("WHEN")
+		when.serialize(statement, out, NoWrap)
+
+		out.WriteString("THEN")
+		c.then[i].serialize(statement, out, NoWrap)
+	}
+
+	if c.els != nil {
+		out.WriteString("ELSE")
+		c.els.serialize(statement, out, NoWrap)
+	}
+
+	out.WriteString("END)")
+}
+
+// DISTINCT operator can be used to return distinct values of expr
+func DISTINCT(expr Expression) Expression {
+	return newPrefixOperatorExpression(expr, "DISTINCT")
+}
+
+func BinaryOperator(lhs Expression, rhs Expression, operator string) Expression {
+	return NewBinaryOperatorExpression(lhs, rhs, operator)
+}