scriptoriumadmin/featurebase
1
0
Fork 0
mirror of https://github.com/featurebasedb/featurebase.git synced 2026-08-28 10:54:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
featurebase/sql3/sql_defs_binops_test.go
pokeeffe-molecula ae3910a22b Test expression eval for tuple values in inserts (fb-1555) (#2270) 
refactored comparison, equality and arithmetic expr eval for decimal data types and added a test to cover expression eval for inserts

fixed failing test

(cherry picked from commit 193ef7cba1)
2022-11-15 11:31:13 -08:00

7923 lines
158 KiB
Go
Raw Blame History

package sql3_test
import (
"time"
"github.com/molecula/featurebase/v3/pql"
)
// INT bin op tests
var binOpExprWithIntInt = tableTest{
table: tbl(
"binoptesti_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
),
srcRows(
srcRow(int64(1), int64(10), int64(20)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >= b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a < b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a > b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a & b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a | b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a << b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(10485760)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >> b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a + b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a - b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(-10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a * b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(200)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a / b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a % b from binoptesti_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a || b from binoptesti_i;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntBool = tableTest{
table: tbl(
"binoptesti_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("b", fldTypeBool),
),
srcRows(
srcRow(int64(1), int64(10), bool(true)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_b;",
),
expErr: "types 'INT' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_b;",
),
expErr: "types 'INT' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_b;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptesti_b;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptesti_b;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptesti_b;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptesti_b;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptesti_b;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptesti_b;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptesti_b;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptesti_b;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptesti_b;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptesti_b;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptesti_b;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptesti_b;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptesti_b;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntID = tableTest{
table: tbl(
"binoptesti_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
),
srcRows(
srcRow(int64(10), int64(20)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select b != _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b = _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b <= _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b >= _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b < _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b > _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b & _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b | _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b << _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(20480)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b >> _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b + _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b - _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b * _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(200)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b / _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b % _id from binoptesti_id;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select b || _id from binoptesti_id;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntDecimal = tableTest{
table: tbl(
"binoptesti_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), int64(20), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >= d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a < d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a > d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a & d from binoptesti_d;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | d from binoptesti_d;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << d from binoptesti_d;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> d from binoptesti_d;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(3234, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a - d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(766, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a * d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(24680, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a / d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(162, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a % d from binoptesti_d;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || d from binoptesti_d;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntTimestamp = tableTest{
table: tbl(
"binoptesti_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), int64(20), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a >= ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a < ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a > ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a & ts from binoptesti_ts;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | ts from binoptesti_ts;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << ts from binoptesti_ts;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> ts from binoptesti_ts;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + ts from binoptesti_ts;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - ts from binoptesti_ts;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * ts from binoptesti_ts;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / ts from binoptesti_ts;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % ts from binoptesti_ts;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || ts from binoptesti_ts;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntIDSet = tableTest{
table: tbl(
"binoptesti_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), int64(20), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_ids;",
),
expErr: "types 'INT' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_ids;",
),
expErr: "types 'INT' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_ids;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptesti_ids;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptesti_ids;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptesti_ids;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptesti_ids;",
),
expErr: " operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | b from binoptesti_ids;",
),
expErr: " operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << b from binoptesti_ids;",
),
expErr: " operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> b from binoptesti_ids;",
),
expErr: " operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + b from binoptesti_ids;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptesti_ids;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptesti_ids;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptesti_ids;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptesti_ids;",
),
expErr: " operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || b from binoptesti_ids;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntString = tableTest{
table: tbl(
"binoptesti_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), int64(20), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_s;",
),
expErr: "types 'INT' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_s;",
),
expErr: "types 'INT' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_s;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptesti_s;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptesti_s;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptesti_s;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptesti_s;",
),
expErr: " operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | b from binoptesti_s;",
),
expErr: " operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << b from binoptesti_s;",
),
expErr: " operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> b from binoptesti_s;",
),
expErr: " operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + b from binoptesti_s;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptesti_s;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptesti_s;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptesti_s;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptesti_s;",
),
expErr: " operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || b from binoptesti_s;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIntStringSet = tableTest{
table: tbl(
"binoptesti_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeInt, "min 0", "max 1000"),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), int64(20), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_ss;",
),
expErr: "types 'INT' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_ss;",
),
expErr: "types 'INT' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_ss;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptesti_ss;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptesti_ss;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptesti_ss;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptesti_ss;",
),
expErr: " operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | b from binoptesti_ss;",
),
expErr: " operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << b from binoptesti_ss;",
),
expErr: " operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> b from binoptesti_ss;",
),
expErr: " operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + b from binoptesti_ss;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptesti_ss;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptesti_ss;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptesti_ss;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptesti_ss;",
),
expErr: " operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || b from binoptesti_ss;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
// BOOL bin op tests
var binOpExprWithBoolInt = tableTest{
table: tbl(
"binoptestb_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
),
srcRows(
srcRow(int64(1), bool(true), int64(20)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestb_i;",
),
expErr: "types 'BOOL' and 'INT' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestb_i;",
),
expErr: "types 'BOOL' and 'INT' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestb_i;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptestb_i;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptestb_i;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptestb_i;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptestb_i;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptestb_i;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptestb_i;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptestb_i;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptestb_i;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptestb_i;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptestb_i;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptestb_i;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptestb_i;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptestb_i;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolBool = tableTest{
table: tbl(
"binoptestb_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("b", fldTypeBool),
),
srcRows(
srcRow(int64(1), bool(true), bool(true)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestb_b;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = b from binoptestb_b;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= b from binoptestb_b;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptestb_b;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptestb_b;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptestb_b;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptestb_b;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptestb_b;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptestb_b;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptestb_b;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptestb_b;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptestb_b;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptestb_b;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptestb_b;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptestb_b;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptestb_b;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolID = tableTest{
table: tbl(
"binoptestb_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
),
srcRows(
srcRow(int64(10), bool(true)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select b != _id from binoptestb_id;",
),
expErr: "types 'BOOL' and 'ID' are not equatable",
},
{
sqls: sqls(
"select b = _id from binoptestb_id;",
),
expErr: "types 'BOOL' and 'ID' are not equatable",
},
{
sqls: sqls(
"select b <= _id from binoptestb_id;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b >= _id from binoptestb_id;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b < _id from binoptestb_id;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b > _id from binoptestb_id;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b & _id from binoptestb_id;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b | _id from binoptestb_id;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b << _id from binoptestb_id;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b >> _id from binoptestb_id;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b + _id from binoptestb_id;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b - _id from binoptestb_id;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b * _id from binoptestb_id;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b / _id from binoptestb_id;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b % _id from binoptestb_id;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select b || _id from binoptestb_id;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolDecimal = tableTest{
table: tbl(
"binoptestb_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), bool(true), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptestb_d;",
),
expErr: "types 'BOOL' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a = d from binoptestb_d;",
),
expErr: "types 'BOOL' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a <= d from binoptestb_d;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= d from binoptestb_d;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < d from binoptestb_d;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > d from binoptestb_d;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & d from binoptestb_d;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | d from binoptestb_d;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << d from binoptestb_d;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> d from binoptestb_d;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + d from binoptestb_d;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - d from binoptestb_d;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * d from binoptestb_d;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / d from binoptestb_d;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % d from binoptestb_d;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || d from binoptestb_d;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolTimestamp = tableTest{
table: tbl(
"binoptestb_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), bool(true), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptestb_ts;",
),
expErr: "types 'BOOL' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptestb_ts;",
),
expErr: "types 'BOOL' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptestb_ts;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= ts from binoptestb_ts;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < ts from binoptestb_ts;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > ts from binoptestb_ts;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & ts from binoptestb_ts;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | ts from binoptestb_ts;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << ts from binoptestb_ts;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> ts from binoptestb_ts;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + ts from binoptestb_ts;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - ts from binoptestb_ts;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * ts from binoptestb_ts;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / ts from binoptestb_ts;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % ts from binoptestb_ts;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || ts from binoptestb_ts;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolIDSet = tableTest{
table: tbl(
"binoptestb_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), bool(true), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestb_ids;",
),
expErr: "types 'BOOL' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestb_ids;",
),
expErr: "types 'BOOL' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestb_ids;",
),
expErr: " operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptestb_ids;",
),
expErr: " operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptestb_ids;",
),
expErr: " operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptestb_ids;",
),
expErr: " operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptestb_ids;",
),
expErr: " operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptestb_ids;",
),
expErr: " operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptestb_ids;",
),
expErr: " operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptestb_ids;",
),
expErr: " operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptestb_ids;",
),
expErr: " operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptestb_ids;",
),
expErr: " operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptestb_ids;",
),
expErr: " operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptestb_ids;",
),
expErr: " operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptestb_ids;",
),
expErr: " operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptestb_ids;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolString = tableTest{
table: tbl(
"binoptestb_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), bool(true), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestb_s;",
),
expErr: "types 'BOOL' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestb_s;",
),
expErr: "types 'BOOL' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestb_s;",
),
expErr: " operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptestb_s;",
),
expErr: " operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptestb_s;",
),
expErr: " operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptestb_s;",
),
expErr: " operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptestb_s;",
),
expErr: " operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptestb_s;",
),
expErr: " operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptestb_s;",
),
expErr: " operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptestb_s;",
),
expErr: " operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptestb_s;",
),
expErr: " operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptestb_s;",
),
expErr: " operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptestb_s;",
),
expErr: " operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptestb_s;",
),
expErr: " operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptestb_s;",
),
expErr: " operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptestb_s;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithBoolStringSet = tableTest{
table: tbl(
"binoptestb_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeBool),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), bool(true), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestb_ss;",
),
expErr: "types 'BOOL' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestb_ss;",
),
expErr: "types 'BOOL' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestb_ss;",
),
expErr: " operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >= b from binoptestb_ss;",
),
expErr: " operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a < b from binoptestb_ss;",
),
expErr: " operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a > b from binoptestb_ss;",
),
expErr: " operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a & b from binoptestb_ss;",
),
expErr: " operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a | b from binoptestb_ss;",
),
expErr: " operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a << b from binoptestb_ss;",
),
expErr: " operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a >> b from binoptestb_ss;",
),
expErr: " operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a + b from binoptestb_ss;",
),
expErr: " operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a - b from binoptestb_ss;",
),
expErr: " operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a * b from binoptestb_ss;",
),
expErr: " operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a / b from binoptestb_ss;",
),
expErr: " operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a % b from binoptestb_ss;",
),
expErr: " operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select a || b from binoptestb_ss;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
// ID bin op tests
var binOpExprWithIDInt = tableTest{
table: tbl(
"binoptestid_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
),
srcRows(
srcRow(int64(10), int64(20)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select _id != b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id = b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id <= b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id >= b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id < b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id > b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id & b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id | b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id << b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(10485760)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id >> b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id + b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id - b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(-10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id * b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(200)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id / b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id % b from binoptestid_i;",
),
expHdrs: hdrs(
hdr("", fldTypeInt),
),
expRows: rows(
row(int64(10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id || b from binoptestid_i;",
),
expErr: "operator '||' incompatible with type 'ID'",
},
},
}
var binOpExprWithIDBool = tableTest{
table: tbl(
"binoptestid_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
),
srcRows(
srcRow(int64(10), bool(true)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select _id != b from binoptestid_b;",
),
expErr: "types 'ID' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select _id = b from binoptestid_b;",
),
expErr: "types 'ID' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select _id <= b from binoptestid_b;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id >= b from binoptestid_b;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id < b from binoptestid_b;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id > b from binoptestid_b;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id & b from binoptestid_b;",
),
expErr: "operator '&' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id | b from binoptestid_b;",
),
expErr: "operator '|' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id << b from binoptestid_b;",
),
expErr: "operator '<<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id >> b from binoptestid_b;",
),
expErr: "operator '>>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id + b from binoptestid_b;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id - b from binoptestid_b;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id * b from binoptestid_b;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id / b from binoptestid_b;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id % b from binoptestid_b;",
),
expErr: "operator '%' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select _id || b from binoptestid_b;",
),
expErr: "operator '||' incompatible with type 'ID'",
},
},
}
var binOpExprWithIDID = tableTest{
table: tbl(
"binoptestid_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
),
srcRows(
srcRow(int64(10), int64(20)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select _id != b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id = b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id <= b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id >= b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id < b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id > b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id & b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id | b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id << b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(10485760)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id >> b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id + b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(30)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id - b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(-10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id * b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(200)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id / b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(0)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id % b from binoptestid_id;",
),
expHdrs: hdrs(
hdr("", fldTypeID),
),
expRows: rows(
row(int64(10)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select _id || b from binoptestid_id;",
),
expErr: "operator '||' incompatible with type 'ID'",
},
},
}
var binOpExprWithIDDecimal = tableTest{
table: tbl(
"binoptestid_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeID),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), int64(20), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >= d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a < d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a > d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a & d from binoptesti_d;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | d from binoptesti_d;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << d from binoptesti_d;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> d from binoptesti_d;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(3234, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a - d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(766, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a * d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(24680, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a / d from binoptesti_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(162, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a % d from binoptesti_d;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || d from binoptesti_d;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIDTimestamp = tableTest{
table: tbl(
"binoptestid_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeID),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), int64(20), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a >= ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a < ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a > ts from binoptesti_ts;",
),
expErr: "types 'INT' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a & ts from binoptesti_ts;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | ts from binoptesti_ts;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << ts from binoptesti_ts;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> ts from binoptesti_ts;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + ts from binoptesti_ts;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - ts from binoptesti_ts;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * ts from binoptesti_ts;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / ts from binoptesti_ts;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % ts from binoptesti_ts;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || ts from binoptesti_ts;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIDIDSet = tableTest{
table: tbl(
"binoptestid_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeID),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), int64(20), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_ids;",
),
expErr: "types 'INT' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_ids;",
),
expErr: "types 'INT' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_ids;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptesti_ids;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptesti_ids;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptesti_ids;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptesti_ids;",
),
expErr: " operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | b from binoptesti_ids;",
),
expErr: " operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << b from binoptesti_ids;",
),
expErr: " operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> b from binoptesti_ids;",
),
expErr: " operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + b from binoptesti_ids;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptesti_ids;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptesti_ids;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptesti_ids;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptesti_ids;",
),
expErr: " operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || b from binoptesti_ids;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIDString = tableTest{
table: tbl(
"binoptestid_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeID),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), int64(20), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_s;",
),
expErr: "types 'INT' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_s;",
),
expErr: "types 'INT' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_s;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptesti_s;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptesti_s;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptesti_s;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptesti_s;",
),
expErr: " operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | b from binoptesti_s;",
),
expErr: " operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << b from binoptesti_s;",
),
expErr: " operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> b from binoptesti_s;",
),
expErr: " operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + b from binoptesti_s;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptesti_s;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptesti_s;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptesti_s;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptesti_s;",
),
expErr: " operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || b from binoptesti_s;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithIDStringSet = tableTest{
table: tbl(
"binoptestid_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeID),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), int64(20), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptesti_ss;",
),
expErr: "types 'INT' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptesti_ss;",
),
expErr: "types 'INT' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptesti_ss;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptesti_ss;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptesti_ss;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptesti_ss;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptesti_ss;",
),
expErr: " operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | b from binoptesti_ss;",
),
expErr: " operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << b from binoptesti_ss;",
),
expErr: " operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> b from binoptesti_ss;",
),
expErr: " operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + b from binoptesti_ss;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptesti_ss;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptesti_ss;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptesti_ss;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptesti_ss;",
),
expErr: " operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || b from binoptesti_ss;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
// DECIMAL bin op tests
var binOpExprWithDecInt = tableTest{
table: tbl(
"binoptestdec_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(10), int64(20), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d = b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d <= b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d >= b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d < b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d > b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d & b from binoptestdec_i;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d | b from binoptestdec_i;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d << b from binoptestdec_i;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d >> b from binoptestdec_i;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d + b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(3234, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d - b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(-766, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d * b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(24680, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d / b from binoptestdec_i;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(61, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d % b from binoptestdec_i;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d || b from binoptestdec_i;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecBool = tableTest{
table: tbl(
"binoptestdec_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(10), bool(true), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestdec_b;",
),
expErr: "types 'DECIMAL(2)' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestdec_b;",
),
expErr: "types 'DECIMAL(2)' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestdec_b;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d >= b from binoptestdec_b;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d < b from binoptestdec_b;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d > b from binoptestdec_b;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d & b from binoptestdec_b;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d | b from binoptestdec_b;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d << b from binoptestdec_b;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d >> b from binoptestdec_b;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d + b from binoptestdec_b;",
),
expErr: "operator '+' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d - b from binoptestdec_b;",
),
expErr: "operator '-' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d * b from binoptestdec_b;",
),
expErr: "operator '*' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d / b from binoptestdec_b;",
),
expErr: "operator '/' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d % b from binoptestdec_b;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d || b from binoptestdec_b;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecID = tableTest{
table: tbl(
"binoptestdec_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(10), int64(20), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d = b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d <= b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d >= b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d < b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d > b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d & b from binoptestdec_id;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d | b from binoptestdec_id;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d << b from binoptestdec_id;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d >> b from binoptestdec_id;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d + b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(3234, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d - b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(-766, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d * b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(24680, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d / b from binoptestdec_id;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(61, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select d % b from binoptestdec_id;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select d || b from binoptestdec_id;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecDecimal = tableTest{
table: tbl(
"binoptestdec_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeDecimal2),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), float64(20.00), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >= d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a < d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a > d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a & d from binoptestdec_d;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | d from binoptestdec_d;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << d from binoptestdec_d;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> d from binoptestdec_d;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(3234, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a - d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(766, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a * d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(24680, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a / d from binoptestdec_d;",
),
expHdrs: hdrs(
hdr("", fldTypeDecimal2),
),
expRows: rows(
row(pql.NewDecimal(162, 2)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a % d from binoptestdec_d;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || d from binoptestdec_d;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecTimestamp = tableTest{
table: tbl(
"binoptestdec_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeDecimal2),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), float64(20.00), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a >= ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a < ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a > ts from binoptestdec_ts;",
),
expErr: "types 'DECIMAL(2)' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a & ts from binoptestdec_ts;",
),
expErr: "operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | ts from binoptestdec_ts;",
),
expErr: "operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << ts from binoptestdec_ts;",
),
expErr: "operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> ts from binoptestdec_ts;",
),
expErr: "operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + ts from binoptestdec_ts;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - ts from binoptestdec_ts;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * ts from binoptestdec_ts;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / ts from binoptestdec_ts;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % ts from binoptestdec_ts;",
),
expErr: "operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || ts from binoptestdec_ts;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecIDSet = tableTest{
table: tbl(
"binoptestdec_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeDecimal2),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), float64(20.00), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestdec_ids;",
),
expErr: "types 'DECIMAL(2)' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestdec_ids;",
),
expErr: "types 'DECIMAL(2)' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestdec_ids;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptestdec_ids;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptestdec_ids;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptestdec_ids;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptestdec_ids;",
),
expErr: " operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | b from binoptestdec_ids;",
),
expErr: " operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << b from binoptestdec_ids;",
),
expErr: " operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> b from binoptestdec_ids;",
),
expErr: " operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + b from binoptestdec_ids;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptestdec_ids;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptestdec_ids;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptestdec_ids;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptestdec_ids;",
),
expErr: " operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || b from binoptestdec_ids;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecString = tableTest{
table: tbl(
"binoptestdec_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeDecimal2),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), float64(20.00), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestdec_s;",
),
expErr: "types 'DECIMAL(2)' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestdec_s;",
),
expErr: "types 'DECIMAL(2)' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestdec_s;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptestdec_s;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptestdec_s;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptestdec_s;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptestdec_s;",
),
expErr: " operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | b from binoptestdec_s;",
),
expErr: " operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << b from binoptestdec_s;",
),
expErr: " operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> b from binoptestdec_s;",
),
expErr: " operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + b from binoptestdec_s;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptestdec_s;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptestdec_s;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptestdec_s;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptestdec_s;",
),
expErr: " operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || b from binoptestdec_s;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithDecStringSet = tableTest{
table: tbl(
"binoptestdec_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeDecimal2),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), float64(20.00), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestdec_ss;",
),
expErr: "types 'DECIMAL(2)' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestdec_ss;",
),
expErr: "types 'DECIMAL(2)' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestdec_ss;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptestdec_ss;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptestdec_ss;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptestdec_ss;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptestdec_ss;",
),
expErr: " operator '&' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a | b from binoptestdec_ss;",
),
expErr: " operator '|' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a << b from binoptestdec_ss;",
),
expErr: " operator '<<' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a >> b from binoptestdec_ss;",
),
expErr: " operator '>>' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a + b from binoptestdec_ss;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptestdec_ss;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptestdec_ss;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptestdec_ss;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptestdec_ss;",
),
expErr: " operator '%' incompatible with type 'DECIMAL(2)'",
},
{
sqls: sqls(
"select a || b from binoptestdec_ss;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
// TIMESTAMP bin op tests
var binOpExprWithTSInt = tableTest{
table: tbl(
"binoptestts_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt, "min 0", "max 1000"),
srcHdr("d", fldTypeTimestamp),
),
srcRows(
srcRow(int64(10), int64(20), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d >= b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d < b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d > b from binoptestts_i;",
),
expErr: "types 'TIMESTAMP' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d & b from binoptestts_i;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d | b from binoptestts_i;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d << b from binoptestts_i;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d >> b from binoptestts_i;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d + b from binoptestts_i;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d - b from binoptestts_i;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d * b from binoptestts_i;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d / b from binoptestts_i;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d % b from binoptestts_i;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d || b from binoptestts_i;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSBool = tableTest{
table: tbl(
"binoptestts_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
srcHdr("d", fldTypeTimestamp),
),
srcRows(
srcRow(int64(10), bool(true), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestts_b;",
),
expErr: "types 'TIMESTAMP' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestts_b;",
),
expErr: "types 'TIMESTAMP' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestts_b;",
),
expErr: "operator '<=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d >= b from binoptestts_b;",
),
expErr: "operator '>=' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d < b from binoptestts_b;",
),
expErr: "operator '<' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d > b from binoptestts_b;",
),
expErr: "operator '>' incompatible with type 'BOOL'",
},
{
sqls: sqls(
"select d & b from binoptestts_b;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d | b from binoptestts_b;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d << b from binoptestts_b;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d >> b from binoptestts_b;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d + b from binoptestts_b;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d - b from binoptestts_b;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d * b from binoptestts_b;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d / b from binoptestts_b;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d % b from binoptestts_b;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d || b from binoptestts_b;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSID = tableTest{
table: tbl(
"binoptestts_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
srcHdr("d", fldTypeTimestamp),
),
srcRows(
srcRow(int64(10), int64(20), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d >= b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d < b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d > b from binoptestts_id;",
),
expErr: "types 'TIMESTAMP' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d & b from binoptestts_id;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d | b from binoptestts_id;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d << b from binoptestts_id;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d >> b from binoptestts_id;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d + b from binoptestts_id;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d - b from binoptestts_id;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d * b from binoptestts_id;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d / b from binoptestts_id;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d % b from binoptestts_id;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select d || b from binoptestts_id;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSDecimal = tableTest{
table: tbl(
"binoptestts_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeTimestamp),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), time.Time(knownTimestamp()), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a = d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a <= d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a >= d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a < d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a > d from binoptestts_d;",
),
expErr: "types 'TIMESTAMP' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a & d from binoptestts_d;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | d from binoptestts_d;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << d from binoptestts_d;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> d from binoptestts_d;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + d from binoptestts_d;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - d from binoptestts_d;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * d from binoptestts_d;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / d from binoptestts_d;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % d from binoptestts_d;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || d from binoptestts_d;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSTimestamp = tableTest{
table: tbl(
"binoptestts_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeTimestamp),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), time.Time(knownTimestamp()), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered},
{
sqls: sqls(
"select a = ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered},
{
sqls: sqls(
"select a <= ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a >= ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered},
{
sqls: sqls(
"select a < ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered},
{
sqls: sqls(
"select a > ts from binoptestts_ts;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered},
{
sqls: sqls(
"select a & ts from binoptestts_ts;",
),
expErr: "operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | ts from binoptestts_ts;",
),
expErr: "operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << ts from binoptestts_ts;",
),
expErr: "operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> ts from binoptestts_ts;",
),
expErr: "operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + ts from binoptestts_ts;",
),
expErr: "operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - ts from binoptestts_ts;",
),
expErr: "operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * ts from binoptestts_ts;",
),
expErr: "operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / ts from binoptestts_ts;",
),
expErr: "operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % ts from binoptestts_ts;",
),
expErr: "operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || ts from binoptestts_ts;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSIDSet = tableTest{
table: tbl(
"binoptestts_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeTimestamp),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), time.Time(knownTimestamp()), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestts_ids;",
),
expErr: "types 'TIMESTAMP' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestts_ids;",
),
expErr: "types 'TIMESTAMP' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestts_ids;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptestts_ids;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptestts_ids;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptestts_ids;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptestts_ids;",
),
expErr: " operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | b from binoptestts_ids;",
),
expErr: " operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << b from binoptestts_ids;",
),
expErr: " operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> b from binoptestts_ids;",
),
expErr: " operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + b from binoptestts_ids;",
),
expErr: " operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - b from binoptestts_ids;",
),
expErr: " operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * b from binoptestts_ids;",
),
expErr: " operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / b from binoptestts_ids;",
),
expErr: " operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % b from binoptestts_ids;",
),
expErr: " operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || b from binoptestts_ids;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSString = tableTest{
table: tbl(
"binoptestts_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeTimestamp),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), time.Time(knownTimestamp()), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestts_s;",
),
expErr: "types 'TIMESTAMP' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestts_s;",
),
expErr: "types 'TIMESTAMP' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestts_s;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptestts_s;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptestts_s;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptestts_s;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptestts_s;",
),
expErr: " operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | b from binoptestts_s;",
),
expErr: " operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << b from binoptestts_s;",
),
expErr: " operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> b from binoptestts_s;",
),
expErr: " operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + b from binoptestts_s;",
),
expErr: " operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - b from binoptestts_s;",
),
expErr: " operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * b from binoptestts_s;",
),
expErr: " operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / b from binoptestts_s;",
),
expErr: " operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % b from binoptestts_s;",
),
expErr: " operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || b from binoptestts_s;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithTSStringSet = tableTest{
table: tbl(
"binoptestts_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeTimestamp),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), time.Time(knownTimestamp()), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestts_ss;",
),
expErr: "types 'TIMESTAMP' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestts_ss;",
),
expErr: "types 'TIMESTAMP' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestts_ss;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptestts_ss;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptestts_ss;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptestts_ss;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptestts_ss;",
),
expErr: " operator '&' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a | b from binoptestts_ss;",
),
expErr: " operator '|' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a << b from binoptestts_ss;",
),
expErr: " operator '<<' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a >> b from binoptestts_ss;",
),
expErr: " operator '>>' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a + b from binoptestts_ss;",
),
expErr: " operator '+' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a - b from binoptestts_ss;",
),
expErr: " operator '-' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a * b from binoptestts_ss;",
),
expErr: " operator '*' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a / b from binoptestts_ss;",
),
expErr: " operator '/' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a % b from binoptestts_ss;",
),
expErr: " operator '%' incompatible with type 'TIMESTAMP'",
},
{
sqls: sqls(
"select a || b from binoptestts_ss;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
// IDSET bin op tests
var binOpExprWithIDSetInt = tableTest{
table: tbl(
"binoptestids_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt),
srcHdr("d", fldTypeIDSet),
),
srcRows(
srcRow(int64(10), int64(20), []int64{20, 21}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestids_i;",
),
expErr: "types 'IDSET' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestids_i;",
),
expErr: "types 'IDSET' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestids_i;",
),
expErr: "operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >= b from binoptestids_i;",
),
expErr: "operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d < b from binoptestids_i;",
),
expErr: "operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d > b from binoptestids_i;",
),
expErr: "operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d & b from binoptestids_i;",
),
expErr: "operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d | b from binoptestids_i;",
),
expErr: "operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d << b from binoptestids_i;",
),
expErr: "operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >> b from binoptestids_i;",
),
expErr: "operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d + b from binoptestids_i;",
),
expErr: "operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d - b from binoptestids_i;",
),
expErr: "operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d * b from binoptestids_i;",
),
expErr: "operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d / b from binoptestids_i;",
),
expErr: "operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d % b from binoptestids_i;",
),
expErr: "operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d || b from binoptestids_i;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetBool = tableTest{
table: tbl(
"binoptestids_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
srcHdr("d", fldTypeIDSet),
),
srcRows(
srcRow(int64(10), bool(true), []int64{20, 21}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestids_b;",
),
expErr: "types 'IDSET' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestids_b;",
),
expErr: "types 'IDSET' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestids_b;",
),
expErr: "operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >= b from binoptestids_b;",
),
expErr: "operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d < b from binoptestids_b;",
),
expErr: "operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d > b from binoptestids_b;",
),
expErr: "operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d & b from binoptestids_b;",
),
expErr: "operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d | b from binoptestids_b;",
),
expErr: "operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d << b from binoptestids_b;",
),
expErr: "operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >> b from binoptestids_b;",
),
expErr: "operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d + b from binoptestids_b;",
),
expErr: "operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d - b from binoptestids_b;",
),
expErr: "operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d * b from binoptestids_b;",
),
expErr: "operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d / b from binoptestids_b;",
),
expErr: "operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d % b from binoptestids_b;",
),
expErr: "operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d || b from binoptestids_b;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetID = tableTest{
table: tbl(
"binoptestids_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
srcHdr("d", fldTypeIDSet),
),
srcRows(
srcRow(int64(10), int64(20), []int64{20, 21}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestids_id;",
),
expErr: "types 'IDSET' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestids_id;",
),
expErr: "types 'IDSET' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestids_id;",
),
expErr: "operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >= b from binoptestids_id;",
),
expErr: "operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d < b from binoptestids_id;",
),
expErr: "operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d > b from binoptestids_id;",
),
expErr: "operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d & b from binoptestids_id;",
),
expErr: "operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d | b from binoptestids_id;",
),
expErr: "operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d << b from binoptestids_id;",
),
expErr: "operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d >> b from binoptestids_id;",
),
expErr: "operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d + b from binoptestids_id;",
),
expErr: "operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d - b from binoptestids_id;",
),
expErr: "operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d * b from binoptestids_id;",
),
expErr: "operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d / b from binoptestids_id;",
),
expErr: "operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d % b from binoptestids_id;",
),
expErr: "operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select d || b from binoptestids_id;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetDecimal = tableTest{
table: tbl(
"binoptestids_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeIDSet),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), []int64{20, 21}, float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptestids_d;",
),
expErr: "types 'IDSET' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a = d from binoptestids_d;",
),
expErr: "types 'IDSET' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a <= d from binoptestids_d;",
),
expErr: "operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= d from binoptestids_d;",
),
expErr: "operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < d from binoptestids_d;",
),
expErr: "operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > d from binoptestids_d;",
),
expErr: "operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & d from binoptestids_d;",
),
expErr: "operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | d from binoptestids_d;",
),
expErr: "operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << d from binoptestids_d;",
),
expErr: "operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> d from binoptestids_d;",
),
expErr: "operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + d from binoptestids_d;",
),
expErr: "operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - d from binoptestids_d;",
),
expErr: "operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * d from binoptestids_d;",
),
expErr: "operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / d from binoptestids_d;",
),
expErr: "operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % d from binoptestids_d;",
),
expErr: "operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || d from binoptestids_d;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetTimestamp = tableTest{
table: tbl(
"binoptestids_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeIDSet),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), []int64{20, 21}, time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptestids_ts;",
),
expErr: "types 'IDSET' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptestids_ts;",
),
expErr: "types 'IDSET' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptestids_ts;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= ts from binoptestids_ts;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < ts from binoptestids_ts;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > ts from binoptestids_ts;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & ts from binoptestids_ts;",
),
expErr: "operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | ts from binoptestids_ts;",
),
expErr: "operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << ts from binoptestids_ts;",
),
expErr: "operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> ts from binoptestids_ts;",
),
expErr: "operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + ts from binoptestids_ts;",
),
expErr: "operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - ts from binoptestids_ts;",
),
expErr: "operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * ts from binoptestids_ts;",
),
expErr: "operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / ts from binoptestids_ts;",
),
expErr: "operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % ts from binoptestids_ts;",
),
expErr: "operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || ts from binoptestids_ts;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetIDSet = tableTest{
table: tbl(
"binoptestids_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeIDSet),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), []int64{101, 103}, []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestids_ids;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = b from binoptestids_ids;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= b from binoptestids_ids;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptestids_ids;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptestids_ids;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptestids_ids;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptestids_ids;",
),
expErr: " operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | b from binoptestids_ids;",
),
expErr: " operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << b from binoptestids_ids;",
),
expErr: " operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> b from binoptestids_ids;",
),
expErr: " operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + b from binoptestids_ids;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptestids_ids;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptestids_ids;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptestids_ids;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptestids_ids;",
),
expErr: " operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || b from binoptestids_ids;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetString = tableTest{
table: tbl(
"binoptestids_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeIDSet),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), []int64{101, 102}, string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestids_s;",
),
expErr: "types 'IDSET' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestids_s;",
),
expErr: "types 'IDSET' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestids_s;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptestids_s;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptestids_s;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptestids_s;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptestids_s;",
),
expErr: " operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | b from binoptestids_s;",
),
expErr: " operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << b from binoptestids_s;",
),
expErr: " operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> b from binoptestids_s;",
),
expErr: " operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + b from binoptestids_s;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptestids_s;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptestids_s;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptestids_s;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptestids_s;",
),
expErr: " operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || b from binoptestids_s;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithIDSetStringSet = tableTest{
table: tbl(
"binoptestids_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeIDSet),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), []int64{102, 103}, []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestids_ss;",
),
expErr: "types 'IDSET' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestids_ss;",
),
expErr: "types 'IDSET' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestids_ss;",
),
expErr: " operator '<=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >= b from binoptestids_ss;",
),
expErr: " operator '>=' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a < b from binoptestids_ss;",
),
expErr: " operator '<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a > b from binoptestids_ss;",
),
expErr: " operator '>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a & b from binoptestids_ss;",
),
expErr: " operator '&' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a | b from binoptestids_ss;",
),
expErr: " operator '|' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a << b from binoptestids_ss;",
),
expErr: " operator '<<' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a >> b from binoptestids_ss;",
),
expErr: " operator '>>' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a + b from binoptestids_ss;",
),
expErr: " operator '+' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a - b from binoptestids_ss;",
),
expErr: " operator '-' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a * b from binoptestids_ss;",
),
expErr: " operator '*' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a / b from binoptestids_ss;",
),
expErr: " operator '/' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a % b from binoptestids_ss;",
),
expErr: " operator '%' incompatible with type 'IDSET'",
},
{
sqls: sqls(
"select a || b from binoptestids_ss;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
// STRING bin op tests
var binOpExprWithStringInt = tableTest{
table: tbl(
"binoptests_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt),
srcHdr("d", fldTypeString),
),
srcRows(
srcRow(int64(10), int64(20), string("foo")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptests_i;",
),
expErr: "types 'STRING' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptests_i;",
),
expErr: "types 'STRING' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptests_i;",
),
expErr: "operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >= b from binoptests_i;",
),
expErr: "operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d < b from binoptests_i;",
),
expErr: "operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d > b from binoptests_i;",
),
expErr: "operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d & b from binoptests_i;",
),
expErr: "operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d | b from binoptests_i;",
),
expErr: "operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d << b from binoptests_i;",
),
expErr: "operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >> b from binoptests_i;",
),
expErr: "operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d + b from binoptests_i;",
),
expErr: "operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d - b from binoptests_i;",
),
expErr: "operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d * b from binoptests_i;",
),
expErr: "operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d / b from binoptests_i;",
),
expErr: "operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d % b from binoptests_i;",
),
expErr: "operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d || b from binoptests_i;",
),
expErr: "operator '||' incompatible with type 'INT'",
},
},
}
var binOpExprWithStringBool = tableTest{
table: tbl(
"binoptests_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
srcHdr("d", fldTypeString),
),
srcRows(
srcRow(int64(10), bool(true), string("foo")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptests_b;",
),
expErr: "types 'STRING' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptests_b;",
),
expErr: "types 'STRING' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptests_b;",
),
expErr: "operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >= b from binoptests_b;",
),
expErr: "operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d < b from binoptests_b;",
),
expErr: "operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d > b from binoptests_b;",
),
expErr: "operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d & b from binoptests_b;",
),
expErr: "operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d | b from binoptests_b;",
),
expErr: "operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d << b from binoptests_b;",
),
expErr: "operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >> b from binoptests_b;",
),
expErr: "operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d + b from binoptests_b;",
),
expErr: "operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d - b from binoptests_b;",
),
expErr: "operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d * b from binoptests_b;",
),
expErr: "operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d / b from binoptests_b;",
),
expErr: "operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d % b from binoptests_b;",
),
expErr: "operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d || b from binoptests_b;",
),
expErr: "operator '||' incompatible with type 'BOOL'",
},
},
}
var binOpExprWithStringID = tableTest{
table: tbl(
"binoptests_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
srcHdr("d", fldTypeString),
),
srcRows(
srcRow(int64(10), int64(20), string("foo")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptests_id;",
),
expErr: "types 'STRING' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptests_id;",
),
expErr: "types 'STRING' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptests_id;",
),
expErr: "operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >= b from binoptests_id;",
),
expErr: "operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d < b from binoptests_id;",
),
expErr: "operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d > b from binoptests_id;",
),
expErr: "operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d & b from binoptests_id;",
),
expErr: "operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d | b from binoptests_id;",
),
expErr: "operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d << b from binoptests_id;",
),
expErr: "operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d >> b from binoptests_id;",
),
expErr: "operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d + b from binoptests_id;",
),
expErr: "operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d - b from binoptests_id;",
),
expErr: "operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d * b from binoptests_id;",
),
expErr: "operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d / b from binoptests_id;",
),
expErr: "operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d % b from binoptests_id;",
),
expErr: "operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select d || b from binoptests_id;",
),
expErr: "operator '||' incompatible with type 'ID'",
},
},
}
var binOpExprWithStringDecimal = tableTest{
table: tbl(
"binoptests_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeString),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), string("foo"), float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptests_d;",
),
expErr: "types 'STRING' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a = d from binoptests_d;",
),
expErr: "types 'STRING' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a <= d from binoptests_d;",
),
expErr: "operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= d from binoptests_d;",
),
expErr: "operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < d from binoptests_d;",
),
expErr: "operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > d from binoptests_d;",
),
expErr: "operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & d from binoptests_d;",
),
expErr: "operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | d from binoptests_d;",
),
expErr: "operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << d from binoptests_d;",
),
expErr: "operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> d from binoptests_d;",
),
expErr: "operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + d from binoptests_d;",
),
expErr: "operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - d from binoptests_d;",
),
expErr: "operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * d from binoptests_d;",
),
expErr: "operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / d from binoptests_d;",
),
expErr: "operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % d from binoptests_d;",
),
expErr: "operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || d from binoptests_d;",
),
expErr: "operator '||' incompatible with type 'DECIMAL(2)'",
},
},
}
var binOpExprWithStringTimestamp = tableTest{
table: tbl(
"binoptests_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeString),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), string("foo"), time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptests_ts;",
),
expErr: "types 'STRING' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptests_ts;",
),
expErr: "types 'STRING' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptests_ts;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= ts from binoptests_ts;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < ts from binoptests_ts;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > ts from binoptests_ts;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & ts from binoptests_ts;",
),
expErr: "operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | ts from binoptests_ts;",
),
expErr: "operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << ts from binoptests_ts;",
),
expErr: "operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> ts from binoptests_ts;",
),
expErr: "operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + ts from binoptests_ts;",
),
expErr: "operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - ts from binoptests_ts;",
),
expErr: "operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * ts from binoptests_ts;",
),
expErr: "operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / ts from binoptests_ts;",
),
expErr: "operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % ts from binoptests_ts;",
),
expErr: "operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || ts from binoptests_ts;",
),
expErr: "operator '||' incompatible with type 'TIMESTAMP'",
},
},
}
var binOpExprWithStringIDSet = tableTest{
table: tbl(
"binoptests_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeString),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), string("foo"), []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptests_ids;",
),
expErr: "types 'STRING' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptests_ids;",
),
expErr: "types 'STRING' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptests_ids;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptests_ids;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptests_ids;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptests_ids;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptests_ids;",
),
expErr: " operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | b from binoptests_ids;",
),
expErr: " operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << b from binoptests_ids;",
),
expErr: " operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> b from binoptests_ids;",
),
expErr: " operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + b from binoptests_ids;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptests_ids;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptests_ids;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptests_ids;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptests_ids;",
),
expErr: " operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || b from binoptests_ids;",
),
expErr: "operator '||' incompatible with type 'IDSET'",
},
},
}
var binOpExprWithStringString = tableTest{
table: tbl(
"binoptests_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeString),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), string("foo"), string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptests_s;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = b from binoptests_s;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= b from binoptests_s;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptests_s;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptests_s;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptests_s;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptests_s;",
),
expErr: " operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | b from binoptests_s;",
),
expErr: " operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << b from binoptests_s;",
),
expErr: " operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> b from binoptests_s;",
),
expErr: " operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + b from binoptests_s;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptests_s;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptests_s;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptests_s;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptests_s;",
),
expErr: " operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || b from binoptests_s;",
),
expHdrs: hdrs(
hdr("", fldTypeString),
),
expRows: rows(
row(string("foo101")),
),
compare: compareExactUnordered,
},
},
}
var binOpExprWithStringStringSet = tableTest{
table: tbl(
"binoptests_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeString),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), string("foo"), []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptests_ss;",
),
expErr: "types 'STRING' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptests_ss;",
),
expErr: "types 'STRING' and 'STRINGSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptests_ss;",
),
expErr: " operator '<=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >= b from binoptests_ss;",
),
expErr: " operator '>=' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a < b from binoptests_ss;",
),
expErr: " operator '<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a > b from binoptests_ss;",
),
expErr: " operator '>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a & b from binoptests_ss;",
),
expErr: " operator '&' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a | b from binoptests_ss;",
),
expErr: " operator '|' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a << b from binoptests_ss;",
),
expErr: " operator '<<' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a >> b from binoptests_ss;",
),
expErr: " operator '>>' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a + b from binoptests_ss;",
),
expErr: " operator '+' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a - b from binoptests_ss;",
),
expErr: " operator '-' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a * b from binoptests_ss;",
),
expErr: " operator '*' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a / b from binoptests_ss;",
),
expErr: " operator '/' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a % b from binoptests_ss;",
),
expErr: " operator '%' incompatible with type 'STRING'",
},
{
sqls: sqls(
"select a || b from binoptests_ss;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
// STRINGSET bin op tests
var binOpExprWithStringSetInt = tableTest{
table: tbl(
"binoptestss_i",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeInt),
srcHdr("d", fldTypeStringSet),
),
srcRows(
srcRow(int64(10), int64(20), []string{"20", "21"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestss_i;",
),
expErr: "types 'STRINGSET' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestss_i;",
),
expErr: "types 'STRINGSET' and 'INT' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestss_i;",
),
expErr: "operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >= b from binoptestss_i;",
),
expErr: "operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d < b from binoptestss_i;",
),
expErr: "operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d > b from binoptestss_i;",
),
expErr: "operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d & b from binoptestss_i;",
),
expErr: "operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d | b from binoptestss_i;",
),
expErr: "operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d << b from binoptestss_i;",
),
expErr: "operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >> b from binoptestss_i;",
),
expErr: "operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d + b from binoptestss_i;",
),
expErr: "operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d - b from binoptestss_i;",
),
expErr: "operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d * b from binoptestss_i;",
),
expErr: "operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d / b from binoptestss_i;",
),
expErr: "operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d % b from binoptestss_i;",
),
expErr: "operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d || b from binoptestss_i;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetBool = tableTest{
table: tbl(
"binoptestss_b",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeBool),
srcHdr("d", fldTypeStringSet),
),
srcRows(
srcRow(int64(10), bool(true), []string{"20", "21"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestss_b;",
),
expErr: "types 'STRINGSET' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestss_b;",
),
expErr: "types 'STRINGSET' and 'BOOL' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestss_b;",
),
expErr: "operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >= b from binoptestss_b;",
),
expErr: "operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d < b from binoptestss_b;",
),
expErr: "operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d > b from binoptestss_b;",
),
expErr: "operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d & b from binoptestss_b;",
),
expErr: "operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d | b from binoptestss_b;",
),
expErr: "operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d << b from binoptestss_b;",
),
expErr: "operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >> b from binoptestss_b;",
),
expErr: "operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d + b from binoptestss_b;",
),
expErr: "operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d - b from binoptestss_b;",
),
expErr: "operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d * b from binoptestss_b;",
),
expErr: "operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d / b from binoptestss_b;",
),
expErr: "operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d % b from binoptestss_b;",
),
expErr: "operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d || b from binoptestss_b;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetID = tableTest{
table: tbl(
"binoptestss_id",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("b", fldTypeID),
srcHdr("d", fldTypeStringSet),
),
srcRows(
srcRow(int64(10), int64(20), []string{"20", "21"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select d != b from binoptestss_id;",
),
expErr: "types 'STRINGSET' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d = b from binoptestss_id;",
),
expErr: "types 'STRINGSET' and 'ID' are not equatable",
},
{
sqls: sqls(
"select d <= b from binoptestss_id;",
),
expErr: "operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >= b from binoptestss_id;",
),
expErr: "operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d < b from binoptestss_id;",
),
expErr: "operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d > b from binoptestss_id;",
),
expErr: "operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d & b from binoptestss_id;",
),
expErr: "operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d | b from binoptestss_id;",
),
expErr: "operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d << b from binoptestss_id;",
),
expErr: "operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d >> b from binoptestss_id;",
),
expErr: "operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d + b from binoptestss_id;",
),
expErr: "operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d - b from binoptestss_id;",
),
expErr: "operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d * b from binoptestss_id;",
),
expErr: "operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d / b from binoptestss_id;",
),
expErr: "operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d % b from binoptestss_id;",
),
expErr: "operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select d || b from binoptestss_id;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetDecimal = tableTest{
table: tbl(
"binoptestss_d",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeStringSet),
srcHdr("d", fldTypeDecimal2),
),
srcRows(
srcRow(int64(1), []string{"20", "21"}, float64(12.34)),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != d from binoptestss_d;",
),
expErr: "types 'STRINGSET' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a = d from binoptestss_d;",
),
expErr: "types 'STRINGSET' and 'DECIMAL(2)' are not equatable",
},
{
sqls: sqls(
"select a <= d from binoptestss_d;",
),
expErr: "operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= d from binoptestss_d;",
),
expErr: "operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < d from binoptestss_d;",
),
expErr: "operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > d from binoptestss_d;",
),
expErr: "operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & d from binoptestss_d;",
),
expErr: "operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | d from binoptestss_d;",
),
expErr: "operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << d from binoptestss_d;",
),
expErr: "operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> d from binoptestss_d;",
),
expErr: "operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + d from binoptestss_d;",
),
expErr: "operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - d from binoptestss_d;",
),
expErr: "operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * d from binoptestss_d;",
),
expErr: "operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / d from binoptestss_d;",
),
expErr: "operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % d from binoptestss_d;",
),
expErr: "operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || d from binoptestss_d;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetTimestamp = tableTest{
table: tbl(
"binoptestss_ts",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeStringSet),
srcHdr("ts", fldTypeTimestamp),
),
srcRows(
srcRow(int64(1), []string{"20", "21"}, time.Time(knownTimestamp())),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != ts from binoptestss_ts;",
),
expErr: "types 'STRINGSET' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a = ts from binoptestss_ts;",
),
expErr: "types 'STRINGSET' and 'TIMESTAMP' are not equatable",
},
{
sqls: sqls(
"select a <= ts from binoptestss_ts;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= ts from binoptestss_ts;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < ts from binoptestss_ts;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > ts from binoptestss_ts;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & ts from binoptestss_ts;",
),
expErr: "operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | ts from binoptestss_ts;",
),
expErr: "operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << ts from binoptestss_ts;",
),
expErr: "operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> ts from binoptestss_ts;",
),
expErr: "operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + ts from binoptestss_ts;",
),
expErr: "operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - ts from binoptestss_ts;",
),
expErr: "operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * ts from binoptestss_ts;",
),
expErr: "operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / ts from binoptestss_ts;",
),
expErr: "operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % ts from binoptestss_ts;",
),
expErr: "operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || ts from binoptestss_ts;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetIDSet = tableTest{
table: tbl(
"binoptestss_ids",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeStringSet),
srcHdr("b", fldTypeIDSet),
),
srcRows(
srcRow(int64(1), []string{"101", "103"}, []int64{101, 102}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestss_ids;",
),
expErr: "types 'STRINGSET' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestss_ids;",
),
expErr: "types 'STRINGSET' and 'IDSET' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestss_ids;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptestss_ids;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptestss_ids;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptestss_ids;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptestss_ids;",
),
expErr: " operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | b from binoptestss_ids;",
),
expErr: " operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << b from binoptestss_ids;",
),
expErr: " operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> b from binoptestss_ids;",
),
expErr: " operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + b from binoptestss_ids;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptestss_ids;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptestss_ids;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptestss_ids;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptestss_ids;",
),
expErr: " operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || b from binoptestss_ids;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetString = tableTest{
table: tbl(
"binoptestss_s",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeStringSet),
srcHdr("b", fldTypeString),
),
srcRows(
srcRow(int64(1), []string{"101", "102"}, string("101")),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestss_s;",
),
expErr: "types 'STRINGSET' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a = b from binoptestss_s;",
),
expErr: "types 'STRINGSET' and 'STRING' are not equatable",
},
{
sqls: sqls(
"select a <= b from binoptestss_s;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptestss_s;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptestss_s;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptestss_s;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptestss_s;",
),
expErr: " operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | b from binoptestss_s;",
),
expErr: " operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << b from binoptestss_s;",
),
expErr: " operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> b from binoptestss_s;",
),
expErr: " operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + b from binoptestss_s;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptestss_s;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptestss_s;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptestss_s;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptestss_s;",
),
expErr: " operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || b from binoptestss_s;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
var binOpExprWithStringSetStringSet = tableTest{
table: tbl(
"binoptestss_ss",
srcHdrs(
srcHdr("_id", fldTypeID),
srcHdr("a", fldTypeStringSet),
srcHdr("b", fldTypeStringSet),
),
srcRows(
srcRow(int64(1), []string{"102", "103"}, []string{"101", "102"}),
),
),
sqlTests: []sqlTest{
{
sqls: sqls(
"select a != b from binoptestss_ss;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(true)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a = b from binoptestss_ss;",
),
expHdrs: hdrs(
hdr("", fldTypeBool),
),
expRows: rows(
row(bool(false)),
),
compare: compareExactUnordered,
},
{
sqls: sqls(
"select a <= b from binoptestss_ss;",
),
expErr: " operator '<=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >= b from binoptestss_ss;",
),
expErr: " operator '>=' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a < b from binoptestss_ss;",
),
expErr: " operator '<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a > b from binoptestss_ss;",
),
expErr: " operator '>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a & b from binoptestss_ss;",
),
expErr: " operator '&' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a | b from binoptestss_ss;",
),
expErr: " operator '|' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a << b from binoptestss_ss;",
),
expErr: " operator '<<' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a >> b from binoptestss_ss;",
),
expErr: " operator '>>' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a + b from binoptestss_ss;",
),
expErr: " operator '+' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a - b from binoptestss_ss;",
),
expErr: " operator '-' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a * b from binoptestss_ss;",
),
expErr: " operator '*' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a / b from binoptestss_ss;",
),
expErr: " operator '/' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a % b from binoptestss_ss;",
),
expErr: " operator '%' incompatible with type 'STRINGSET'",
},
{
sqls: sqls(
"select a || b from binoptestss_ss;",
),
expErr: "operator '||' incompatible with type 'STRINGSET'",
},
},
}
Reference in a new issue View git blame Copy permalink