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';

SELECT inheritance_id FROM inheritance_parent;

COMMIT AND CHAIN;

SAVEPOINT s;

BEGIN ISOLATION LEVEL SERIALIZABLE;

BEGIN DEFERRABLE;

SET __neki.transaction_mode = 'atomic';

SET SESSION AUTHORIZATION 'someone';

ALTER DATABASE db SET work_mem FROM CURRENT;

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

EXPLAIN neki_plan LISTEN c;

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

EXPLAIN (BUFFERS) SELECT user_id FROM users;

EXPLAIN (FORMAT YAML) SELECT user_id FROM users;

SET __neki.target = 'replica';
CREATE PUBLICATION p FOR TABLE users;

INSERT INTO multiple_column_primary_index (user_id, tenant_id) VALUES (1, 2);

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

COPY users TO STDOUT;

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

COPY ref_countries TO STDOUT;

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

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

COPY multiple_column_primary_index (user_id, tenant_id) FROM STDIN;

COPY ref_countries (country_id, name) FROM STDIN;

COPY users TO PROGRAM 'cat';

COPY (SELECT user_id FROM users) FROM STDIN;

COPY (SELECT user_id FROM users) TO STDOUT;

COPY public.notes FROM STDIN WHERE id > 1;

COPY notes_with_identity (msg) FROM STDIN;

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

COPY users (user_id, name) FROM STDIN WITH (ENCODING 'LATIN1');

SELECT 1; COPY notes FROM STDIN;

COPY notes FROM STDIN;

COPY mv_users FROM STDIN;

SELECT pg_advisory_lock(1) FROM users WHERE user_id = 1;
SELECT pg_advisory_lock(2) FROM users WHERE user_id = 900;

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

SELECT pg_advisory_xact_lock(user_id) FROM users;

CREATE TABLE users_adv_lock AS SELECT pg_advisory_xact_lock(1);

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$DECLARE r record; BEGIN FOREACH r IN ARRAY ARRAY[1] LOOP END LOOP; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$DECLARE c cursor FOR SELECT 1; BEGIN FOREACH c IN ARRAY ARRAY[1] LOOP END LOOP; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$DECLARE a int[]; BEGIN a[1:2] := ARRAY[1,2]; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$DECLARE r record; BEGIN r := ROW(1,2); END$$;

CREATE FUNCTION f() RETURNS int LANGUAGE plpgsql AS $$DECLARE r record; BEGIN SELECT r.a INTO r; RETURN 1; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$DECLARE r users; BEGIN SELECT * INTO r FROM users WHERE user_id = 1; END$$;

CREATE FUNCTION f() RETURNS int LANGUAGE plpgsql AS $$DECLARE r record; BEGIN FOR r IN SELECT 1 AS a UNION SELECT 'x' AS a LOOP END LOOP; RETURN 1; END$$;

CREATE FUNCTION f() RETURNS int LANGUAGE plpgsql SET work_mem = '4MB' AS $$BEGIN RETURN 1; END$$;

CREATE FUNCTION f(anyelement) RETURNS anyelement LANGUAGE plpgsql AS $$BEGIN RETURN $1; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$BEGIN GET DIAGNOSTICS STACKED x = RETURNED_SQLSTATE; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$<<outer>> BEGIN EXIT outer; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$BEGIN RAISE; END$$;

CREATE FUNCTION f() RETURNS void LANGUAGE plpgsql AS $$BEGIN RAISE EXCEPTION 'bad' USING HINT = 'fix it'; END$$;

CREATE FUNCTION f() RETURNS SETOF int LANGUAGE plpgsql AS $$BEGIN RETURN NEXT; END$$;

CREATE FUNCTION f() RETURNS SETOF int LANGUAGE plpgsql AS $$BEGIN RETURN QUERY EXECUTE 'SELECT 1'; END$$;

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

UPDATE user_tags SET tag_ids[1:2] = ARRAY[7,8] WHERE user_id = 1;

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;

WITH a AS (SELECT user_id FROM users WHERE user_id = 1), b AS (SELECT user_id FROM a) UPDATE orders SET status = 'x' FROM b WHERE orders.user_id = b.user_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 WHERE nextval('public.my_sequence') > 0 ORDER BY (SELECT max(total_amount) FROM orders);

SELECT * FROM users WHERE (user_id, name) > ALL(SELECT user_id, name FROM orders);

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 * FROM users, LATERAL (VALUES (users.user_id)) t(x);

SELECT t1.user_id, t2.user_id FROM user_tags t1 FULL OUTER JOIN user_tags t2 ON ROW(t1.user_id::smallint) = ROW(t2.user_id::numeric);

SELECT 1 FROM users u JOIN products p ON u.user_id + p.user_id = 5;

SELECT phone FROM accounts WHERE email = 'a@example.com' AND category = 2;

SELECT name FROM users WHERE user_id = ANY($1);

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, status) VALUES (91021, 91020, DATE '2026-09-09', 'new'), (91022, 91020, DATE '2026-09-09', 'held') ON CONFLICT (order_id) DO NOTHING RETURNING order_id, user_id;

INSERT INTO users (name) VALUES ('foo');

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';

UPDATE view_users SET name = 'x' WHERE user_id = 1;

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);

SELECT x FROM (SELECT user_id FROM users) v(x);

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;

TRUNCATE inheritance_parent 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 * FROM public.my_sequence;

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;

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 (91035, 'a', 'a@x') ON CONFLICT (user_id) DO NOTHING RETURNING old.user_id;

INSERT INTO users (user_id, name, email) VALUES (1, 'a', 'a@x') 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 (INSERT INTO users (user_id) VALUES (1) RETURNING user_id);

SELECT ARRAY(SELECT user_id FROM users WHERE user_id < 10);

SELECT eqsel(NULL, 0, NULL, 0);

SELECT 'x'::gtsvector;

SELECT '1'::unknown::int2vector;

CREATE FUNCTION double(int) RETURNS int LANGUAGE sql AS 'SELECT $1 * 2';
SELECT name FROM users WHERE user_id = double(2);

CREATE OPERATOR === (LEFTARG = int, RIGHTARG = int, FUNCTION = int4eq);
SELECT name FROM users WHERE user_id === 1;

CREATE AGGREGATE my_sum(int) (SFUNC = int4pl, STYPE = int);
SELECT my_sum(user_id) FROM users;

CREATE AGGREGATE my_sum(int) (SFUNC = int4pl, STYPE = int);
SELECT my_sum(user_id) FROM users;

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

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

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

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;

SELECT lo_create(0);

CREATE LANGUAGE plperl;

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 mood RENAME VALUE 'sad' TO 'unhappy';

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 * 1000000 + local_id);

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