Neki error codes

not implemented: [108] This subquery shape is unavailable in ORDER BY.

SELECT user_id INTO users_copy FROM users WHERE user_id = 1;

ALTER SYSTEM SET work_mem = '4MB';

CREATE TABLE inheritance_parent (inheritance_id bigint PRIMARY KEY);
CREATE TABLE inheritance_child () INHERITS (inheritance_parent);
SELECT inheritance_id FROM inheritance_parent;

PREPARE TRANSACTION 'gid';

SET __neki.tx_mode = 'atomic';

SET work_mem FROM CURRENT;

SET TRANSACTION SNAPSHOT '00000003-0000001B-1';

EXPLAIN (NEKI_PLAN, ANALYZE) CREATE TABLE users_copy AS SELECT 1;

EXPLAIN (NEKI_PLAN, ANALYZE) WITH u AS (UPDATE users SET name = 'x' WHERE user_id = 1 RETURNING user_id) SELECT * FROM u;

EXPLAIN (NEKI_PLAN, GENERIC_PLAN) SELECT user_id FROM users;

SET client_min_messages = 'debug1';

DECLARE c CURSOR WITH HOLD FOR SELECT count(*), now() FROM users;

BEGIN;
DECLARE c CURSOR FOR SELECT g FROM generate_series(1, 5) g;
FETCH 1 FROM c;
SET DateStyle = 'SQL, DMY';
FETCH 1 FROM c;

BEGIN;
DECLARE c CURSOR FOR SELECT u.name, o.status FROM users u JOIN orders o ON u.name = o.status FOR UPDATE;

BEGIN;
CREATE AGGREGATE my_moving_sum(int) (SFUNC = int4pl, STYPE = int, MSFUNC = int4pl, MINVFUNC = int4mi, MSTYPE = int);
SELECT my_moving_sum(user_id) OVER (ORDER BY user_id ROWS 1 PRECEDING) FROM users;

INSERT INTO devices (owner_id, device_no) VALUES (1, 2);

SELECT __neki.set_data_topology($${
  "authoritative_shard_group": "meta",
  "shard_indexes": {
    "modulo_user_id": {"type": "modulo", "columns": ["user_id"], "index_params": {"modulus": "2"}}
  },
  "shard_groups": [
    {"uid": "meta", "key_ranges": [{"shard_uid": "shard-meta"}]},
    {"uid": "user_data", "default_shard_index": "modulo_user_id",
     "key_ranges": [{"shard_uid": "shard-a", "end": "80"}, {"shard_uid": "shard-b", "start": "80"}]}
  ],
  "databases": {"app": {"advisory_lock_shard_group": "user_data"}}
}$$, true);

COPY users FROM '/tmp/users.csv';

COPY ref_countries FROM '/tmp/countries.csv';

COPY public.accounts (account_id, label) FROM STDIN;

COPY devices (owner_id, device_no) FROM STDIN;

ALTER TABLE ref_countries ADD COLUMN created_at timestamptz DEFAULT clock_timestamp();
COPY ref_countries (country_id, name) FROM STDIN;

COPY users TO PROGRAM 'cat';

COPY (SELECT user_id FROM users) TO STDOUT;

COPY public.notes FROM STDIN WHERE id > 1;

COPY users (user_id, name, email) FROM STDIN;

COPY users (user_id, name, email, created_at) FROM STDIN WITH (ON_ERROR ignore);

COPY users (user_id, name, email, created_at) FROM STDIN WITH (ENCODING 'SJIS');

SELECT 1; COPY notes FROM STDIN;

COPY notes FROM STDIN;

SELECT __neki.set_data_topology($${
  "authoritative_shard_group": "meta",
  "shard_indexes": {
    "modulo_user_id": {"type": "modulo", "columns": ["user_id"], "index_params": {"modulus": "2"}}
  },
  "shard_groups": [
    {"uid": "meta", "key_ranges": [{"shard_uid": "shard-meta"}]},
    {"uid": "user_data", "default_shard_index": "modulo_user_id",
     "key_ranges": [{"shard_uid": "shard-a", "end": "80"}, {"shard_uid": "shard-b", "start": "80"}]}
  ],
  "databases": {"app": {"notify_shard_group": "user_data"}}
}$$, true);

COPY users FROM PROGRAM 'cat users.csv';

SELECT pg_advisory_lock(1);
SELECT pg_advisory_lock(2);

SELECT pg_advisory_lock(1), pg_advisory_xact_lock(1) FROM users WHERE user_id = 1;

CREATE TABLE users_adv_lock AS SELECT pg_advisory_xact_lock(1);

CREATE TEMP VIEW active_users AS SELECT * FROM users;

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
CREATE FUNCTION cart_size() RETURNS bigint LANGUAGE sql AS $$SELECT count(*) FROM session_cart$$;

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
BEGIN;
SELECT * FROM session_cart;

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
CREATE TABLE relation_refs (id bigint PRIMARY KEY, rc regclass DEFAULT 'session_cart');

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
CREATE TYPE session_cart AS ENUM ('standard', 'express');

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
UPDATE session_cart SET quantity = 2;

CREATE TEMP TABLE session_cart (sku text PRIMARY KEY, quantity integer NOT NULL);
SELECT pg_relation_size('session_cart');

DO $$DECLARE r record; x text; BEGIN IF random() > 2 THEN SELECT 1 AS a INTO r; ELSE SELECT 'x'::text AS a INTO r; END IF; x := r.a; END$$;

CREATE FUNCTION pinned_to_primary() RETURNS int LANGUAGE plpgsql SET __neki.target = 'primary' AS $$BEGIN RETURN 1; END$$;
SELECT pinned_to_primary();

DO $$DECLARE x text; BEGIN GET DIAGNOSTICS x = PG_CONTEXT; END$$;

CREATE DOMAIN positive_int AS int CHECK (VALUE > 0);
CREATE FUNCTION fetch_positive() RETURNS SETOF positive_int LANGUAGE plpgsql AS $$BEGIN RETURN QUERY EXECUTE 'FETCH ALL FROM c'; END$$;
BEGIN;
DECLARE c CURSOR FOR SELECT 1::positive_int;
SELECT * FROM fetch_positive();

DO $$DECLARE n int; BEGIN n := DISTINCT 1.5; END$$;

CREATE FUNCTION all_users() RETURNS SETOF record LANGUAGE plpgsql AS $$BEGIN RETURN QUERY SELECT user_id, name FROM users; END$$;
SELECT * FROM all_users() AS t(user_id bigint, name varchar);

DO $$DECLARE r record; t text := 'users'; BEGIN EXECUTE 'SELECT * FROM ' || t || ' LIMIT 1' INTO r; END$$;

DO $$DECLARE r record; t text := 'users'; BEGIN FOR r IN EXECUTE 'SELECT * FROM ' || t LOOP END LOOP; END$$;

DO $$DECLARE c refcursor; x text; BEGIN OPEN c FOR EXPLAIN SELECT * FROM users; SET search_path = pg_catalog; FETCH c INTO x; END$$;

DO $$DECLARE c refcursor := 'c'; r record; BEGIN OPEN c FOR EXECUTE 'SELECT 1 AS a'; FETCH c INTO r; END$$;

DO $$DECLARE r record; BEGIN SELECT * INTO r FROM json_to_record('{"a": 1}'::json) AS x(a int); END$$;

VALUES ((SELECT 1));

UPDATE users SET name = (SELECT 'x') FROM orders WHERE users.user_id = orders.user_id;

UPDATE users SET name = 'x' WHERE current_setting(name, true) = 'foo';

UPDATE users SET name = 'x' WHERE user_id = 1 RETURNING WITH (OLD AS o) now();

DELETE FROM users USING orders WHERE users.created_at < orders.created_at + (extract(epoch from now()) || ' seconds')::interval;

DELETE FROM accounts WHERE account_id = 1 RETURNING account_id;

SELECT p.user_id, row_number() OVER (PARTITION BY p.user_id ORDER BY p.product_id) FROM users u JOIN products p ON u.user_id % 2 = p.user_id % 2;

SELECT count(*), date_trunc('day', now()) FROM users GROUP BY date_trunc('day', now());

SELECT name FROM users ORDER BY user_id > ALL (SELECT user_id FROM orders);

SELECT user_id, count(*) FROM orders GROUP BY user_id HAVING count(*) IN (SELECT user_id FROM users WHERE users.user_id = orders.user_id);

SELECT u.user_id FROM users u WHERE u.name = (SELECT min(o.status) FROM orders o WHERE o.total_amount = u.user_id GROUP BY o.status);

SELECT k FROM jsonb_each((SELECT '{"a": 1}'::jsonb)) AS s(k, v);

SELECT 1 FROM users u FULL JOIN products p ON u.user_id > p.user_id;

INSERT INTO users (user_id, name) VALUES (1, 'a' || (SELECT 'b'));

INSERT INTO users (user_id, email, name) SELECT p.product_id, p.name, p.name FROM products p ON CONFLICT (user_id) DO UPDATE SET name = excluded.name;

INSERT INTO users (user_id) VALUES (generate_series(1,3));

INSERT INTO orders (order_id, user_id, order_date) VALUES (91021, 91020, DATE '2026-09-09'), (91022, 91020, DATE '2026-09-09') ON CONFLICT (order_id) DO UPDATE SET status = 'held' WHERE orders.status IS NULL RETURNING order_id, user_id;

ALTER TABLE ref_countries ADD COLUMN seq bigint GENERATED BY DEFAULT AS IDENTITY;
UPDATE ref_countries SET seq = DEFAULT;

MERGE INTO users t USING (SELECT 1 AS user_id) s ON t.user_id = s.user_id WHEN MATCHED THEN UPDATE SET name = 'x';

CREATE VIEW view_users AS SELECT user_id, name FROM users;
UPDATE view_users SET name = 'x' WHERE user_id = 1;

CREATE MATERIALIZED VIEW mv_users AS SELECT user_id, name FROM users;
SELECT * FROM mv_users WHERE user_id = 1;

SELECT account_id FROM accounts WHERE email = 'a@example.com' INTERSECT SELECT user_id FROM products WHERE user_id = 500;

SELECT name, count(*) FROM users GROUP BY GROUPING SETS ((name), ());

SELECT * FROM users TABLESAMPLE bernoulli(50);

DELETE FROM users WHERE CURRENT OF c;

SELECT DISTINCT ROW(random()) FROM users;

SELECT nextval('public.my_sequence') + (SELECT max(order_id) FROM orders WHERE orders.user_id = users.user_id) FROM users;

TRUNCATE users RESTART IDENTITY CASCADE;

CREATE TABLE logs (log_id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY);
CREATE TABLE logs_archive () INHERITS (logs);
TRUNCATE logs RESTART IDENTITY;

SELECT json_agg(t.*) FROM (SELECT order_id AS t FROM orders) t;

SELECT (SELECT max(u.user_id)) FROM users u;

SELECT user_id FROM users WHERE EXISTS (SELECT 1 FROM orders LIMIT users.user_id);

SELECT name FROM users ORDER BY name FETCH FIRST 2 ROWS WITH TIES;

SELECT u.user_id FROM users u LEFT JOIN orders o ON u.user_id = o.user_id ORDER BY generate_series(u.user_id::int, (u.user_id + 1)::int) LIMIT 2;

CREATE TABLE audit_log (log_id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, user_id bigint, action text);
INSERT INTO audit_log (user_id, action) OVERRIDING USER VALUE VALUES (100, 'login');

INSERT INTO user_tags (user_id, tag_ids[$1]) VALUES (1, 2);

INSERT INTO users (user_id, name, email) VALUES (1, 'a', 'a@example.com'), (900, 'b', 'b@example.com') ON CONFLICT (user_id) DO NOTHING RETURNING old.user_id;

INSERT INTO users (user_id, name, email) VALUES (1, 'a', 'a@example.com'), (900, 'b', 'b@example.com') ON CONFLICT (user_id) DO NOTHING RETURNING now();

UPDATE users SET user_id = nextval('public.my_sequence') WHERE user_id = 1;

UPDATE users SET name = 'x' WHERE COALESCE(nextval('public.my_sequence') > 0, false);

UPDATE users SET name = nextval('public.my_sequence')::text WHERE random() < 0.5;

SELECT count(*), row_number() OVER () FROM products;

SELECT x FROM (VALUES (1),(2) ORDER BY column1 + 1) v(x);

SELECT cardinality(ARRAY(SELECT unnest(ARRAY['a','b']) INTERSECT SELECT unnest(ARRAY['b','c'])));

SELECT (VALUES (1));

SELECT user_id FROM users ORDER BY ARRAY(SELECT order_id FROM orders WHERE user_id = 1);

SELECT j FROM (users u JOIN orders o ON u.user_id = o.user_id) AS j;

SELECT count(*) + (random() + length(name)) FROM users GROUP BY random() + length(name);

CREATE SCHEMA archive;
CREATE TABLE archive.notes (id bigint PRIMARY KEY, body text);
SELECT 1 FROM public.notes, archive.notes;

SELECT JSON_ARRAY(SELECT 1);

INSERT INTO users (user_id, name, email) VALUES (1, 'a', 'a@example.com');
SELECT max(ROW(CASE WHEN user_id = 1 THEN ROW(name::varchar(5)) ELSE ROW(name::varchar(10)) END)) FROM users;

SELECT * FROM users u, LATERAL JSON_TABLE(to_jsonb(u.name), '$' COLUMNS (a text PATH '$')) jt;

SELECT (SELECT a FROM orders u LIMIT 1) FROM users u(a) WHERE u.a = 1;

SELECT 1 FROM (public.users JOIN orders USING (user_id)) j, pg_catalog.pg_class users;

SELECT * FROM pg_get_catalog_foreign_keys();

SELECT pg_relation_filepath('users');

SELECT pg_indexam_has_property(100000, 'can_order');

CREATE OPERATOR CLASS cls DEFAULT FOR TYPE int USING btree AS OPERATOR 1 <;

CREATE OPERATOR FAMILY fam USING btree;

CREATE TEXT SEARCH CONFIGURATION public.neki_config (COPY = pg_catalog.simple);

CREATE TEXT SEARCH DICTIONARY public.neki_simple (TEMPLATE = pg_catalog.simple);

CREATE EVENT TRIGGER e ON ddl_command_start EXECUTE FUNCTION f();

CREATE RULE r AS ON DELETE TO public.users DO INSTEAD NOTHING;

CREATE TABLESPACE ts LOCATION '/tmp/ts';

CREATE ACCESS METHOD am TYPE INDEX HANDLER f;

CREATE COLLATION c (LOCALE = 'C');

CREATE CONVERSION cv FOR 'UTF8' TO 'LATIN1' FROM f;

CREATE FOREIGN DATA WRAPPER w;

CREATE SERVER srv FOREIGN DATA WRAPPER w;

CREATE FOREIGN TABLE ft (a int) SERVER srv;

CREATE USER MAPPING FOR testuser SERVER srv;

CREATE TEXT SEARCH PARSER p (START = f, GETTOKEN = g, END = h, LEXTYPES = i);

CREATE TEXT SEARCH TEMPLATE tm (LEXIZE = f);

CREATE TRANSFORM FOR int LANGUAGE sql (FROM SQL WITH FUNCTION f(int), TO SQL WITH FUNCTION g(int));

ALTER TYPE pair ADD ATTRIBUTE third int;

LOAD 'libexample';

IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO public;

ALTER TABLE t ALTER COLUMN a SET STATISTICS 100;

ALTER FOREIGN TABLE ft ALTER COLUMN a OPTIONS (ADD b 'c');

CREATE FUNCTION f() RETURNS int LANGUAGE c AS 'lib', 'sym';

CREATE PROCEDURE p() LANGUAGE plperl AS 'return 1';

CREATE LANGUAGE l HANDLER h;

ALTER DOMAIN positive_int RENAME CONSTRAINT positive_int_check TO positive_check;

ALTER DOMAIN positive_int SET DEFAULT 1;

CREATE DATABASE db IS_TEMPLATE true;

CREATE DATABASE db TABLESPACE ts;

CREATE DATABASE db LOCALE 'xx_not_a_locale';

ALTER TYPE region RENAME VALUE 'eu' TO 'europe';

ALTER TABLE t ALTER COLUMN a SET STORAGE EXTERNAL;

ALTER TABLE t ALTER COLUMN a SET COMPRESSION pglz;

ALTER TABLE regional_accounts ALTER COLUMN account_id SET EXPRESSION AS (region_id * 2000000 + local_id);

ALTER TABLE notes ADD COLUMN seq bigint GENERATED BY DEFAULT AS IDENTITY;
ALTER TABLE notes ALTER COLUMN seq RESTART;

CREATE TYPE pg_temp.mood AS ENUM ('happy', 'sad');

CREATE FUNCTION pg_temp.one() RETURNS int LANGUAGE sql AS 'SELECT 1';

CREATE STATISTICS pg_temp.users_stats ON user_id, name FROM users;

CREATE DATABASE reports ENCODING 'EUC_TW';

CREATE TYPE note_type AS (id bigint, body text);
ALTER TABLE notes OF note_type;

CREATE TABLE events (event_id bigint, event_date date) PARTITION BY RANGE (event_date);
CREATE TABLE events_2026 (event_id bigint, event_date date);
ALTER TABLE events ATTACH PARTITION events_2026 FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');

ALTER TABLE users DISABLE TRIGGER ALL;

CREATE TABLE notifications AS SELECT pg_notify('c', 'p');

CREATE TYPE user_location AS (region_id integer, city text);
ALTER TABLE users ADD COLUMN location user_location;
WITH RECURSIVE r AS (SELECT u.user_id, u.location FROM users u WHERE u.user_id = 1 UNION ALL SELECT u.user_id, u.location FROM users u JOIN r ON u.location = r.location AND u.user_id = r.user_id + 1) SELECT * FROM r;

WITH c AS MATERIALIZED (SELECT CASE WHEN user_id > 0 THEN ROW(user_id) ELSE ROW(user_id, user_id) END AS r, user_id FROM users) SELECT r FROM c UNION ALL SELECT r FROM c;

CREATE TYPE base_type (INPUT = int4in, OUTPUT = int4out, INTERNALLENGTH = 4);

WITH batch AS MATERIALIZED (SELECT user_id FROM users), updated AS (UPDATE users t SET name = 'x' FROM batch b WHERE t.user_id = b.user_id RETURNING 1) SELECT count(*), (SELECT count(*) FROM updated) FROM users WHERE name = 'x';

WITH m AS (MERGE INTO users t USING ref_countries s ON t.user_id = s.country_id WHEN MATCHED THEN UPDATE SET name = 'x' RETURNING t.user_id) SELECT * FROM m;

WITH RECURSIVE t AS (SELECT user_id, name FROM users WHERE user_id = 1 UNION ALL SELECT u.user_id, u.name FROM users u JOIN t ON u.name = t.name AND u.user_id > t.user_id) SEARCH DEPTH FIRST BY user_id SET ordercol SELECT * FROM t;

ALTER DATABASE postgres REFRESH COLLATION VERSION;

WITH c AS (SELECT user_id FROM users WHERE user_id = 2) SELECT c.user_id, d.user_id AS du FROM c, (WITH c AS (SELECT user_id FROM orders WHERE user_id = 2) SELECT user_id FROM c) d;

WITH RECURSIVE seed AS (SELECT 1 AS n), t(n) AS (SELECT n FROM seed UNION ALL SELECT n + 1 FROM t WHERE n < 3) SELECT * FROM t;