-- Arrays of float4, float8, bytea, point, box and circle in a JSON_ARRAY()
-- expression index, then the setting that changes their output.  Run with
--   psql -X -d <db> -f repro-arrays.sql.txt
-- One line per case:
--   ORACLE <type>/<shape> | index_exists index_used | index=N seq=M | verdict
-- no-index: CREATE INDEX rejected; DIVERGE: index scan and seq scan
-- disagree (stale index); same: they agree.
\set VERBOSITY terse
\pset tuples_only on
\pset format unaligned

-- float8: SET extra_float_digits = 0
CREATE DOMAIN d_float8 AS float8;
CREATE DOMAIN da_float8 AS float8[];
CREATE TABLE r_float8_array (v float8[]);
INSERT INTO r_float8_array VALUES (ARRAY['0.30000000000000004'::float8]);
CREATE INDEX ON r_float8_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float8_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8])::float8[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float8_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float8_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8])::float8[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float8/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float8_array'::regclass) AS has_idx) x;
CREATE TABLE r_float8_domain_array (v d_float8[]);
INSERT INTO r_float8_domain_array VALUES (ARRAY['0.30000000000000004'::float8::d_float8]);
CREATE INDEX ON r_float8_domain_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float8_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8::d_float8])::d_float8[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float8_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float8_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8::d_float8])::d_float8[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float8/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float8_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_float8_2d_array (v float8[]);
INSERT INTO r_float8_2d_array VALUES (ARRAY[['0.30000000000000004'::float8, '0.30000000000000004'::float8], ['0.30000000000000004'::float8, '0.30000000000000004'::float8]]);
CREATE INDEX ON r_float8_2d_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float8_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['0.30000000000000004'::float8, '0.30000000000000004'::float8], ['0.30000000000000004'::float8, '0.30000000000000004'::float8]])::float8[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float8_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float8_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['0.30000000000000004'::float8, '0.30000000000000004'::float8], ['0.30000000000000004'::float8, '0.30000000000000004'::float8]])::float8[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float8/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float8_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_float8_domain_over_array (v da_float8);
INSERT INTO r_float8_domain_over_array VALUES (ARRAY['0.30000000000000004'::float8]::da_float8);
CREATE INDEX ON r_float8_domain_over_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float8_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8]::da_float8)::da_float8 RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float8_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float8_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['0.30000000000000004'::float8]::da_float8)::da_float8 RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float8/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float8_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_float8_scalar (v float8);
INSERT INTO r_float8_scalar VALUES ('0.30000000000000004'::float8);
CREATE INDEX ON r_float8_scalar ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float8_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('0.30000000000000004'::float8)::float8 RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float8_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float8_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('0.30000000000000004'::float8)::float8 RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float8/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float8_scalar'::regclass) AS has_idx) x;

-- float4: SET extra_float_digits = 0
CREATE DOMAIN d_float4 AS float4;
CREATE DOMAIN da_float4 AS float4[];
CREATE TABLE r_float4_array (v float4[]);
INSERT INTO r_float4_array VALUES (ARRAY['3.3000002'::float4]);
CREATE INDEX ON r_float4_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float4_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4])::float4[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float4_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float4_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4])::float4[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float4/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float4_array'::regclass) AS has_idx) x;
CREATE TABLE r_float4_domain_array (v d_float4[]);
INSERT INTO r_float4_domain_array VALUES (ARRAY['3.3000002'::float4::d_float4]);
CREATE INDEX ON r_float4_domain_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float4_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4::d_float4])::d_float4[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float4_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float4_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4::d_float4])::d_float4[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float4/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float4_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_float4_2d_array (v float4[]);
INSERT INTO r_float4_2d_array VALUES (ARRAY[['3.3000002'::float4, '3.3000002'::float4], ['3.3000002'::float4, '3.3000002'::float4]]);
CREATE INDEX ON r_float4_2d_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float4_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['3.3000002'::float4, '3.3000002'::float4], ['3.3000002'::float4, '3.3000002'::float4]])::float4[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float4_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float4_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['3.3000002'::float4, '3.3000002'::float4], ['3.3000002'::float4, '3.3000002'::float4]])::float4[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float4/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float4_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_float4_domain_over_array (v da_float4);
INSERT INTO r_float4_domain_over_array VALUES (ARRAY['3.3000002'::float4]::da_float4);
CREATE INDEX ON r_float4_domain_over_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float4_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4]::da_float4)::da_float4 RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float4_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float4_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['3.3000002'::float4]::da_float4)::da_float4 RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float4/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float4_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_float4_scalar (v float4);
INSERT INTO r_float4_scalar VALUES ('3.3000002'::float4);
CREATE INDEX ON r_float4_scalar ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_float4_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('3.3000002'::float4)::float4 RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_float4_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_float4_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('3.3000002'::float4)::float4 RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'float4/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_float4_scalar'::regclass) AS has_idx) x;

-- bytea: SET bytea_output = escape
CREATE DOMAIN d_bytea AS bytea;
CREATE DOMAIN da_bytea AS bytea[];
CREATE TABLE r_bytea_array (v bytea[]);
INSERT INTO r_bytea_array VALUES (ARRAY['\x01ff'::bytea]);
CREATE INDEX ON r_bytea_array ((json_array(v RETURNING jsonb)));
SET bytea_output = escape;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_bytea_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea])::bytea[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_bytea_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_bytea_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea])::bytea[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'bytea/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_bytea_array'::regclass) AS has_idx) x;
CREATE TABLE r_bytea_domain_array (v d_bytea[]);
INSERT INTO r_bytea_domain_array VALUES (ARRAY['\x01ff'::bytea::d_bytea]);
CREATE INDEX ON r_bytea_domain_array ((json_array(v RETURNING jsonb)));
SET bytea_output = escape;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_bytea_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea::d_bytea])::d_bytea[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_bytea_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_bytea_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea::d_bytea])::d_bytea[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'bytea/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_bytea_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_bytea_2d_array (v bytea[]);
INSERT INTO r_bytea_2d_array VALUES (ARRAY[['\x01ff'::bytea, '\x01ff'::bytea], ['\x01ff'::bytea, '\x01ff'::bytea]]);
CREATE INDEX ON r_bytea_2d_array ((json_array(v RETURNING jsonb)));
SET bytea_output = escape;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_bytea_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['\x01ff'::bytea, '\x01ff'::bytea], ['\x01ff'::bytea, '\x01ff'::bytea]])::bytea[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_bytea_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_bytea_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[['\x01ff'::bytea, '\x01ff'::bytea], ['\x01ff'::bytea, '\x01ff'::bytea]])::bytea[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'bytea/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_bytea_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_bytea_domain_over_array (v da_bytea);
INSERT INTO r_bytea_domain_over_array VALUES (ARRAY['\x01ff'::bytea]::da_bytea);
CREATE INDEX ON r_bytea_domain_over_array ((json_array(v RETURNING jsonb)));
SET bytea_output = escape;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_bytea_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea]::da_bytea)::da_bytea RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_bytea_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_bytea_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY['\x01ff'::bytea]::da_bytea)::da_bytea RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'bytea/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_bytea_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_bytea_scalar (v bytea);
INSERT INTO r_bytea_scalar VALUES ('\x01ff'::bytea);
CREATE INDEX ON r_bytea_scalar ((json_array(v RETURNING jsonb)));
SET bytea_output = escape;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_bytea_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('\x01ff'::bytea)::bytea RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_bytea_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_bytea_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array(('\x01ff'::bytea)::bytea RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'bytea/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_bytea_scalar'::regclass) AS has_idx) x;

-- point: SET extra_float_digits = 0
CREATE DOMAIN d_point AS point;
CREATE DOMAIN da_point AS point[];
CREATE TABLE r_point_array (v point[]);
INSERT INTO r_point_array VALUES (ARRAY[point(0.30000000000000004, 1)]);
CREATE INDEX ON r_point_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_point_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)])::point[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_point_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_point_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)])::point[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'point/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_point_array'::regclass) AS has_idx) x;
CREATE TABLE r_point_domain_array (v d_point[]);
INSERT INTO r_point_domain_array VALUES (ARRAY[point(0.30000000000000004, 1)::d_point]);
CREATE INDEX ON r_point_domain_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_point_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)::d_point])::d_point[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_point_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_point_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)::d_point])::d_point[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'point/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_point_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_point_2d_array (v point[]);
INSERT INTO r_point_2d_array VALUES (ARRAY[[point(0.30000000000000004, 1), point(0.30000000000000004, 1)], [point(0.30000000000000004, 1), point(0.30000000000000004, 1)]]);
CREATE INDEX ON r_point_2d_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_point_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[point(0.30000000000000004, 1), point(0.30000000000000004, 1)], [point(0.30000000000000004, 1), point(0.30000000000000004, 1)]])::point[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_point_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_point_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[point(0.30000000000000004, 1), point(0.30000000000000004, 1)], [point(0.30000000000000004, 1), point(0.30000000000000004, 1)]])::point[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'point/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_point_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_point_domain_over_array (v da_point);
INSERT INTO r_point_domain_over_array VALUES (ARRAY[point(0.30000000000000004, 1)]::da_point);
CREATE INDEX ON r_point_domain_over_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_point_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)]::da_point)::da_point RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_point_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_point_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[point(0.30000000000000004, 1)]::da_point)::da_point RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'point/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_point_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_point_scalar (v point);
INSERT INTO r_point_scalar VALUES (point(0.30000000000000004, 1));
CREATE INDEX ON r_point_scalar ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_point_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((point(0.30000000000000004, 1))::point RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_point_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_point_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((point(0.30000000000000004, 1))::point RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'point/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_point_scalar'::regclass) AS has_idx) x;

-- box: SET extra_float_digits = 0
CREATE DOMAIN d_box AS box;
CREATE DOMAIN da_box AS box[];
CREATE TABLE r_box_array (v box[]);
INSERT INTO r_box_array VALUES (ARRAY[box(point(0.30000000000000004, 0), point(1, 1))]);
CREATE INDEX ON r_box_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_box_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))])::box[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_box_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_box_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))])::box[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'box/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_box_array'::regclass) AS has_idx) x;
CREATE TABLE r_box_domain_array (v d_box[]);
INSERT INTO r_box_domain_array VALUES (ARRAY[box(point(0.30000000000000004, 0), point(1, 1))::d_box]);
CREATE INDEX ON r_box_domain_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_box_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))::d_box])::d_box[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_box_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_box_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))::d_box])::d_box[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'box/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_box_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_box_2d_array (v box[]);
INSERT INTO r_box_2d_array VALUES (ARRAY[[box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))], [box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))]]);
CREATE INDEX ON r_box_2d_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_box_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))], [box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))]])::box[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_box_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_box_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))], [box(point(0.30000000000000004, 0), point(1, 1)), box(point(0.30000000000000004, 0), point(1, 1))]])::box[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'box/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_box_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_box_domain_over_array (v da_box);
INSERT INTO r_box_domain_over_array VALUES (ARRAY[box(point(0.30000000000000004, 0), point(1, 1))]::da_box);
CREATE INDEX ON r_box_domain_over_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_box_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))]::da_box)::da_box RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_box_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_box_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[box(point(0.30000000000000004, 0), point(1, 1))]::da_box)::da_box RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'box/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_box_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_box_scalar (v box);
INSERT INTO r_box_scalar VALUES (box(point(0.30000000000000004, 0), point(1, 1)));
CREATE INDEX ON r_box_scalar ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_box_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((box(point(0.30000000000000004, 0), point(1, 1)))::box RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_box_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_box_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((box(point(0.30000000000000004, 0), point(1, 1)))::box RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'box/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_box_scalar'::regclass) AS has_idx) x;

-- circle: SET extra_float_digits = 0
CREATE DOMAIN d_circle AS circle;
CREATE DOMAIN da_circle AS circle[];
CREATE TABLE r_circle_array (v circle[]);
INSERT INTO r_circle_array VALUES (ARRAY[circle(point(0.30000000000000004, 0), 1)]);
CREATE INDEX ON r_circle_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_circle_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)])::circle[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_circle_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_circle_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)])::circle[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'circle/array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_circle_array'::regclass) AS has_idx) x;
CREATE TABLE r_circle_domain_array (v d_circle[]);
INSERT INTO r_circle_domain_array VALUES (ARRAY[circle(point(0.30000000000000004, 0), 1)::d_circle]);
CREATE INDEX ON r_circle_domain_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_circle_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)::d_circle])::d_circle[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_circle_domain_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_circle_domain_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)::d_circle])::d_circle[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'circle/domain-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_circle_domain_array'::regclass) AS has_idx) x;
CREATE TABLE r_circle_2d_array (v circle[]);
INSERT INTO r_circle_2d_array VALUES (ARRAY[[circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)], [circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)]]);
CREATE INDEX ON r_circle_2d_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_circle_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)], [circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)]])::circle[] RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_circle_2d_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_circle_2d_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[[circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)], [circle(point(0.30000000000000004, 0), 1), circle(point(0.30000000000000004, 0), 1)]])::circle[] RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'circle/2d-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_circle_2d_array'::regclass) AS has_idx) x;
CREATE TABLE r_circle_domain_over_array (v da_circle);
INSERT INTO r_circle_domain_over_array VALUES (ARRAY[circle(point(0.30000000000000004, 0), 1)]::da_circle);
CREATE INDEX ON r_circle_domain_over_array ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_circle_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)]::da_circle)::da_circle RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_circle_domain_over_array'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_circle_domain_over_array WHERE
    json_array(v RETURNING jsonb) =
    json_array((ARRAY[circle(point(0.30000000000000004, 0), 1)]::da_circle)::da_circle RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'circle/domain-over-array', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_circle_domain_over_array'::regclass) AS has_idx) x;
CREATE TABLE r_circle_scalar (v circle);
INSERT INTO r_circle_scalar VALUES (circle(point(0.30000000000000004, 0), 1));
CREATE INDEX ON r_circle_scalar ((json_array(v RETURNING jsonb)));
SET extra_float_digits = 0;
BEGIN; SET LOCAL enable_seqscan = off;
SELECT count(*) AS n_idx FROM r_circle_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((circle(point(0.30000000000000004, 0), 1))::circle RETURNING jsonb) \gset
SELECT coalesce(sum(pg_stat_get_xact_numscans(indexrelid)), 0) > 0 AS used
  FROM pg_index WHERE indrelid = 'r_circle_scalar'::regclass \gset
COMMIT;
RESET enable_seqscan; SET enable_indexscan = off; SET enable_indexonlyscan = off;
SET enable_bitmapscan = off;
SELECT count(*) AS n_seq FROM r_circle_scalar WHERE
    json_array(v RETURNING jsonb) =
    json_array((circle(point(0.30000000000000004, 0), 1))::circle RETURNING jsonb) \gset
RESET enable_indexscan; RESET enable_indexonlyscan; RESET enable_bitmapscan;
RESET extra_float_digits; RESET bytea_output;
SELECT format('ORACLE %s | index_exists=%s index_used=%s | index=%s seq=%s | %s',
  'circle/scalar', x.has_idx, :'used', :n_idx, :n_seq,
  CASE WHEN NOT x.has_idx THEN 'no-index'
       WHEN :n_idx <> :n_seq THEN 'DIVERGE' ELSE 'same' END)
  FROM (SELECT EXISTS (SELECT 1 FROM pg_index
                        WHERE indrelid = 'r_circle_scalar'::regclass) AS has_idx) x;