@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/108-cardinality-estimation.sqllogic

@@ -0,0 +1,146 @@
+-- 108-cardinality-estimation.sqllogic
+-- Exercises ANALYZE (initial run, re-run after data changes) over skewed data
+-- and checks that results stay correct throughout — row counts, GROUP BY
+-- distribution, equality/range filters, and joins. It does NOT assert plan
+-- shape, index selection, or access method; nothing here fails if ANALYZE's
+-- statistics are ignored by the optimizer. Cost-based plan-shape assertions
+-- driven by ANALYZE statistics live in test/where-conjunct-ordering.spec.ts
+-- and test/optimizer/*.spec.ts.
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Setup: table with skewed data distribution
+-- ═══════════════════════════════════════════════════════════════════════
+
+CREATE TABLE ce_products (
+	id INTEGER PRIMARY KEY,
+	category TEXT,
+	price REAL,
+	name TEXT
+) USING memory;
+
+-- 40 rows: 4 categories (high selectivity equality), spread prices
+-- Category distribution: 10 electronics, 10 books, 10 clothing, 10 food
+-- Price distribution: 9.99 to 399.60
+
+-- Insert rows (one per statement)
+INSERT INTO ce_products VALUES (1, 'electronics', 9.99, 'item_1');
+INSERT INTO ce_products VALUES (2, 'books', 19.98, 'item_2');
+INSERT INTO ce_products VALUES (3, 'clothing', 29.97, 'item_3');
+INSERT INTO ce_products VALUES (4, 'food', 39.96, 'item_4');
+INSERT INTO ce_products VALUES (5, 'electronics', 49.95, 'item_5');
+INSERT INTO ce_products VALUES (6, 'books', 59.94, 'item_6');
+INSERT INTO ce_products VALUES (7, 'clothing', 69.93, 'item_7');
+INSERT INTO ce_products VALUES (8, 'food', 79.92, 'item_8');
+INSERT INTO ce_products VALUES (9, 'electronics', 89.91, 'item_9');
+INSERT INTO ce_products VALUES (10, 'books', 99.90, 'item_10');
+INSERT INTO ce_products VALUES (11, 'clothing', 109.89, 'item_11');
+INSERT INTO ce_products VALUES (12, 'food', 119.88, 'item_12');
+INSERT INTO ce_products VALUES (13, 'electronics', 129.87, 'item_13');
+INSERT INTO ce_products VALUES (14, 'books', 139.86, 'item_14');
+INSERT INTO ce_products VALUES (15, 'clothing', 149.85, 'item_15');
+INSERT INTO ce_products VALUES (16, 'food', 159.84, 'item_16');
+INSERT INTO ce_products VALUES (17, 'electronics', 169.83, 'item_17');
+INSERT INTO ce_products VALUES (18, 'books', 179.82, 'item_18');
+INSERT INTO ce_products VALUES (19, 'clothing', 189.81, 'item_19');
+INSERT INTO ce_products VALUES (20, 'food', 199.80, 'item_20');
+INSERT INTO ce_products VALUES (21, 'electronics', 209.79, 'item_21');
+INSERT INTO ce_products VALUES (22, 'books', 219.78, 'item_22');
+INSERT INTO ce_products VALUES (23, 'clothing', 229.77, 'item_23');
+INSERT INTO ce_products VALUES (24, 'food', 239.76, 'item_24');
+INSERT INTO ce_products VALUES (25, 'electronics', 249.75, 'item_25');
+INSERT INTO ce_products VALUES (26, 'books', 259.74, 'item_26');
+INSERT INTO ce_products VALUES (27, 'clothing', 269.73, 'item_27');
+INSERT INTO ce_products VALUES (28, 'food', 279.72, 'item_28');
+INSERT INTO ce_products VALUES (29, 'electronics', 289.71, 'item_29');
+INSERT INTO ce_products VALUES (30, 'books', 299.70, 'item_30');
+INSERT INTO ce_products VALUES (31, 'clothing', 309.69, 'item_31');
+INSERT INTO ce_products VALUES (32, 'food', 319.68, 'item_32');
+INSERT INTO ce_products VALUES (33, 'electronics', 329.67, 'item_33');
+INSERT INTO ce_products VALUES (34, 'books', 339.66, 'item_34');
+INSERT INTO ce_products VALUES (35, 'clothing', 349.65, 'item_35');
+INSERT INTO ce_products VALUES (36, 'food', 359.64, 'item_36');
+INSERT INTO ce_products VALUES (37, 'electronics', 369.63, 'item_37');
+INSERT INTO ce_products VALUES (38, 'books', 379.62, 'item_38');
+INSERT INTO ce_products VALUES (39, 'clothing', 389.61, 'item_39');
+INSERT INTO ce_products VALUES (40, 'food', 399.60, 'item_40');
+
+-- Run ANALYZE to collect statistics
+ANALYZE ce_products;
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Verify ANALYZE produces valid output
+-- ═══════════════════════════════════════════════════════════════════════
+
+-- Correctness: verify data is intact after ANALYZE
+SELECT count(*) AS cnt FROM ce_products;
+→ [{"cnt":40}]
+
+-- Correctness: category distribution
+SELECT category, count(*) AS cnt FROM ce_products GROUP BY category ORDER BY category;
+→ [{"category":"books","cnt":10},{"category":"clothing","cnt":10},{"category":"electronics","cnt":10},{"category":"food","cnt":10}]
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Equality filter correctness (benefits from NDV statistics)
+-- ═══════════════════════════════════════════════════════════════════════
+
+SELECT count(*) AS cnt FROM ce_products WHERE category = 'electronics';
+→ [{"cnt":10}]
+
+SELECT count(*) AS cnt FROM ce_products WHERE category = 'books';
+→ [{"cnt":10}]
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Range filter correctness (benefits from histogram statistics)
+-- ═══════════════════════════════════════════════════════════════════════
+
+SELECT count(*) AS cnt FROM ce_products WHERE price < 100;
+→ [{"cnt":10}]
+
+SELECT count(*) AS cnt FROM ce_products WHERE price >= 200 AND price < 300;
+→ [{"cnt":10}]
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Setup second table for join tests
+-- ═══════════════════════════════════════════════════════════════════════
+
+CREATE TABLE ce_orders (
+	order_id INTEGER PRIMARY KEY,
+	product_id INTEGER,
+	quantity INTEGER
+) USING memory;
+
+INSERT INTO ce_orders VALUES (1, 1, 2);
+INSERT INTO ce_orders VALUES (2, 1, 1);
+INSERT INTO ce_orders VALUES (3, 5, 3);
+INSERT INTO ce_orders VALUES (4, 10, 1);
+INSERT INTO ce_orders VALUES (5, 20, 5);
+
+ANALYZE ce_orders;
+
+-- Join correctness: inner join
+SELECT count(*) AS cnt FROM ce_products JOIN ce_orders ON ce_products.id = ce_orders.product_id;
+→ [{"cnt":5}]
+
+-- Join correctness: left join (product 1 has 2 orders, so 36 + 2 + 1 + 1 + 1 = 41)
+SELECT count(*) AS cnt FROM ce_products LEFT JOIN ce_orders ON ce_products.id = ce_orders.product_id;
+→ [{"cnt":41}]
+
+-- ═══════════════════════════════════════════════════════════════════════
+-- Re-ANALYZE after data changes
+-- ═══════════════════════════════════════════════════════════════════════
+
+INSERT INTO ce_products VALUES (41, 'electronics', 409.59, 'item_41');
+INSERT INTO ce_products VALUES (42, 'books', 419.58, 'item_42');
+INSERT INTO ce_products VALUES (43, 'clothing', 429.57, 'item_43');
+INSERT INTO ce_products VALUES (44, 'food', 439.56, 'item_44');
+INSERT INTO ce_products VALUES (45, 'electronics', 449.55, 'item_45');
+
+ANALYZE ce_products;
+
+-- Verify updated row count
+SELECT count(*) AS cnt FROM ce_products;
+→ [{"cnt":45}]
+
+-- Queries still work correctly after re-ANALYZE
+SELECT count(*) AS cnt FROM ce_products WHERE category = 'electronics';
+→ [{"cnt":12}]

package/test/logic/108.1-analyze-name-resolution.sqllogic

@@ -0,0 +1,102 @@
+-- 108.1-analyze-name-resolution.sqllogic
+-- ANALYZE on a name that resolves to nothing used to succeed quietly with zero
+-- rows (through both the emitter's table lookup and the schema-only lookup).
+-- It now resolves the target at build time, the same way every other
+-- name-taking statement does, and errors when the name does not exist.
+
+create table t (id integer primary key, v integer);
+insert into t values (1, 10), (2, 20);
+
+create view v_t as select * from t;
+
+create materialized view mv_t as select * from t;
+
+create table temp.tt (id integer primary key, v integer);
+insert into temp.tt values (1, 100);
+
+-- ===================================
+-- Real table: unchanged
+-- ===================================
+
+analyze t;
+→ [{"table":"t","rows":2}]
+
+-- ===================================
+-- Unresolvable names now error instead of silently returning nothing
+-- ===================================
+
+analyze nosuchtable;
+-- error: Table 'nosuchtable' not found in schema path: main
+
+analyze main.nosuchtable;
+-- error: Table not found: main.nosuchtable
+
+analyze nosuchschema.t;
+-- error: Table not found: nosuchschema.t
+
+analyze nosuchschema.*;
+-- error: Schema not found: nosuchschema
+
+-- ===================================
+-- A plain view has no stored rows to collect statistics from
+-- ===================================
+
+analyze v_t;
+-- error: Cannot ANALYZE view 'main.v_t': a view has no stored rows to collect statistics from.
+
+-- ===================================
+-- `temp.` now parses as a schema qualifier (was a parse error before this fix)
+-- ===================================
+
+analyze temp.tt;
+→ [{"table":"tt","rows":1}]
+
+analyze temp.*;
+→ [{"table":"tt","rows":1}]
+
+-- ===================================
+-- An unqualified name follows the session search path, the way it does for
+-- every other statement — the emitter's old lookup hardcoded `main`.
+-- ===================================
+
+analyze tt;
+-- error: Table 'tt' not found in schema path: main
+
+PRAGMA schema_path = 'main,temp';
+-- run
+
+analyze tt;
+→ [{"table":"tt","rows":1}]
+
+PRAGMA schema_path = 'main';
+-- run
+
+-- ===================================
+-- The `committed` pseudo-schema resolves through the search path, so both the
+-- table arm and the view rejection see the same name a plain reference would.
+-- ===================================
+
+analyze committed.t;
+→ [{"table":"t","rows":2}]
+
+analyze committed.v_t;
+-- error: Cannot ANALYZE view 'main.v_t': a view has no stored rows to collect statistics from.
+
+-- ===================================
+-- Materialized view: real backing table, unchanged
+-- ===================================
+
+analyze mv_t;
+→ [{"table":"mv_t","rows":2}]
+
+-- ===================================
+-- Bare ANALYZE: unchanged, still allowed to report nothing for an empty schema
+-- ===================================
+
+analyze;
+-- run
+
+drop materialized view mv_t;
+drop view v_t;
+drop table t;
+drop table temp.tt;

package/test/logic/109-aggregate-physical-selection.sqllogic

@@ -0,0 +1,103 @@
+-- aggregate-physical-selection.sqllogic
+-- Validates physical aggregate operator selection across decision branches
+-- of ruleAggregatePhysical
+
+-- Setup: table with single PK (sorted by id)
+CREATE TABLE aps_single (id INTEGER PRIMARY KEY, grp TEXT, val INTEGER) USING memory;
+INSERT INTO aps_single VALUES (1,'a',10),(2,'b',20),(3,'a',30),(4,'b',40),(5,'c',50);
+
+-- Setup: table with composite PK (sorted by a, b)
+CREATE TABLE aps_comp (a INTEGER, b INTEGER, c INTEGER, PRIMARY KEY (a, b)) USING memory;
+INSERT INTO aps_comp VALUES (1,1,10),(1,2,20),(2,1,30),(2,2,40),(3,1,50);
+
+-- ===== Scalar aggregate → StreamAggregate =====
+
+-- Plan: scalar aggregate uses StreamAggregate
+SELECT 1 AS ok FROM query_plan('SELECT count(*), sum(val) FROM aps_single')
+WHERE op = 'STREAMAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Plan: scalar aggregate does not use HashAggregate
+SELECT count(*) AS cnt FROM query_plan('SELECT count(*), sum(val) FROM aps_single')
+WHERE op = 'HASHAGGREGATE';
+→ [{"cnt":0}]
+
+-- Correctness: scalar aggregate
+SELECT count(*) AS c, sum(val) AS s FROM aps_single;
+→ [{"c":5,"s":150}]
+
+-- ===== Already-sorted → StreamAggregate without Sort =====
+
+-- Plan: GROUP BY PK uses StreamAggregate
+SELECT 1 AS ok FROM query_plan('SELECT id, count(*) FROM aps_single GROUP BY id')
+WHERE op = 'STREAMAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Plan: GROUP BY PK does not insert Sort
+SELECT count(*) AS cnt FROM query_plan('SELECT id, count(*) FROM aps_single GROUP BY id')
+WHERE op = 'SORT';
+→ [{"cnt":0}]
+
+-- Plan: GROUP BY full composite PK uses StreamAggregate
+SELECT 1 AS ok FROM query_plan('SELECT a, b, count(*) FROM aps_comp GROUP BY a, b')
+WHERE op = 'STREAMAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Plan: GROUP BY composite PK prefix uses StreamAggregate
+SELECT 1 AS ok FROM query_plan('SELECT a, count(*) FROM aps_comp GROUP BY a')
+WHERE op = 'STREAMAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- ===== Unsorted → HashAggregate =====
+
+-- Plan: GROUP BY non-PK column uses HashAggregate
+SELECT 1 AS ok FROM query_plan('SELECT grp, count(*) FROM aps_single GROUP BY grp')
+WHERE op = 'HASHAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Correctness: grouped aggregate on non-sorted column
+SELECT grp, count(*) AS cnt FROM aps_single GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","cnt":2},{"grp":"b","cnt":2},{"grp":"c","cnt":1}]
+
+-- ===== isOrderedForGrouping edge cases =====
+
+-- Expression grouping (non-column-ref) → HashAggregate
+SELECT 1 AS ok FROM query_plan('SELECT id + 1, count(*) FROM aps_single GROUP BY id + 1')
+WHERE op = 'HASHAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Reversed composite PK order → HashAggregate (prefix mismatch)
+SELECT 1 AS ok FROM query_plan('SELECT b, a, count(*) FROM aps_comp GROUP BY b, a')
+WHERE op = 'HASHAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- More grouping keys than PK columns: GROUP-BY FD simplification drops the
+-- PK-determined column (`c` is functionally determined by the PK `(a, b)`)
+-- and rewrites the aggregate over `GROUP BY a, b` with a MIN(c) picker.
+-- The resulting GROUP BY is a prefix of the source ordering, so we land on
+-- StreamAggregate (no Sort needed).
+SELECT 1 AS ok FROM query_plan('SELECT a, b, c, count(*) FROM aps_comp GROUP BY a, b, c')
+WHERE op = 'STREAMAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Second key only (not prefix) → HashAggregate
+SELECT 1 AS ok FROM query_plan('SELECT b, count(*) FROM aps_comp GROUP BY b')
+WHERE op = 'HASHAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- First PK key + non-PK key → HashAggregate (column mismatch at position 1)
+SELECT 1 AS ok FROM query_plan('SELECT a, c, count(*) FROM aps_comp GROUP BY a, c')
+WHERE op = 'HASHAGGREGATE' LIMIT 1;
+→ [{"ok":1}]
+
+-- Correctness: expression GROUP BY
+SELECT id + 1 AS e, count(*) AS cnt FROM aps_single GROUP BY id + 1 ORDER BY id + 1;
+→ [{"e":2,"cnt":1},{"e":3,"cnt":1},{"e":4,"cnt":1},{"e":5,"cnt":1},{"e":6,"cnt":1}]
+
+-- Correctness: composite PK grouped aggregate
+SELECT a, b, count(*) AS c FROM aps_comp GROUP BY a, b ORDER BY a, b;
+→ [{"a":1,"b":1,"c":1},{"a":1,"b":2,"c":1},{"a":2,"b":1,"c":1},{"a":2,"b":2,"c":1},{"a":3,"b":1,"c":1}]
+
+-- Correctness: prefix GROUP BY on composite PK
+SELECT a, sum(c) AS total FROM aps_comp GROUP BY a ORDER BY a;
+→ [{"a":1,"total":30},{"a":2,"total":70},{"a":3,"total":50}]

package/test/logic/11-joins.sqllogic

@@ -0,0 +1,86 @@
+-- joins.sqllogic - Testing JOIN clauses
+
+-- Setup tables
+CREATE TABLE t_left (id INTEGER PRIMARY KEY, val_l TEXT);
+CREATE TABLE t_right (id INTEGER PRIMARY KEY, val_r TEXT, left_id INTEGER);
+
+INSERT INTO t_left VALUES (1, 'L1'), (2, 'L2'), (3, 'L3');
+INSERT INTO t_right VALUES (10, 'R1', 1), (20, 'R2', 2), (40, 'R4', 4);
+
+-- INNER JOIN
+SELECT l.id, l.val_l, r.id, r.val_r FROM t_left l JOIN t_right r ON l.id = r.left_id ORDER BY l.id;
+→ [{"id":1,"val_l":"L1","id:1":10,"val_r":"R1"},{"id":2,"val_l":"L2","id:1":20,"val_r":"R2"}]
+
+-- INNER JOIN with aliases
+SELECT l.id as left_id, r.id as right_id FROM t_left l JOIN t_right r ON l.id = r.left_id ORDER BY left_id;
+→ [{"left_id":1,"right_id":10},{"left_id":2,"right_id":20}]
+
+-- LEFT JOIN
+SELECT l.id, l.val_l, r.id, r.val_r FROM t_left l LEFT JOIN t_right r ON l.id = r.left_id ORDER BY l.id;
+→ [{"id":1,"val_l":"L1","id:1":10,"val_r":"R1"},{"id":2,"val_l":"L2","id:1":20,"val_r":"R2"},{"id":3,"val_l":"L3","id:1":null,"val_r":null}]
+
+-- CROSS JOIN
+SELECT count(*) FROM t_left CROSS JOIN t_right;
+→ [{"count(*)":9}]
+SELECT l.id, r.id FROM t_left l CROSS JOIN t_right r ORDER BY l.id, r.id LIMIT 2;
+→ [{"id":1,"id:1":10},{"id":1,"id:1":20}]
+
+-- JOIN with WHERE clause
+SELECT l.id, r.val_r FROM t_left l JOIN t_right r ON l.id = r.left_id WHERE r.id = 10;
+→ [{"id":1,"val_r":"R1"}]
+
+-- Multiple JOINs (requires a third table setup)
+CREATE TABLE t_extra (id INTEGER PRIMARY KEY, right_id INTEGER, val_e TEXT);
+INSERT INTO t_extra VALUES (100, 10, 'E1'), (200, 20, 'E2');
+SELECT l.id, r.id, e.id FROM t_left l JOIN t_right r ON l.id = r.left_id JOIN t_extra e ON r.id = e.right_id ORDER BY l.id;
+→ [{"id":1,"id:1":10,"id:2":100},{"id":2,"id:1":20,"id:2":200}]
+
+DROP TABLE t_extra;
+-- run
+
+-- RIGHT JOIN: every right row appears; r.id=40 (left_id=4) has no left match → null-left.
+SELECT l.id, r.id FROM t_left l RIGHT JOIN t_right r ON l.id = r.left_id ORDER BY r.id;
+→ [{"id":1,"id:1":10},{"id":2,"id:1":20},{"id":null,"id:1":40}]
+
+-- FULL JOIN: matched rows plus l.id=3 (no right) null-right and r.id=40 (no left) null-left.
+SELECT l.id, r.id FROM t_left l FULL JOIN t_right r ON l.id = r.left_id ORDER BY coalesce(l.id, r.id);
+→ [{"id":1,"id:1":10},{"id":2,"id:1":20},{"id":3,"id:1":null},{"id":null,"id:1":40}]
+
+DROP TABLE t_left;
+DROP TABLE t_right;
+
+-- ===================================================================
+-- Join elimination - FK→PK
+-- Regression coverage for rule-join-elimination: rewritten plans must
+-- produce the same rows as the un-rewritten queries.
+-- ===================================================================
+
+CREATE TABLE je_customers (id INTEGER PRIMARY KEY, name TEXT, region TEXT);
+CREATE TABLE je_orders (
+    order_id INTEGER PRIMARY KEY,
+    customer_id INTEGER NOT NULL REFERENCES je_customers(id),
+    total REAL
+);
+
+INSERT INTO je_customers VALUES (1, 'Acme', 'EU'), (2, 'Beta', 'US');
+INSERT INTO je_orders VALUES (10, 1, 99.0), (11, 2, 49.5), (12, 1, 12.0);
+
+-- LEFT JOIN eliminable: no right-side columns selected
+SELECT order_id, total FROM je_orders LEFT JOIN je_customers ON je_orders.customer_id = je_customers.id ORDER BY order_id;
+→ [{"order_id":10,"total":99.0},{"order_id":11,"total":49.5},{"order_id":12,"total":12.0}]
+
+-- INNER JOIN eliminable: NOT NULL FK
+SELECT order_id FROM je_orders JOIN je_customers ON je_orders.customer_id = je_customers.id ORDER BY order_id;
+→ [{"order_id":10},{"order_id":11},{"order_id":12}]
+
+-- Eliminable view: outer query selects only FK-side columns
+CREATE VIEW je_order_view AS
+  SELECT o.order_id, o.total, c.name AS cust_name
+  FROM je_orders o LEFT JOIN je_customers c ON o.customer_id = c.id;
+
+SELECT order_id, total FROM je_order_view ORDER BY order_id;
+→ [{"order_id":10,"total":99.0},{"order_id":11,"total":49.5},{"order_id":12,"total":12.0}]
+
+DROP VIEW je_order_view;
+DROP TABLE je_orders;
+DROP TABLE je_customers;