@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/03-expressions.sqllogic

@@ -0,0 +1,190 @@
+-- expressions.sqllogic - Testing various expression types and operators
+
+CREATE TABLE expr_t (i INTEGER PRIMARY KEY, n NUMERIC, t TEXT NULL, b BLOB NULL);
+INSERT INTO expr_t VALUES (1, 10.5, 'hello', x'01ff'), (2, -5, 'world', x'02'), (3, 0, null, null);
+-- No expected output for setup
+
+-- Arithmetic
+SELECT i + 1, n * 2, i / 2.0, i % 2 FROM expr_t WHERE i = 1;
+→ [{"i + 1":2,"n * 2":21,"i / 2.0":0.5,"i % 2":1}]
+SELECT i + 1, n * 2, i / 2.0, i % 2 FROM expr_t WHERE i = 2;
+→ [{"i + 1":3,"n * 2":-10,"i / 2.0":1,"i % 2":0}]
+
+-- Stacked unary operators
+SELECT - -1;
+→ [{"--1":1}]
+SELECT NOT NOT 1;
+→ [{"not not 1":true}]
+SELECT ~-1;
+→ [{"~-1":0}]
+
+-- Unary operators over numeric-typed operands take a specialized emit-time path
+-- (see runtime/emit/unary.ts); these pin its results against the generic path.
+-- REAL operand: ~ truncates toward zero before complementing.
+SELECT ~5.7 AS a, ~(-5.7) AS b, -5.5 AS c, +5.5 AS d;
+→ [{"a":-6,"b":4,"c":-5.5,"d":5.5}]
+-- BIGINT operand: stays in the bigint domain, no float round-trip.
+SELECT -9223372036854775807 AS a, +9223372036854775807 AS b, ~9223372036854775807 AS c;
+→ [{"a":-9223372036854775807,"b":9223372036854775807,"c":-9223372036854775808}]
+-- NULL propagates through every unary arithmetic operator.
+SELECT -null AS a, +null AS b, ~null AS c;
+→ [{"a":null,"b":null,"c":null}]
+-- Column-sourced operands (INTEGER key, NUMERIC column) take the same path.
+SELECT -i AS a, +i AS b, ~i AS c, -n AS d, +n AS e FROM expr_t WHERE i = 2;
+→ [{"a":-2,"b":2,"c":-3,"d":5,"e":-5}]
+-- TEXT operand keeps the generic coerce-or-null path.
+SELECT -t AS a, +t AS b, ~t AS c FROM expr_t WHERE i = 1;
+→ [{"a":null,"b":null,"c":null}]
+-- ~ is -x-1 over the WHOLE integer domain, not a 32-bit complement: every operand
+-- below is past 2^31, where a ToInt32-based ~ silently wraps (~3000000000 would be
+-- 1294967295). The last two land on the safe-integer boundary from both sides —
+-- arithmetic narrowing (R1) hands ~ a number where it used to see a bigint.
+SELECT ~2147483647 AS a, ~2147483648 AS b, ~3000000000 AS c, ~(-3000000000) AS d;
+→ [{"a":-2147483648,"b":-2147483649,"c":-3000000001,"d":2999999999}]
+SELECT ~9007199254740990 AS a, ~(9007199254740993 - 3) AS b, ~9007199254740991 AS c;
+→ [{"a":-9007199254740991,"b":-9007199254740991,"c":-9007199254740992}]
+-- Generic (TEXT-operand) path agrees with the numeric-fast path past 2^31.
+SELECT ~'3000000000' AS a;
+→ [{"a":-3000000001}]
+
+-- String Concatenation
+SELECT t || ' ' || t FROM expr_t WHERE i = 1;
+→ [{"t || ' ' || t":"hello hello"}]
+
+-- Comparisons
+SELECT i > 1, n <= 10.5, t = 'hello', b != x'01ff' FROM expr_t WHERE i = 1;
+→ [{"i > 1":false,"n <= 10.5":true,"t = 'hello'":true,"b != x'01ff'":false}]
+SELECT i > 1, n <= 10.5, t == 'world' FROM expr_t WHERE i = 2;
+→ [{"i > 1":true,"n <= 10.5":true,"t == 'world'":true}]
+
+-- Logical Operators
+SELECT i > 1 AND n < 0 FROM expr_t WHERE i = 2;
+→ [{"i > 1 and n < 0":true}]
+SELECT i = 1 OR t = 'world' FROM expr_t ORDER BY i;
+→ [{"i = 1 or t = 'world'":true},{"i = 1 or t = 'world'":true},{"i = 1 or t = 'world'":null}]
+SELECT NOT (n = 0) FROM expr_t WHERE i = 3;
+→ [{"not (n = 0)":false}]
+
+-- XOR Operator (3VL)
+SELECT 1 XOR 1, 1 XOR 0, 0 XOR 1, 0 XOR 0;
+→ [{"1 xor 1":false,"1 xor 0":true,"0 xor 1":true,"0 xor 0":false}]
+SELECT NULL XOR 1, NULL XOR 0, 1 XOR NULL, 0 XOR NULL, NULL XOR NULL;
+→ [{"null xor 1":null,"null xor 0":null,"1 xor null":null,"0 xor null":null,"null xor null":null}]
+SELECT (i > 1) XOR (n < 0) FROM expr_t WHERE i = 2; -- TRUE XOR TRUE -> FALSE
+→ [{"i > 1 xor n < 0":false}]
+SELECT (i > 1) XOR (t = 'hello') FROM expr_t WHERE i = 1; -- FALSE XOR TRUE -> TRUE
+→ [{"i > 1 xor t = 'hello'":true}]
+SELECT (i > 1) XOR n IS NULL FROM expr_t WHERE i = 1; -- FALSE XOR FALSE -> FALSE
+→ [{"i > 1 xor n is null":false}]
+SELECT (i > 1) XOR t IS NULL FROM expr_t WHERE i = 3; -- FALSE XOR NULL -> NULL
+→ [{"i > 1 xor t is null":false}]
+
+-- NULL Handling
+SELECT t is null, t IS NOT NULL, n + NULL FROM expr_t WHERE i = 3;
+→ [{"t is null":true,"t is not null":false,"n + null":null}]
+SELECT coalesce(t, 'default') FROM expr_t ORDER BY i;
+→ [{"coalesce(t, 'default')":"hello"},{"coalesce(t, 'default')":"world"},{"coalesce(t, 'default')":"default"}]
+SELECT nullif(i, 2) FROM expr_t ORDER BY i;
+→ [{"nullif(i, 2)":1},{"nullif(i, 2)":null},{"nullif(i, 2)":3}]
+
+-- CASE expressions
+SELECT CASE i WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'other' END FROM expr_t ORDER BY i;
+→ [{"case i when 1 then 'one' when 2 then 'two' else 'other' end":"one"},{"case i when 1 then 'one' when 2 then 'two' else 'other' end":"two"},{"case i when 1 then 'one' when 2 then 'two' else 'other' end":"other"}]
+SELECT CASE WHEN n > 0 THEN 'pos' WHEN n < 0 THEN 'neg' ELSE 'zero' END FROM expr_t ORDER BY i;
+→ [{"case when n > 0 then 'pos' when n < 0 then 'neg' else 'zero' end":"pos"},{"case when n > 0 then 'pos' when n < 0 then 'neg' else 'zero' end":"neg"},{"case when n > 0 then 'pos' when n < 0 then 'neg' else 'zero' end":"zero"}]
+
+-- CASE short-circuit semantics (only the selected branch is evaluated)
+-- Simple CASE, no ELSE, no match → NULL
+SELECT CASE i WHEN 99 THEN 'x' END FROM expr_t WHERE i = 1;
+→ [{"case i when 99 then 'x' end":null}]
+-- Searched CASE, no ELSE, no match → NULL
+SELECT CASE WHEN i = 99 THEN 'x' END FROM expr_t WHERE i = 1;
+→ [{"case when i = 99 then 'x' end":null}]
+-- Simple CASE with NULL base never matches any WHEN → falls to ELSE
+SELECT CASE null WHEN 1 THEN 'a' ELSE 'else' END AS r;
+→ [{"r":"else"}]
+-- Simple CASE with NULL WHEN value never matches → falls to ELSE
+SELECT CASE 1 WHEN null THEN 'a' ELSE 'else' END AS r;
+→ [{"r":"else"}]
+-- First match wins: later WHEN clauses are not consulted
+SELECT CASE WHEN 1 = 1 THEN 'first' WHEN 1 = 1 THEN 'second' END AS r;
+→ [{"r":"first"}]
+
+-- CAST expressions
+SELECT cast(i as TEXT), cast(n as INTEGER), cast(t as REAL) FROM expr_t WHERE i = 1;
+→ [{"cast(i as text)":"1","cast(n as integer)":10,"cast(t as real)":0}]
+SELECT cast('123' as INTEGER), cast('12.3' as REAL), cast(123 as TEXT);
+→ [{"cast('123' as integer)":123,"cast('12.3' as real)":12.3,"cast(123 as text)":"123"}]
+
+-- COLLATE (basic syntax check, assumes default collation)
+SELECT t FROM expr_t WHERE t = 'HELLO' COLLATE NOCASE ORDER BY i;
+→ [{"t":"hello"}]
+
+DROP TABLE expr_t;
+
+SELECT typeof(1 + 2), typeof(1.5 + 2), typeof('a' || 'b');
+→ [{"typeof(1 + 2)":"integer","typeof(1.5 + 2)":"real","typeof('a' || 'b')":"text"}]
+
+-- BETWEEN
+SELECT 3 BETWEEN 2 and 6 AS isbetwixt, 'a' between 'f' and 'z' AS notbetwixt;
+→ [{"isbetwixt":true,"notbetwixt":false}]
+
+-- BETWEEN with COLLATE NOCASE
+SELECT 'Hello' COLLATE NOCASE BETWEEN 'a' AND 'z' AS yes1, 'Hello' BETWEEN 'a' AND 'z' AS no1;
+→ [{"yes1":true,"no1":false}]
+
+SELECT 'B' COLLATE NOCASE BETWEEN 'a' AND 'c' AS yes2, 'B' BETWEEN 'a' AND 'c' AS no2;
+→ [{"yes2":true,"no2":false}]
+
+-- NOT BETWEEN with COLLATE NOCASE
+SELECT 'Hello' COLLATE NOCASE NOT BETWEEN 'a' AND 'z' AS no3, 'Hello' NOT BETWEEN 'a' AND 'z' AS yes3;
+→ [{"no3":false,"yes3":true}]
+
+-- A COLLATE on a BETWEEN *bound* governs only that bound's comparison (per-bound,
+-- like `expr >= lo AND expr <= hi`), NOT the whole expression. The lower bound's NOCASE
+-- makes `'hello' >= 'A'` true, but the bare upper keeps `'hello' <= 'Z'` BINARY (false),
+-- so the whole BETWEEN is false — matching SQLite and the desugared two-comparison form.
+SELECT 'hello' BETWEEN 'A' COLLATE NOCASE AND 'Z' AS lo_collated, 'hello' BETWEEN 'A' AND 'Z' AS plain;
+→ [{"lo_collated":false,"plain":false}]
+
+-- A COLLATE on the *upper* bound likewise flips only that comparison: `'hello' <= 'Z'`
+-- under NOCASE is true ('hello' <= 'z'), and the bare lower `'hello' >= 'A'` is BINARY-true,
+-- so the BETWEEN is true.
+SELECT 'hello' BETWEEN 'A' AND 'Z' COLLATE NOCASE AS hi_collated;
+→ [{"hi_collated":true}]
+
+-- BETWEEN with NULL operands still returns NULL under COLLATE
+SELECT null COLLATE NOCASE BETWEEN 'a' AND 'z' AS r1, 'b' COLLATE NOCASE BETWEEN null AND 'z' AS r2;
+→ [{"r1":null,"r2":null}]
+
+-- Expression evaluation consistency across contexts
+CREATE TABLE expr_context_test (id INTEGER PRIMARY KEY, a INTEGER, b INTEGER, c INTEGER NULL);
+INSERT INTO expr_context_test VALUES (1, 5, 3, null), (2, -2, 4, 7), (3, 0, 1, 0);
+
+-- Test that expressions evaluate consistently across SELECT, WHERE, HAVING
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test ORDER BY id;
+→ [{"id":1,"expr_result":11},{"id":2,"expr_result":6},{"id":3,"expr_result":2}]
+
+-- Same expression in WHERE - should find matching rows
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test WHERE (a + b * 2) = 11;
+→ [{"id":1,"expr_result":11}]
+
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test WHERE (a + b * 2) = 6;
+→ [{"id":2,"expr_result":6}]
+
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test WHERE (a + b * 2) = 2;
+→ [{"id":3,"expr_result":2}]
+
+-- Same expression in HAVING (a, b in GROUP BY for SQL-92 column coverage; id alone would
+-- need PK-based functional-dependency analysis which Quereus does not implement)
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test GROUP BY id, a, b HAVING (a + b * 2) = 11;
+→ [{"id":1,"expr_result":11}]
+
+SELECT id, (a + b * 2) as expr_result FROM expr_context_test GROUP BY id, a, b HAVING (a + b * 2) IN (2, 6) ORDER BY id;
+→ [{"id":2,"expr_result":6},{"id":3,"expr_result":2}]
+
+-- Test more complex expressions
+SELECT id, (a * b + COALESCE(c, 0)) as complex_expr FROM expr_context_test ORDER BY id;
+→ [{"id":1,"complex_expr":15},{"id":2,"complex_expr":-1},{"id":3,"complex_expr":0}]
+
+DROP TABLE expr_context_test;

package/test/logic/03.1-quoted-identifiers.sqllogic

@@ -0,0 +1,55 @@
+-- quoted-identifiers.sqllogic - Testing quoted identifier syntax
+-- Tests double-quoted, backtick, and bracket identifier quoting
+
+-- Test double-quoted table name
+CREATE TABLE "QuotedTable" (id INTEGER PRIMARY KEY, value TEXT);
+INSERT INTO "QuotedTable" VALUES (1, 'test');
+SELECT * FROM "QuotedTable";
+→ [{"id":1,"value":"test"}]
+
+-- Test double-quoted column names
+CREATE TABLE test_quoted_cols ("Column One" INTEGER PRIMARY KEY, "Column Two" TEXT);
+INSERT INTO test_quoted_cols ("Column One", "Column Two") VALUES (1, 'hello');
+SELECT "Column One", "Column Two" FROM test_quoted_cols;
+→ [{"Column One":1,"Column Two":"hello"}]
+
+-- Test backtick-quoted table name
+CREATE TABLE `BacktickTable` (id INTEGER PRIMARY KEY, name TEXT);
+INSERT INTO `BacktickTable` VALUES (1, 'backtick test');
+SELECT * FROM `BacktickTable`;
+→ [{"id":1,"name":"backtick test"}]
+
+-- Test bracket-quoted table name (SQL Server style)
+CREATE TABLE [BracketTable] (id INTEGER PRIMARY KEY, data TEXT);
+INSERT INTO [BracketTable] VALUES (1, 'bracket test');
+SELECT * FROM [BracketTable];
+→ [{"id":1,"data":"bracket test"}]
+
+-- Test quoted identifiers that are reserved words
+CREATE TABLE "SELECT" (id INTEGER PRIMARY KEY, "FROM" TEXT, "WHERE" INTEGER);
+INSERT INTO "SELECT" ("id", "FROM", "WHERE") VALUES (1, 'table', 42);
+SELECT "FROM", "WHERE" FROM "SELECT";
+→ [{"FROM":"table","WHERE":42}]
+
+-- Test quoted alias
+SELECT id AS "My ID", value AS "The Value" FROM "QuotedTable";
+→ [{"My ID":1,"The Value":"test"}]
+
+-- Test quoted identifiers with spaces
+CREATE TABLE "Table With Spaces" ("Column With Spaces" TEXT PRIMARY KEY);
+INSERT INTO "Table With Spaces" VALUES ('spacy');
+SELECT "Column With Spaces" FROM "Table With Spaces";
+→ [{"Column With Spaces":"spacy"}]
+
+-- Test mixed quoting styles in same query
+SELECT q.id, b.id AS bid FROM "QuotedTable" q JOIN `BacktickTable` b ON q.id = b.id;
+→ [{"id":1,"bid":1}]
+
+-- Clean up
+DROP TABLE "QuotedTable";
+DROP TABLE test_quoted_cols;
+DROP TABLE `BacktickTable`;
+DROP TABLE [BracketTable];
+DROP TABLE "SELECT";
+DROP TABLE "Table With Spaces";
+