514 lines
9.8 KiB
Go
514 lines
9.8 KiB
Go
// +build disabled
|
|
|
|
package sqlbuilder
|
|
|
|
import (
|
|
"bytes"
|
|
"time"
|
|
|
|
gc "gopkg.in/check.v1"
|
|
)
|
|
|
|
type ExprSuite struct {
|
|
}
|
|
|
|
var _ = gc.Suite(&ExprSuite{})
|
|
|
|
func (s *ExprSuite) TestConjunctExprEmptyList(c *gc.C) {
|
|
expr := And()
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestConjunctExprNilInList(c *gc.C) {
|
|
expr := And(nil, EqL(table1Col1, 1))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestConjunctExprSingleElement(c *gc.C) {
|
|
expr := And(EqL(table1Col1, 1))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1=1")
|
|
}
|
|
|
|
func (s *ExprSuite) TestLikeExpr(c *gc.C) {
|
|
expr := LikeL(table1Col1, EscapeForLike("%my_prefix")+"%")
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(
|
|
sql,
|
|
gc.Equals,
|
|
"table1.col1 LIKE '\\%my\\_prefix%'")
|
|
|
|
}
|
|
|
|
func (s *ExprSuite) TestRegexExpr(c *gc.C) {
|
|
expr := RegexpL(table1Col1, "[[:<:]]log|[[.low-line.]]log")
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(
|
|
sql,
|
|
gc.Equals,
|
|
"table1.col1 REGEXP '[[:<:]]log|[[.low-line.]]log'")
|
|
|
|
}
|
|
|
|
func (s *ExprSuite) TestAndExpr(c *gc.C) {
|
|
expr := And(EqL(table1Col1, 1), EqL(table1ColFloat, 2), EqL(table1Col3, 3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(
|
|
sql,
|
|
gc.Equals,
|
|
"(table1.col1=1 AND table1.col2=2 AND table1.col3=3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestOrExpr(c *gc.C) {
|
|
expr := Or(EqL(table1Col1, 1), EqL(table1ColFloat, 2), EqL(table1Col3, 3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(
|
|
sql,
|
|
gc.Equals,
|
|
"(table1.col1=1 OR table1.col2=2 OR table1.col3=3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestAddExpr(c *gc.C) {
|
|
expr := Add(literal(1), literal(2), literal(3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "(1 + 2 + 3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestSubExpr(c *gc.C) {
|
|
expr := Sub(literal(1), literal(2), literal(3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "(1 - 2 - 3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestMulExpr(c *gc.C) {
|
|
expr := Mul(literal(1), literal(2), literal(3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "(1 * 2 * 3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestDivExpr(c *gc.C) {
|
|
expr := Div(literal(1), literal(2), literal(3))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "(1 / 2 / 3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestBinaryExprNilLHS(c *gc.C) {
|
|
expr := GT(nil, table1Col1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestNegateExpr(c *gc.C) {
|
|
expr := NOT(EqL(table1Col1, 123))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "NOT (table1.col1=123)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestBinaryExprNilRHS(c *gc.C) {
|
|
expr := LT(table1Col1, nil)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestEqExpr(c *gc.C) {
|
|
expr := EqL(table1Col1, 321)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1=321")
|
|
}
|
|
|
|
func (s *ExprSuite) TestEqExprNilLHS(c *gc.C) {
|
|
expr := EqL(table1Col1, nil)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1 IS null")
|
|
}
|
|
|
|
func (s *ExprSuite) TestNeqExpr(c *gc.C) {
|
|
expr := NeqL(table1Col1, 123)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1!=123")
|
|
}
|
|
|
|
func (s *ExprSuite) TestNeqExprNilLHS(c *gc.C) {
|
|
expr := NeqL(table1Col1, nil)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1 IS NOT null")
|
|
}
|
|
|
|
func (s *ExprSuite) TestLtExpr(c *gc.C) {
|
|
expr := LtL(table1Col1, -1.5)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1<-1.5")
|
|
}
|
|
|
|
func (s *ExprSuite) TestLteExpr(c *gc.C) {
|
|
expr := LteL(table1Col1, "foo\"';drop user tableName;")
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(
|
|
sql,
|
|
gc.Equals,
|
|
"table1.col1<='foo\\\"\\';drop user tableName;'")
|
|
}
|
|
|
|
func (s *ExprSuite) TestGtExpr(c *gc.C) {
|
|
expr := GtL(table1Col1, 1.1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1>1.1")
|
|
}
|
|
|
|
func (s *ExprSuite) TestGteExpr(c *gc.C) {
|
|
expr := GteL(table1Col1, 1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.serialize(0, buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1>=1")
|
|
}
|
|
|
|
func (s *ExprSuite) TestInExpr(c *gc.C) {
|
|
values := []int32{1, 2, 3}
|
|
expr := In(table1Col1, values)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1 IN (1,2,3)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestInExprEmptyList(c *gc.C) {
|
|
values := []int32{}
|
|
expr := In(table1Col1, values)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "FALSE")
|
|
}
|
|
|
|
func (s *ExprSuite) TestSqlFuncExprNilInArgList(c *gc.C) {
|
|
expr := SqlFunc("rand", nil)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestSqlFuncExprEmptyArgList(c *gc.C) {
|
|
expr := SqlFunc("rand")
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "rand()")
|
|
}
|
|
|
|
func (s *ExprSuite) TestSqlFuncExprNonEmptyArgList(c *gc.C) {
|
|
expr := SqlFunc("add", table1Col1, table1ColFloat)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := expr.Serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "add(table1.col1,table1.col2)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestOrderByClauseNilExpr(c *gc.C) {
|
|
clause := ASC(nil)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.serialize(buf)
|
|
c.Assert(err, gc.NotNil)
|
|
}
|
|
|
|
func (s *ExprSuite) TestAsc(c *gc.C) {
|
|
clause := ASC(table1Col1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1 ASC")
|
|
}
|
|
|
|
func (s *ExprSuite) TestDesc(c *gc.C) {
|
|
clause := DESC(table1Col1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.serialize(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "table1.col1 DESC")
|
|
}
|
|
|
|
func (s *ExprSuite) TestColumnValue(c *gc.C) {
|
|
clause := ColumnValue(table1Col1)
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "VALUES(table1.col1)")
|
|
}
|
|
|
|
func (s *ExprSuite) TestBitwiseOr(c *gc.C) {
|
|
clause := BitOr(literal(1), literal(2))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "1 | 2")
|
|
}
|
|
|
|
func (s *ExprSuite) TestBitwiseAnd(c *gc.C) {
|
|
clause := BitAnd(literal(1), literal(2))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "1 & 2")
|
|
}
|
|
|
|
func (s *ExprSuite) TestBitwiseXor(c *gc.C) {
|
|
clause := BitXor(literal(1), literal(2))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "1 ^ 2")
|
|
}
|
|
|
|
func (s *ExprSuite) TestPlus(c *gc.C) {
|
|
clause := Plus(literal(1), literal(2))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "1 + 2")
|
|
}
|
|
|
|
func (s *ExprSuite) TestMinus(c *gc.C) {
|
|
clause := Minus(literal(1), literal(2))
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
err := clause.SerializeSql(buf)
|
|
c.Assert(err, gc.IsNil)
|
|
|
|
sql := buf.String()
|
|
c.Assert(sql, gc.Equals, "1 - 2")
|
|
}
|
|
|
|
func (s *ExprSuite) TestInterval(c *gc.C) {
|
|
testTable := []struct {
|
|
interval time.Duration
|
|
expected string
|
|
expectedErr error
|
|
}{
|
|
{
|
|
interval: 50 * time.Microsecond,
|
|
expected: "INTERVAL '0:0:0:50' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: -50 * time.Microsecond,
|
|
expected: "INTERVAL '-0:0:0:50' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50*time.Microsecond + 50*time.Second,
|
|
expected: "INTERVAL '0:0:50:50' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50*time.Microsecond +
|
|
50*time.Second +
|
|
50*time.Minute,
|
|
expected: "INTERVAL '0:50:50:50' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50*time.Microsecond +
|
|
50*time.Second +
|
|
50*time.Minute +
|
|
50*time.Hour,
|
|
expected: "INTERVAL '50:50:50:50' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50 * time.Hour,
|
|
expected: "INTERVAL '50:0:0:0' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50*time.Hour + 50*time.Minute,
|
|
expected: "INTERVAL '50:50:0:0' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50*time.Hour + 50*time.Minute + 50*time.Second,
|
|
expected: "INTERVAL '50:50:50:0' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 0,
|
|
expected: "INTERVAL '0:0:0:0' HOUR_MICROSECOND",
|
|
},
|
|
{
|
|
interval: 50 * time.Nanosecond,
|
|
expected: "INTERVAL '0:0:0:0' HOUR_MICROSECOND",
|
|
},
|
|
}
|
|
buf := &bytes.Buffer{}
|
|
|
|
for i, tt := range testTable {
|
|
buf.Reset()
|
|
err := Interval(tt.interval).Serialize(buf)
|
|
c.Assert(err, gc.Equals, tt.expectedErr,
|
|
gc.Commentf("experiment #%d", i))
|
|
if err == nil {
|
|
c.Assert(buf.String(), gc.Equals, tt.expected,
|
|
gc.Commentf("experiment #%d", i))
|
|
}
|
|
}
|
|
}
|