diff --git a/crates/squawk_ide/src/builtins.sql b/crates/squawk_ide/src/builtins.sql
index 106bdcb0..6680d6b0 100644
--- a/crates/squawk_ide/src/builtins.sql
+++ b/crates/squawk_ide/src/builtins.sql
@@ -3,6 +3,8 @@
 -- update via:
 --   cargo xtask sync-builtins
 
+create schema pg_temp;
+
 create schema information_schema;
 
 -- system catalog schema
@@ -11,8 +13,6 @@ create schema pg_catalog;
 -- standard public schema
 create schema public;
 
-create schema pg_temp;
-
 -- size: 4, align: 4
 create type information_schema.cardinal_number;
 
@@ -432,148 +432,974 @@ create type pg_catalog.tsrange as range (subtype = timestamp without time zone);
 -- size: -1, align: 8
 create type pg_catalog.tstzrange as range (subtype = timestamp with time zone);
 
-create view information_schema._pg_foreign_data_wrappers(oid, fdwowner, fdwoptions, foreign_data_wrapper_catalog, foreign_data_wrapper_name, authorization_identifier, foreign_data_wrapper_language) as
-  select
-    null::oid,
-    null::oid,
-    null::text[],
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.character_data
-;
-
-create view information_schema._pg_foreign_servers(oid, srvoptions, foreign_server_catalog, foreign_server_name, foreign_data_wrapper_catalog, foreign_data_wrapper_name, foreign_server_type, foreign_server_version, authorization_identifier) as
-  select
-    null::oid,
-    null::text[],
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.character_data,
-    null::information_schema.character_data,
-    null::information_schema.sql_identifier
-;
+create table information_schema.sql_features (
+  feature_id information_schema.character_data,
+  feature_name information_schema.character_data,
+  sub_feature_id information_schema.character_data,
+  sub_feature_name information_schema.character_data,
+  is_supported information_schema.yes_or_no,
+  is_verified_by information_schema.character_data,
+  comments information_schema.character_data
+);
 
-create view information_schema._pg_foreign_table_columns(nspname, relname, attname, attfdwoptions) as
-  select
-    null::name,
-    null::name,
-    null::name,
-    null::text[]
-;
+create table information_schema.sql_implementation_info (
+  implementation_info_id information_schema.character_data,
+  implementation_info_name information_schema.character_data,
+  integer_value information_schema.cardinal_number,
+  character_value information_schema.character_data,
+  comments information_schema.character_data
+);
 
-create view information_schema._pg_foreign_tables(foreign_table_catalog, foreign_table_schema, foreign_table_name, ftoptions, foreign_server_catalog, foreign_server_name, authorization_identifier) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::text[],
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
+create table information_schema.sql_parts (
+  feature_id information_schema.character_data,
+  feature_name information_schema.character_data,
+  is_supported information_schema.yes_or_no,
+  is_verified_by information_schema.character_data,
+  comments information_schema.character_data
+);
 
-create view information_schema._pg_user_mappings(oid, umoptions, umuser, authorization_identifier, foreign_server_catalog, foreign_server_name, srvowner) as
-  select
-    null::oid,
-    null::text[],
-    null::oid,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
+create table information_schema.sql_sizing (
+  sizing_id information_schema.cardinal_number,
+  sizing_name information_schema.character_data,
+  supported_value information_schema.cardinal_number,
+  comments information_schema.character_data
+);
 
-create view information_schema.administrable_role_authorizations(grantee, role_name, is_grantable) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.yes_or_no
-;
+create table pg_catalog.pg_aggregate (
+  aggfnoid regproc,
+  aggkind "char",
+  aggnumdirectargs smallint,
+  aggtransfn regproc,
+  aggfinalfn regproc,
+  aggcombinefn regproc,
+  aggserialfn regproc,
+  aggdeserialfn regproc,
+  aggmtransfn regproc,
+  aggminvtransfn regproc,
+  aggmfinalfn regproc,
+  aggfinalextra boolean,
+  aggmfinalextra boolean,
+  aggfinalmodify "char",
+  aggmfinalmodify "char",
+  aggsortop oid,
+  aggtranstype oid,
+  aggtransspace integer,
+  aggmtranstype oid,
+  aggmtransspace integer,
+  agginitval text,
+  aggminitval text
+);
 
-create view information_schema.applicable_roles(grantee, role_name, is_grantable) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.yes_or_no
-;
+create table pg_catalog.pg_am (
+  oid oid,
+  amname name,
+  amhandler regproc,
+  amtype "char"
+);
 
-create view information_schema.attributes(udt_catalog, udt_schema, udt_name, attribute_name, ordinal_position, attribute_default, is_nullable, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, attribute_udt_catalog, attribute_udt_schema, attribute_udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, is_derived_reference_attribute) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.cardinal_number,
-    null::information_schema.character_data,
-    null::information_schema.yes_or_no,
-    null::information_schema.character_data,
-    null::information_schema.cardinal_number,
-    null::information_schema.cardinal_number,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.cardinal_number,
-    null::information_schema.cardinal_number,
-    null::information_schema.cardinal_number,
-    null::information_schema.cardinal_number,
-    null::information_schema.character_data,
-    null::information_schema.cardinal_number,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.cardinal_number,
-    null::information_schema.sql_identifier,
-    null::information_schema.yes_or_no
-;
+create table pg_catalog.pg_amop (
+  oid oid,
+  amopfamily oid,
+  amoplefttype oid,
+  amoprighttype oid,
+  amopstrategy smallint,
+  amoppurpose "char",
+  amopopr oid,
+  amopmethod oid,
+  amopsortfamily oid
+);
 
-create view information_schema.character_sets(character_set_catalog, character_set_schema, character_set_name, character_repertoire, form_of_use, default_collate_catalog, default_collate_schema, default_collate_name) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
+create table pg_catalog.pg_amproc (
+  oid oid,
+  amprocfamily oid,
+  amproclefttype oid,
+  amprocrighttype oid,
+  amprocnum smallint,
+  amproc regproc
+);
 
-create view information_schema.check_constraint_routine_usage(constraint_catalog, constraint_schema, constraint_name, specific_catalog, specific_schema, specific_name) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
+create table pg_catalog.pg_attrdef (
+  oid oid,
+  adrelid oid,
+  adnum smallint,
+  adbin pg_node_tree
+);
 
-create view information_schema.check_constraints(constraint_catalog, constraint_schema, constraint_name, check_clause) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.character_data
-;
+create table pg_catalog.pg_attribute (
+  attrelid oid,
+  attname name,
+  atttypid oid,
+  attlen smallint,
+  attnum smallint,
+  atttypmod integer,
+  attndims smallint,
+  attbyval boolean,
+  attalign "char",
+  attstorage "char",
+  attcompression "char",
+  attnotnull boolean,
+  atthasdef boolean,
+  atthasmissing boolean,
+  attidentity "char",
+  attgenerated "char",
+  attisdropped boolean,
+  attislocal boolean,
+  attinhcount smallint,
+  attcollation oid,
+  attstattarget smallint,
+  attacl aclitem[],
+  attoptions text[],
+  attfdwoptions text[],
+  attmissingval anyarray
+);
 
-create view information_schema.collation_character_set_applicability(collation_catalog, collation_schema, collation_name, character_set_catalog, character_set_schema, character_set_name) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
+create table pg_catalog.pg_auth_members (
+  oid oid,
+  roleid oid,
+  member oid,
+  grantor oid,
+  admin_option boolean,
+  inherit_option boolean,
+  set_option boolean
+);
+
+create table pg_catalog.pg_authid (
+  oid oid,
+  rolname name,
+  rolsuper boolean,
+  rolinherit boolean,
+  rolcreaterole boolean,
+  rolcreatedb boolean,
+  rolcanlogin boolean,
+  rolreplication boolean,
+  rolbypassrls boolean,
+  rolconnlimit integer,
+  rolpassword text,
+  rolvaliduntil timestamp with time zone
+);
+
+create table pg_catalog.pg_cast (
+  oid oid,
+  castsource oid,
+  casttarget oid,
+  castfunc oid,
+  castcontext "char",
+  castmethod "char"
+);
+
+create table pg_catalog.pg_class (
+  oid oid,
+  relname name,
+  relnamespace oid,
+  reltype oid,
+  reloftype oid,
+  relowner oid,
+  relam oid,
+  relfilenode oid,
+  reltablespace oid,
+  relpages integer,
+  reltuples real,
+  relallvisible integer,
+  relallfrozen integer,
+  reltoastrelid oid,
+  relhasindex boolean,
+  relisshared boolean,
+  relpersistence "char",
+  relkind "char",
+  relnatts smallint,
+  relchecks smallint,
+  relhasrules boolean,
+  relhastriggers boolean,
+  relhassubclass boolean,
+  relrowsecurity boolean,
+  relforcerowsecurity boolean,
+  relispopulated boolean,
+  relreplident "char",
+  relispartition boolean,
+  relrewrite oid,
+  relfrozenxid xid,
+  relminmxid xid,
+  relacl aclitem[],
+  reloptions text[],
+  relpartbound pg_node_tree
+);
+
+create table pg_catalog.pg_collation (
+  oid oid,
+  collname name,
+  collnamespace oid,
+  collowner oid,
+  collprovider "char",
+  collisdeterministic boolean,
+  collencoding integer,
+  collcollate text,
+  collctype text,
+  colllocale text,
+  collicurules text,
+  collversion text
+);
+
+create table pg_catalog.pg_constraint (
+  oid oid,
+  conname name,
+  connamespace oid,
+  contype "char",
+  condeferrable boolean,
+  condeferred boolean,
+  conenforced boolean,
+  convalidated boolean,
+  conrelid oid,
+  contypid oid,
+  conindid oid,
+  conparentid oid,
+  confrelid oid,
+  confupdtype "char",
+  confdeltype "char",
+  confmatchtype "char",
+  conislocal boolean,
+  coninhcount smallint,
+  connoinherit boolean,
+  conperiod boolean,
+  conkey smallint[],
+  confkey smallint[],
+  conpfeqop oid[],
+  conppeqop oid[],
+  conffeqop oid[],
+  confdelsetcols smallint[],
+  conexclop oid[],
+  conbin pg_node_tree
+);
+
+create table pg_catalog.pg_conversion (
+  oid oid,
+  conname name,
+  connamespace oid,
+  conowner oid,
+  conforencoding integer,
+  contoencoding integer,
+  conproc regproc,
+  condefault boolean
+);
+
+create table pg_catalog.pg_database (
+  oid oid,
+  datname name,
+  datdba oid,
+  encoding integer,
+  datlocprovider "char",
+  datistemplate boolean,
+  datallowconn boolean,
+  dathasloginevt boolean,
+  datconnlimit integer,
+  datfrozenxid xid,
+  datminmxid xid,
+  dattablespace oid,
+  datcollate text,
+  datctype text,
+  datlocale text,
+  daticurules text,
+  datcollversion text,
+  datacl aclitem[]
+);
+
+create table pg_catalog.pg_db_role_setting (
+  setdatabase oid,
+  setrole oid,
+  setconfig text[]
+);
+
+create table pg_catalog.pg_default_acl (
+  oid oid,
+  defaclrole oid,
+  defaclnamespace oid,
+  defaclobjtype "char",
+  defaclacl aclitem[]
+);
+
+create table pg_catalog.pg_depend (
+  classid oid,
+  objid oid,
+  objsubid integer,
+  refclassid oid,
+  refobjid oid,
+  refobjsubid integer,
+  deptype "char"
+);
+
+create table pg_catalog.pg_description (
+  objoid oid,
+  classoid oid,
+  objsubid integer,
+  description text
+);
+
+create table pg_catalog.pg_enum (
+  oid oid,
+  enumtypid oid,
+  enumsortorder real,
+  enumlabel name
+);
+
+create table pg_catalog.pg_event_trigger (
+  oid oid,
+  evtname name,
+  evtevent name,
+  evtowner oid,
+  evtfoid oid,
+  evtenabled "char",
+  evttags text[]
+);
+
+create table pg_catalog.pg_extension (
+  oid oid,
+  extname name,
+  extowner oid,
+  extnamespace oid,
+  extrelocatable boolean,
+  extversion text,
+  extconfig oid[],
+  extcondition text[]
+);
+
+create table pg_catalog.pg_foreign_data_wrapper (
+  oid oid,
+  fdwname name,
+  fdwowner oid,
+  fdwhandler oid,
+  fdwvalidator oid,
+  fdwacl aclitem[],
+  fdwoptions text[]
+);
+
+create table pg_catalog.pg_foreign_server (
+  oid oid,
+  srvname name,
+  srvowner oid,
+  srvfdw oid,
+  srvtype text,
+  srvversion text,
+  srvacl aclitem[],
+  srvoptions text[]
+);
+
+create table pg_catalog.pg_foreign_table (
+  ftrelid oid,
+  ftserver oid,
+  ftoptions text[]
+);
+
+create table pg_catalog.pg_index (
+  indexrelid oid,
+  indrelid oid,
+  indnatts smallint,
+  indnkeyatts smallint,
+  indisunique boolean,
+  indnullsnotdistinct boolean,
+  indisprimary boolean,
+  indisexclusion boolean,
+  indimmediate boolean,
+  indisclustered boolean,
+  indisvalid boolean,
+  indcheckxmin boolean,
+  indisready boolean,
+  indislive boolean,
+  indisreplident boolean,
+  indkey int2vector,
+  indcollation oidvector,
+  indclass oidvector,
+  indoption int2vector,
+  indexprs pg_node_tree,
+  indpred pg_node_tree
+);
+
+create table pg_catalog.pg_inherits (
+  inhrelid oid,
+  inhparent oid,
+  inhseqno integer,
+  inhdetachpending boolean
+);
+
+create table pg_catalog.pg_init_privs (
+  objoid oid,
+  classoid oid,
+  objsubid integer,
+  privtype "char",
+  initprivs aclitem[]
+);
+
+create table pg_catalog.pg_language (
+  oid oid,
+  lanname name,
+  lanowner oid,
+  lanispl boolean,
+  lanpltrusted boolean,
+  lanplcallfoid oid,
+  laninline oid,
+  lanvalidator oid,
+  lanacl aclitem[]
+);
+
+create table pg_catalog.pg_largeobject (
+  loid oid,
+  pageno integer,
+  data bytea
+);
+
+create table pg_catalog.pg_largeobject_metadata (
+  oid oid,
+  lomowner oid,
+  lomacl aclitem[]
+);
+
+create table pg_catalog.pg_namespace (
+  oid oid,
+  nspname name,
+  nspowner oid,
+  nspacl aclitem[]
+);
+
+create table pg_catalog.pg_opclass (
+  oid oid,
+  opcmethod oid,
+  opcname name,
+  opcnamespace oid,
+  opcowner oid,
+  opcfamily oid,
+  opcintype oid,
+  opcdefault boolean,
+  opckeytype oid
+);
+
+create table pg_catalog.pg_operator (
+  oid oid,
+  oprname name,
+  oprnamespace oid,
+  oprowner oid,
+  oprkind "char",
+  oprcanmerge boolean,
+  oprcanhash boolean,
+  oprleft oid,
+  oprright oid,
+  oprresult oid,
+  oprcom oid,
+  oprnegate oid,
+  oprcode regproc,
+  oprrest regproc,
+  oprjoin regproc
+);
+
+create table pg_catalog.pg_opfamily (
+  oid oid,
+  opfmethod oid,
+  opfname name,
+  opfnamespace oid,
+  opfowner oid
+);
+
+create table pg_catalog.pg_parameter_acl (
+  oid oid,
+  parname text,
+  paracl aclitem[]
+);
+
+create table pg_catalog.pg_partitioned_table (
+  partrelid oid,
+  partstrat "char",
+  partnatts smallint,
+  partdefid oid,
+  partattrs int2vector,
+  partclass oidvector,
+  partcollation oidvector,
+  partexprs pg_node_tree
+);
+
+create table pg_catalog.pg_policy (
+  oid oid,
+  polname name,
+  polrelid oid,
+  polcmd "char",
+  polpermissive boolean,
+  polroles oid[],
+  polqual pg_node_tree,
+  polwithcheck pg_node_tree
+);
+
+create table pg_catalog.pg_proc (
+  oid oid,
+  proname name,
+  pronamespace oid,
+  proowner oid,
+  prolang oid,
+  procost real,
+  prorows real,
+  provariadic oid,
+  prosupport regproc,
+  prokind "char",
+  prosecdef boolean,
+  proleakproof boolean,
+  proisstrict boolean,
+  proretset boolean,
+  provolatile "char",
+  proparallel "char",
+  pronargs smallint,
+  pronargdefaults smallint,
+  prorettype oid,
+  proargtypes oidvector,
+  proallargtypes oid[],
+  proargmodes "char"[],
+  proargnames text[],
+  proargdefaults pg_node_tree,
+  protrftypes oid[],
+  prosrc text,
+  probin text,
+  prosqlbody pg_node_tree,
+  proconfig text[],
+  proacl aclitem[]
+);
+
+create table pg_catalog.pg_publication (
+  oid oid,
+  pubname name,
+  pubowner oid,
+  puballtables boolean,
+  pubinsert boolean,
+  pubupdate boolean,
+  pubdelete boolean,
+  pubtruncate boolean,
+  pubviaroot boolean,
+  pubgencols "char"
+);
+
+create table pg_catalog.pg_publication_namespace (
+  oid oid,
+  pnpubid oid,
+  pnnspid oid
+);
+
+create table pg_catalog.pg_publication_rel (
+  oid oid,
+  prpubid oid,
+  prrelid oid,
+  prqual pg_node_tree,
+  prattrs int2vector
+);
+
+create table pg_catalog.pg_range (
+  rngtypid oid,
+  rngsubtype oid,
+  rngmultitypid oid,
+  rngcollation oid,
+  rngsubopc oid,
+  rngcanonical regproc,
+  rngsubdiff regproc
+);
+
+create table pg_catalog.pg_replication_origin (
+  roident oid,
+  roname text
+);
+
+create table pg_catalog.pg_rewrite (
+  oid oid,
+  rulename name,
+  ev_class oid,
+  ev_type "char",
+  ev_enabled "char",
+  is_instead boolean,
+  ev_qual pg_node_tree,
+  ev_action pg_node_tree
+);
+
+create table pg_catalog.pg_seclabel (
+  objoid oid,
+  classoid oid,
+  objsubid integer,
+  provider text,
+  label text
+);
+
+create table pg_catalog.pg_sequence (
+  seqrelid oid,
+  seqtypid oid,
+  seqstart bigint,
+  seqincrement bigint,
+  seqmax bigint,
+  seqmin bigint,
+  seqcache bigint,
+  seqcycle boolean
+);
+
+create table pg_catalog.pg_shdepend (
+  dbid oid,
+  classid oid,
+  objid oid,
+  objsubid integer,
+  refclassid oid,
+  refobjid oid,
+  deptype "char"
+);
+
+create table pg_catalog.pg_shdescription (
+  objoid oid,
+  classoid oid,
+  description text
+);
+
+create table pg_catalog.pg_shseclabel (
+  objoid oid,
+  classoid oid,
+  provider text,
+  label text
+);
+
+create table pg_catalog.pg_statistic (
+  starelid oid,
+  staattnum smallint,
+  stainherit boolean,
+  stanullfrac real,
+  stawidth integer,
+  stadistinct real,
+  stakind1 smallint,
+  stakind2 smallint,
+  stakind3 smallint,
+  stakind4 smallint,
+  stakind5 smallint,
+  staop1 oid,
+  staop2 oid,
+  staop3 oid,
+  staop4 oid,
+  staop5 oid,
+  stacoll1 oid,
+  stacoll2 oid,
+  stacoll3 oid,
+  stacoll4 oid,
+  stacoll5 oid,
+  stanumbers1 real[],
+  stanumbers2 real[],
+  stanumbers3 real[],
+  stanumbers4 real[],
+  stanumbers5 real[],
+  stavalues1 anyarray,
+  stavalues2 anyarray,
+  stavalues3 anyarray,
+  stavalues4 anyarray,
+  stavalues5 anyarray
+);
+
+create table pg_catalog.pg_statistic_ext (
+  oid oid,
+  stxrelid oid,
+  stxname name,
+  stxnamespace oid,
+  stxowner oid,
+  stxkeys int2vector,
+  stxstattarget smallint,
+  stxkind "char"[],
+  stxexprs pg_node_tree
+);
+
+create table pg_catalog.pg_statistic_ext_data (
+  stxoid oid,
+  stxdinherit boolean,
+  stxdndistinct pg_ndistinct,
+  stxddependencies pg_dependencies,
+  stxdmcv pg_mcv_list,
+  stxdexpr pg_statistic[]
+);
+
+create table pg_catalog.pg_subscription (
+  oid oid,
+  subdbid oid,
+  subskiplsn pg_lsn,
+  subname name,
+  subowner oid,
+  subenabled boolean,
+  subbinary boolean,
+  substream "char",
+  subtwophasestate "char",
+  subdisableonerr boolean,
+  subpasswordrequired boolean,
+  subrunasowner boolean,
+  subfailover boolean,
+  subconninfo text,
+  subslotname name,
+  subsynccommit text,
+  subpublications text[],
+  suborigin text
+);
+
+create table pg_catalog.pg_subscription_rel (
+  srsubid oid,
+  srrelid oid,
+  srsubstate "char",
+  srsublsn pg_lsn
+);
+
+create table pg_catalog.pg_tablespace (
+  oid oid,
+  spcname name,
+  spcowner oid,
+  spcacl aclitem[],
+  spcoptions text[]
+);
+
+create table pg_catalog.pg_transform (
+  oid oid,
+  trftype oid,
+  trflang oid,
+  trffromsql regproc,
+  trftosql regproc
+);
+
+create table pg_catalog.pg_trigger (
+  oid oid,
+  tgrelid oid,
+  tgparentid oid,
+  tgname name,
+  tgfoid oid,
+  tgtype smallint,
+  tgenabled "char",
+  tgisinternal boolean,
+  tgconstrrelid oid,
+  tgconstrindid oid,
+  tgconstraint oid,
+  tgdeferrable boolean,
+  tginitdeferred boolean,
+  tgnargs smallint,
+  tgattr int2vector,
+  tgargs bytea,
+  tgqual pg_node_tree,
+  tgoldtable name,
+  tgnewtable name
+);
+
+create table pg_catalog.pg_ts_config (
+  oid oid,
+  cfgname name,
+  cfgnamespace oid,
+  cfgowner oid,
+  cfgparser oid
+);
+
+create table pg_catalog.pg_ts_config_map (
+  mapcfg oid,
+  maptokentype integer,
+  mapseqno integer,
+  mapdict oid
+);
+
+create table pg_catalog.pg_ts_dict (
+  oid oid,
+  dictname name,
+  dictnamespace oid,
+  dictowner oid,
+  dicttemplate oid,
+  dictinitoption text
+);
+
+create table pg_catalog.pg_ts_parser (
+  oid oid,
+  prsname name,
+  prsnamespace oid,
+  prsstart regproc,
+  prstoken regproc,
+  prsend regproc,
+  prsheadline regproc,
+  prslextype regproc
+);
+
+create table pg_catalog.pg_ts_template (
+  oid oid,
+  tmplname name,
+  tmplnamespace oid,
+  tmplinit regproc,
+  tmpllexize regproc
+);
+
+create table pg_catalog.pg_type (
+  oid oid,
+  typname name,
+  typnamespace oid,
+  typowner oid,
+  typlen smallint,
+  typbyval boolean,
+  typtype "char",
+  typcategory "char",
+  typispreferred boolean,
+  typisdefined boolean,
+  typdelim "char",
+  typrelid oid,
+  typsubscript regproc,
+  typelem oid,
+  typarray oid,
+  typinput regproc,
+  typoutput regproc,
+  typreceive regproc,
+  typsend regproc,
+  typmodin regproc,
+  typmodout regproc,
+  typanalyze regproc,
+  typalign "char",
+  typstorage "char",
+  typnotnull boolean,
+  typbasetype oid,
+  typtypmod integer,
+  typndims integer,
+  typcollation oid,
+  typdefaultbin pg_node_tree,
+  typdefault text,
+  typacl aclitem[]
+);
+
+create table pg_catalog.pg_user_mapping (
+  oid oid,
+  umuser oid,
+  umserver oid,
+  umoptions text[]
+);
+
+create view information_schema._pg_foreign_data_wrappers(oid, fdwowner, fdwoptions, foreign_data_wrapper_catalog, foreign_data_wrapper_name, authorization_identifier, foreign_data_wrapper_language) as
+  select
+    null::oid,
+    null::oid,
+    null::text[],
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.character_data
+;
+
+create view information_schema._pg_foreign_servers(oid, srvoptions, foreign_server_catalog, foreign_server_name, foreign_data_wrapper_catalog, foreign_data_wrapper_name, foreign_server_type, foreign_server_version, authorization_identifier) as
+  select
+    null::oid,
+    null::text[],
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.character_data,
+    null::information_schema.character_data,
+    null::information_schema.sql_identifier
+;
+
+create view information_schema._pg_foreign_table_columns(nspname, relname, attname, attfdwoptions) as
+  select
+    null::name,
+    null::name,
+    null::name,
+    null::text[]
+;
+
+create view information_schema._pg_foreign_tables(foreign_table_catalog, foreign_table_schema, foreign_table_name, ftoptions, foreign_server_catalog, foreign_server_name, authorization_identifier) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::text[],
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
+
+create view information_schema._pg_user_mappings(oid, umoptions, umuser, authorization_identifier, foreign_server_catalog, foreign_server_name, srvowner) as
+  select
+    null::oid,
+    null::text[],
+    null::oid,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
+
+create view information_schema.administrable_role_authorizations(grantee, role_name, is_grantable) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.yes_or_no
+;
+
+create view information_schema.applicable_roles(grantee, role_name, is_grantable) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.yes_or_no
+;
+
+create view information_schema.attributes(udt_catalog, udt_schema, udt_name, attribute_name, ordinal_position, attribute_default, is_nullable, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, attribute_udt_catalog, attribute_udt_schema, attribute_udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, is_derived_reference_attribute) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.cardinal_number,
+    null::information_schema.character_data,
+    null::information_schema.yes_or_no,
+    null::information_schema.character_data,
+    null::information_schema.cardinal_number,
+    null::information_schema.cardinal_number,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.cardinal_number,
+    null::information_schema.cardinal_number,
+    null::information_schema.cardinal_number,
+    null::information_schema.cardinal_number,
+    null::information_schema.character_data,
+    null::information_schema.cardinal_number,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.cardinal_number,
+    null::information_schema.sql_identifier,
+    null::information_schema.yes_or_no
+;
+
+create view information_schema.character_sets(character_set_catalog, character_set_schema, character_set_name, character_repertoire, form_of_use, default_collate_catalog, default_collate_schema, default_collate_name) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
+
+create view information_schema.check_constraint_routine_usage(constraint_catalog, constraint_schema, constraint_name, specific_catalog, specific_schema, specific_name) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
+
+create view information_schema.check_constraints(constraint_catalog, constraint_schema, constraint_name, check_clause) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.character_data
+;
+
+create view information_schema.collation_character_set_applicability(collation_catalog, collation_schema, collation_name, character_set_catalog, character_set_schema, character_set_name) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
 
 create view information_schema.collations(collation_catalog, collation_schema, collation_name, pad_attribute) as
   select
@@ -1163,39 +1989,6 @@ create view information_schema.sequences(sequence_catalog, sequence_schema, sequ
     null::information_schema.yes_or_no
 ;
 
-create table information_schema.sql_features (
-  feature_id information_schema.character_data,
-  feature_name information_schema.character_data,
-  sub_feature_id information_schema.character_data,
-  sub_feature_name information_schema.character_data,
-  is_supported information_schema.yes_or_no,
-  is_verified_by information_schema.character_data,
-  comments information_schema.character_data
-);
-
-create table information_schema.sql_implementation_info (
-  implementation_info_id information_schema.character_data,
-  implementation_info_name information_schema.character_data,
-  integer_value information_schema.cardinal_number,
-  character_value information_schema.character_data,
-  comments information_schema.character_data
-);
-
-create table information_schema.sql_parts (
-  feature_id information_schema.character_data,
-  feature_name information_schema.character_data,
-  is_supported information_schema.yes_or_no,
-  is_verified_by information_schema.character_data,
-  comments information_schema.character_data
-);
-
-create table information_schema.sql_sizing (
-  sizing_id information_schema.cardinal_number,
-  sizing_name information_schema.character_data,
-  supported_value information_schema.cardinal_number,
-  comments information_schema.character_data
-);
-
 create view information_schema.table_constraints(constraint_catalog, constraint_schema, constraint_name, table_catalog, table_schema, table_name, constraint_type, is_deferrable, initially_deferred, enforced, nulls_distinct) as
   select
     null::information_schema.sql_identifier,
@@ -1367,170 +2160,57 @@ create view information_schema.view_column_usage(view_catalog, view_schema, view
 ;
 
 create view information_schema.view_routine_usage(table_catalog, table_schema, table_name, specific_catalog, specific_schema, specific_name) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
-
-create view information_schema.view_table_usage(view_catalog, view_schema, view_name, table_catalog, table_schema, table_name) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier
-;
-
-create view information_schema.views(table_catalog, table_schema, table_name, view_definition, check_option, is_updatable, is_insertable_into, is_trigger_updatable, is_trigger_deletable, is_trigger_insertable_into) as
-  select
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.sql_identifier,
-    null::information_schema.character_data,
-    null::information_schema.character_data,
-    null::information_schema.yes_or_no,
-    null::information_schema.yes_or_no,
-    null::information_schema.yes_or_no,
-    null::information_schema.yes_or_no,
-    null::information_schema.yes_or_no
-;
-
-create table pg_catalog.pg_aggregate (
-  aggfnoid regproc,
-  aggkind "char",
-  aggnumdirectargs smallint,
-  aggtransfn regproc,
-  aggfinalfn regproc,
-  aggcombinefn regproc,
-  aggserialfn regproc,
-  aggdeserialfn regproc,
-  aggmtransfn regproc,
-  aggminvtransfn regproc,
-  aggmfinalfn regproc,
-  aggfinalextra boolean,
-  aggmfinalextra boolean,
-  aggfinalmodify "char",
-  aggmfinalmodify "char",
-  aggsortop oid,
-  aggtranstype oid,
-  aggtransspace integer,
-  aggmtranstype oid,
-  aggmtransspace integer,
-  agginitval text,
-  aggminitval text
-);
-
-create view pg_catalog.pg_aios(pid, io_id, io_generation, state, operation, off, length, target, handle_data_len, raw_result, result, target_desc, f_sync, f_localmem, f_buffered) as
-  select
-    null::integer,
-    null::integer,
-    null::bigint,
-    null::text,
-    null::text,
-    null::bigint,
-    null::bigint,
-    null::text,
-    null::smallint,
-    null::integer,
-    null::text,
-    null::text,
-    null::boolean,
-    null::boolean,
-    null::boolean
-;
-
-create table pg_catalog.pg_am (
-  oid oid,
-  amname name,
-  amhandler regproc,
-  amtype "char"
-);
-
-create table pg_catalog.pg_amop (
-  oid oid,
-  amopfamily oid,
-  amoplefttype oid,
-  amoprighttype oid,
-  amopstrategy smallint,
-  amoppurpose "char",
-  amopopr oid,
-  amopmethod oid,
-  amopsortfamily oid
-);
-
-create table pg_catalog.pg_amproc (
-  oid oid,
-  amprocfamily oid,
-  amproclefttype oid,
-  amprocrighttype oid,
-  amprocnum smallint,
-  amproc regproc
-);
-
-create table pg_catalog.pg_attrdef (
-  oid oid,
-  adrelid oid,
-  adnum smallint,
-  adbin pg_node_tree
-);
-
-create table pg_catalog.pg_attribute (
-  attrelid oid,
-  attname name,
-  atttypid oid,
-  attlen smallint,
-  attnum smallint,
-  atttypmod integer,
-  attndims smallint,
-  attbyval boolean,
-  attalign "char",
-  attstorage "char",
-  attcompression "char",
-  attnotnull boolean,
-  atthasdef boolean,
-  atthasmissing boolean,
-  attidentity "char",
-  attgenerated "char",
-  attisdropped boolean,
-  attislocal boolean,
-  attinhcount smallint,
-  attcollation oid,
-  attstattarget smallint,
-  attacl aclitem[],
-  attoptions text[],
-  attfdwoptions text[],
-  attmissingval anyarray
-);
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
 
-create table pg_catalog.pg_auth_members (
-  oid oid,
-  roleid oid,
-  member oid,
-  grantor oid,
-  admin_option boolean,
-  inherit_option boolean,
-  set_option boolean
-);
+create view information_schema.view_table_usage(view_catalog, view_schema, view_name, table_catalog, table_schema, table_name) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier
+;
 
-create table pg_catalog.pg_authid (
-  oid oid,
-  rolname name,
-  rolsuper boolean,
-  rolinherit boolean,
-  rolcreaterole boolean,
-  rolcreatedb boolean,
-  rolcanlogin boolean,
-  rolreplication boolean,
-  rolbypassrls boolean,
-  rolconnlimit integer,
-  rolpassword text,
-  rolvaliduntil timestamp with time zone
-);
+create view information_schema.views(table_catalog, table_schema, table_name, view_definition, check_option, is_updatable, is_insertable_into, is_trigger_updatable, is_trigger_deletable, is_trigger_insertable_into) as
+  select
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.sql_identifier,
+    null::information_schema.character_data,
+    null::information_schema.character_data,
+    null::information_schema.yes_or_no,
+    null::information_schema.yes_or_no,
+    null::information_schema.yes_or_no,
+    null::information_schema.yes_or_no,
+    null::information_schema.yes_or_no
+;
+
+create view pg_catalog.pg_aios(pid, io_id, io_generation, state, operation, off, length, target, handle_data_len, raw_result, result, target_desc, f_sync, f_localmem, f_buffered) as
+  select
+    null::integer,
+    null::integer,
+    null::bigint,
+    null::text,
+    null::text,
+    null::bigint,
+    null::bigint,
+    null::text,
+    null::smallint,
+    null::integer,
+    null::text,
+    null::text,
+    null::boolean,
+    null::boolean,
+    null::boolean
+;
 
 create view pg_catalog.pg_available_extension_versions(name, version, installed, superuser, trusted, relocatable, schema, requires, comment) as
   select
@@ -1567,204 +2247,21 @@ create view pg_catalog.pg_backend_memory_contexts(name, ident, type, level, path
     null::bigint
 ;
 
-create table pg_catalog.pg_cast (
-  oid oid,
-  castsource oid,
-  casttarget oid,
-  castfunc oid,
-  castcontext "char",
-  castmethod "char"
-);
-
-create table pg_catalog.pg_class (
-  oid oid,
-  relname name,
-  relnamespace oid,
-  reltype oid,
-  reloftype oid,
-  relowner oid,
-  relam oid,
-  relfilenode oid,
-  reltablespace oid,
-  relpages integer,
-  reltuples real,
-  relallvisible integer,
-  relallfrozen integer,
-  reltoastrelid oid,
-  relhasindex boolean,
-  relisshared boolean,
-  relpersistence "char",
-  relkind "char",
-  relnatts smallint,
-  relchecks smallint,
-  relhasrules boolean,
-  relhastriggers boolean,
-  relhassubclass boolean,
-  relrowsecurity boolean,
-  relforcerowsecurity boolean,
-  relispopulated boolean,
-  relreplident "char",
-  relispartition boolean,
-  relrewrite oid,
-  relfrozenxid xid,
-  relminmxid xid,
-  relacl aclitem[],
-  reloptions text[],
-  relpartbound pg_node_tree
-);
-
-create table pg_catalog.pg_collation (
-  oid oid,
-  collname name,
-  collnamespace oid,
-  collowner oid,
-  collprovider "char",
-  collisdeterministic boolean,
-  collencoding integer,
-  collcollate text,
-  collctype text,
-  colllocale text,
-  collicurules text,
-  collversion text
-);
-
 create view pg_catalog.pg_config(name, setting) as
   select
     null::text,
-    null::text
-;
-
-create table pg_catalog.pg_constraint (
-  oid oid,
-  conname name,
-  connamespace oid,
-  contype "char",
-  condeferrable boolean,
-  condeferred boolean,
-  conenforced boolean,
-  convalidated boolean,
-  conrelid oid,
-  contypid oid,
-  conindid oid,
-  conparentid oid,
-  confrelid oid,
-  confupdtype "char",
-  confdeltype "char",
-  confmatchtype "char",
-  conislocal boolean,
-  coninhcount smallint,
-  connoinherit boolean,
-  conperiod boolean,
-  conkey smallint[],
-  confkey smallint[],
-  conpfeqop oid[],
-  conppeqop oid[],
-  conffeqop oid[],
-  confdelsetcols smallint[],
-  conexclop oid[],
-  conbin pg_node_tree
-);
-
-create table pg_catalog.pg_conversion (
-  oid oid,
-  conname name,
-  connamespace oid,
-  conowner oid,
-  conforencoding integer,
-  contoencoding integer,
-  conproc regproc,
-  condefault boolean
-);
-
-create view pg_catalog.pg_cursors(name, statement, is_holdable, is_binary, is_scrollable, creation_time) as
-  select
-    null::text,
-    null::text,
-    null::boolean,
-    null::boolean,
-    null::boolean,
-    null::timestamp with time zone
-;
-
-create table pg_catalog.pg_database (
-  oid oid,
-  datname name,
-  datdba oid,
-  encoding integer,
-  datlocprovider "char",
-  datistemplate boolean,
-  datallowconn boolean,
-  dathasloginevt boolean,
-  datconnlimit integer,
-  datfrozenxid xid,
-  datminmxid xid,
-  dattablespace oid,
-  datcollate text,
-  datctype text,
-  datlocale text,
-  daticurules text,
-  datcollversion text,
-  datacl aclitem[]
-);
-
-create table pg_catalog.pg_db_role_setting (
-  setdatabase oid,
-  setrole oid,
-  setconfig text[]
-);
-
-create table pg_catalog.pg_default_acl (
-  oid oid,
-  defaclrole oid,
-  defaclnamespace oid,
-  defaclobjtype "char",
-  defaclacl aclitem[]
-);
-
-create table pg_catalog.pg_depend (
-  classid oid,
-  objid oid,
-  objsubid integer,
-  refclassid oid,
-  refobjid oid,
-  refobjsubid integer,
-  deptype "char"
-);
-
-create table pg_catalog.pg_description (
-  objoid oid,
-  classoid oid,
-  objsubid integer,
-  description text
-);
-
-create table pg_catalog.pg_enum (
-  oid oid,
-  enumtypid oid,
-  enumsortorder real,
-  enumlabel name
-);
-
-create table pg_catalog.pg_event_trigger (
-  oid oid,
-  evtname name,
-  evtevent name,
-  evtowner oid,
-  evtfoid oid,
-  evtenabled "char",
-  evttags text[]
-);
+    null::text
+;
 
-create table pg_catalog.pg_extension (
-  oid oid,
-  extname name,
-  extowner oid,
-  extnamespace oid,
-  extrelocatable boolean,
-  extversion text,
-  extconfig oid[],
-  extcondition text[]
-);
+create view pg_catalog.pg_cursors(name, statement, is_holdable, is_binary, is_scrollable, creation_time) as
+  select
+    null::text,
+    null::text,
+    null::boolean,
+    null::boolean,
+    null::boolean,
+    null::timestamp with time zone
+;
 
 create view pg_catalog.pg_file_settings(sourcefile, sourceline, seqno, name, setting, applied, error) as
   select
@@ -1777,33 +2274,6 @@ create view pg_catalog.pg_file_settings(sourcefile, sourceline, seqno, name, set
     null::text
 ;
 
-create table pg_catalog.pg_foreign_data_wrapper (
-  oid oid,
-  fdwname name,
-  fdwowner oid,
-  fdwhandler oid,
-  fdwvalidator oid,
-  fdwacl aclitem[],
-  fdwoptions text[]
-);
-
-create table pg_catalog.pg_foreign_server (
-  oid oid,
-  srvname name,
-  srvowner oid,
-  srvfdw oid,
-  srvtype text,
-  srvversion text,
-  srvacl aclitem[],
-  srvoptions text[]
-);
-
-create table pg_catalog.pg_foreign_table (
-  ftrelid oid,
-  ftserver oid,
-  ftoptions text[]
-);
-
 create view pg_catalog.pg_group(groname, grosysid, grolist) as
   select
     null::name,
@@ -1837,30 +2307,6 @@ create view pg_catalog.pg_ident_file_mappings(map_number, file_name, line_number
     null::text
 ;
 
-create table pg_catalog.pg_index (
-  indexrelid oid,
-  indrelid oid,
-  indnatts smallint,
-  indnkeyatts smallint,
-  indisunique boolean,
-  indnullsnotdistinct boolean,
-  indisprimary boolean,
-  indisexclusion boolean,
-  indimmediate boolean,
-  indisclustered boolean,
-  indisvalid boolean,
-  indcheckxmin boolean,
-  indisready boolean,
-  indislive boolean,
-  indisreplident boolean,
-  indkey int2vector,
-  indcollation oidvector,
-  indclass oidvector,
-  indoption int2vector,
-  indexprs pg_node_tree,
-  indpred pg_node_tree
-);
-
 create view pg_catalog.pg_indexes(schemaname, tablename, indexname, tablespace, indexdef) as
   select
     null::name,
@@ -1870,45 +2316,6 @@ create view pg_catalog.pg_indexes(schemaname, tablename, indexname, tablespace,
     null::text
 ;
 
-create table pg_catalog.pg_inherits (
-  inhrelid oid,
-  inhparent oid,
-  inhseqno integer,
-  inhdetachpending boolean
-);
-
-create table pg_catalog.pg_init_privs (
-  objoid oid,
-  classoid oid,
-  objsubid integer,
-  privtype "char",
-  initprivs aclitem[]
-);
-
-create table pg_catalog.pg_language (
-  oid oid,
-  lanname name,
-  lanowner oid,
-  lanispl boolean,
-  lanpltrusted boolean,
-  lanplcallfoid oid,
-  laninline oid,
-  lanvalidator oid,
-  lanacl aclitem[]
-);
-
-create table pg_catalog.pg_largeobject (
-  loid oid,
-  pageno integer,
-  data bytea
-);
-
-create table pg_catalog.pg_largeobject_metadata (
-  oid oid,
-  lomowner oid,
-  lomacl aclitem[]
-);
-
 create view pg_catalog.pg_locks(locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath, waitstart) as
   select
     null::text,
@@ -1940,68 +2347,6 @@ create view pg_catalog.pg_matviews(schemaname, matviewname, matviewowner, tables
     null::text
 ;
 
-create table pg_catalog.pg_namespace (
-  oid oid,
-  nspname name,
-  nspowner oid,
-  nspacl aclitem[]
-);
-
-create table pg_catalog.pg_opclass (
-  oid oid,
-  opcmethod oid,
-  opcname name,
-  opcnamespace oid,
-  opcowner oid,
-  opcfamily oid,
-  opcintype oid,
-  opcdefault boolean,
-  opckeytype oid
-);
-
-create table pg_catalog.pg_operator (
-  oid oid,
-  oprname name,
-  oprnamespace oid,
-  oprowner oid,
-  oprkind "char",
-  oprcanmerge boolean,
-  oprcanhash boolean,
-  oprleft oid,
-  oprright oid,
-  oprresult oid,
-  oprcom oid,
-  oprnegate oid,
-  oprcode regproc,
-  oprrest regproc,
-  oprjoin regproc
-);
-
-create table pg_catalog.pg_opfamily (
-  oid oid,
-  opfmethod oid,
-  opfname name,
-  opfnamespace oid,
-  opfowner oid
-);
-
-create table pg_catalog.pg_parameter_acl (
-  oid oid,
-  parname text,
-  paracl aclitem[]
-);
-
-create table pg_catalog.pg_partitioned_table (
-  partrelid oid,
-  partstrat "char",
-  partnatts smallint,
-  partdefid oid,
-  partattrs int2vector,
-  partclass oidvector,
-  partcollation oidvector,
-  partexprs pg_node_tree
-);
-
 create view pg_catalog.pg_policies(schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check) as
   select
     null::name,
@@ -2014,17 +2359,6 @@ create view pg_catalog.pg_policies(schemaname, tablename, policyname, permissive
     null::text
 ;
 
-create table pg_catalog.pg_policy (
-  oid oid,
-  polname name,
-  polrelid oid,
-  polcmd "char",
-  polpermissive boolean,
-  polroles oid[],
-  polqual pg_node_tree,
-  polwithcheck pg_node_tree
-);
-
 create view pg_catalog.pg_prepared_statements(name, statement, prepare_time, parameter_types, result_types, from_sql, generic_plans, custom_plans) as
   select
     null::text,
@@ -2033,78 +2367,18 @@ create view pg_catalog.pg_prepared_statements(name, statement, prepare_time, par
     null::regtype[],
     null::regtype[],
     null::boolean,
-    null::bigint,
-    null::bigint
-;
-
-create view pg_catalog.pg_prepared_xacts(transaction, gid, prepared, owner, database) as
-  select
-    null::xid,
-    null::text,
-    null::timestamp with time zone,
-    null::name,
-    null::name
-;
-
-create table pg_catalog.pg_proc (
-  oid oid,
-  proname name,
-  pronamespace oid,
-  proowner oid,
-  prolang oid,
-  procost real,
-  prorows real,
-  provariadic oid,
-  prosupport regproc,
-  prokind "char",
-  prosecdef boolean,
-  proleakproof boolean,
-  proisstrict boolean,
-  proretset boolean,
-  provolatile "char",
-  proparallel "char",
-  pronargs smallint,
-  pronargdefaults smallint,
-  prorettype oid,
-  proargtypes oidvector,
-  proallargtypes oid[],
-  proargmodes "char"[],
-  proargnames text[],
-  proargdefaults pg_node_tree,
-  protrftypes oid[],
-  prosrc text,
-  probin text,
-  prosqlbody pg_node_tree,
-  proconfig text[],
-  proacl aclitem[]
-);
-
-create table pg_catalog.pg_publication (
-  oid oid,
-  pubname name,
-  pubowner oid,
-  puballtables boolean,
-  pubinsert boolean,
-  pubupdate boolean,
-  pubdelete boolean,
-  pubtruncate boolean,
-  pubviaroot boolean,
-  pubgencols "char"
-);
-
-create table pg_catalog.pg_publication_namespace (
-  oid oid,
-  pnpubid oid,
-  pnnspid oid
-);
-
-create table pg_catalog.pg_publication_rel (
-  oid oid,
-  prpubid oid,
-  prrelid oid,
-  prqual pg_node_tree,
-  prattrs int2vector
-);
+    null::bigint,
+    null::bigint
+;
+
+create view pg_catalog.pg_prepared_xacts(transaction, gid, prepared, owner, database) as
+  select
+    null::xid,
+    null::text,
+    null::timestamp with time zone,
+    null::name,
+    null::name
+;
 
 create view pg_catalog.pg_publication_tables(pubname, schemaname, tablename, attnames, rowfilter) as
   select
@@ -2115,21 +2389,6 @@ create view pg_catalog.pg_publication_tables(pubname, schemaname, tablename, att
     null::text
 ;
 
-create table pg_catalog.pg_range (
-  rngtypid oid,
-  rngsubtype oid,
-  rngmultitypid oid,
-  rngcollation oid,
-  rngsubopc oid,
-  rngcanonical regproc,
-  rngsubdiff regproc
-);
-
-create table pg_catalog.pg_replication_origin (
-  roident oid,
-  roname text
-);
-
 create view pg_catalog.pg_replication_origin_status(local_id, external_id, remote_lsn, local_lsn) as
   select
     null::oid,
@@ -2163,17 +2422,6 @@ create view pg_catalog.pg_replication_slots(slot_name, plugin, slot_type, datoid
     null::boolean
 ;
 
-create table pg_catalog.pg_rewrite (
-  oid oid,
-  rulename name,
-  ev_class oid,
-  ev_type "char",
-  ev_enabled "char",
-  is_instead boolean,
-  ev_qual pg_node_tree,
-  ev_action pg_node_tree
-);
-
 create view pg_catalog.pg_roles(rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolconnlimit, rolpassword, rolvaliduntil, rolbypassrls, rolconfig, oid) as
   select
     null::name,
@@ -2199,14 +2447,6 @@ create view pg_catalog.pg_rules(schemaname, tablename, rulename, definition) as
     null::text
 ;
 
-create table pg_catalog.pg_seclabel (
-  objoid oid,
-  classoid oid,
-  objsubid integer,
-  provider text,
-  label text
-);
-
 create view pg_catalog.pg_seclabels(objoid, classoid, objsubid, objtype, objnamespace, objname, provider, label) as
   select
     null::oid,
@@ -2219,17 +2459,6 @@ create view pg_catalog.pg_seclabels(objoid, classoid, objsubid, objtype, objname
     null::text
 ;
 
-create table pg_catalog.pg_sequence (
-  seqrelid oid,
-  seqtypid oid,
-  seqstart bigint,
-  seqincrement bigint,
-  seqmax bigint,
-  seqmin bigint,
-  seqcache bigint,
-  seqcycle boolean
-);
-
 create view pg_catalog.pg_sequences(schemaname, sequencename, sequenceowner, data_type, start_value, min_value, max_value, increment_by, cycle, cache_size, last_value) as
   select
     null::name,
@@ -2279,22 +2508,6 @@ create view pg_catalog.pg_shadow(usename, usesysid, usecreatedb, usesuper, usere
     null::text[]
 ;
 
-create table pg_catalog.pg_shdepend (
-  dbid oid,
-  classid oid,
-  objid oid,
-  objsubid integer,
-  refclassid oid,
-  refobjid oid,
-  deptype "char"
-);
-
-create table pg_catalog.pg_shdescription (
-  objoid oid,
-  classoid oid,
-  description text
-);
-
 create view pg_catalog.pg_shmem_allocations(name, off, size, allocated_size) as
   select
     null::text,
@@ -2310,13 +2523,6 @@ create view pg_catalog.pg_shmem_allocations_numa(name, numa_node, size) as
     null::bigint
 ;
 
-create table pg_catalog.pg_shseclabel (
-  objoid oid,
-  classoid oid,
-  provider text,
-  label text
-);
-
 create view pg_catalog.pg_stat_activity(datid, datname, pid, leader_pid, usesysid, usename, application_name, client_addr, client_hostname, client_port, backend_start, xact_start, query_start, state_change, wait_event_type, wait_event, state, backend_xid, backend_xmin, query_id, query, backend_type) as
   select
     null::oid,
@@ -3003,61 +3209,6 @@ create view pg_catalog.pg_statio_user_tables(relid, schemaname, relname, heap_bl
     null::bigint
 ;
 
-create table pg_catalog.pg_statistic (
-  starelid oid,
-  staattnum smallint,
-  stainherit boolean,
-  stanullfrac real,
-  stawidth integer,
-  stadistinct real,
-  stakind1 smallint,
-  stakind2 smallint,
-  stakind3 smallint,
-  stakind4 smallint,
-  stakind5 smallint,
-  staop1 oid,
-  staop2 oid,
-  staop3 oid,
-  staop4 oid,
-  staop5 oid,
-  stacoll1 oid,
-  stacoll2 oid,
-  stacoll3 oid,
-  stacoll4 oid,
-  stacoll5 oid,
-  stanumbers1 real[],
-  stanumbers2 real[],
-  stanumbers3 real[],
-  stanumbers4 real[],
-  stanumbers5 real[],
-  stavalues1 anyarray,
-  stavalues2 anyarray,
-  stavalues3 anyarray,
-  stavalues4 anyarray,
-  stavalues5 anyarray
-);
-
-create table pg_catalog.pg_statistic_ext (
-  oid oid,
-  stxrelid oid,
-  stxname name,
-  stxnamespace oid,
-  stxowner oid,
-  stxkeys int2vector,
-  stxstattarget smallint,
-  stxkind "char"[],
-  stxexprs pg_node_tree
-);
-
-create table pg_catalog.pg_statistic_ext_data (
-  stxoid oid,
-  stxdinherit boolean,
-  stxdndistinct pg_ndistinct,
-  stxddependencies pg_dependencies,
-  stxdmcv pg_mcv_list,
-  stxdexpr pg_statistic[]
-);
-
 create view pg_catalog.pg_stats(schemaname, tablename, attname, inherited, null_frac, avg_width, n_distinct, most_common_vals, most_common_freqs, histogram_bounds, correlation, most_common_elems, most_common_elem_freqs, elem_count_histogram, range_length_histogram, range_empty_frac, range_bounds_histogram) as
   select
     null::name,
@@ -3119,176 +3270,32 @@ create view pg_catalog.pg_stats_ext_exprs(schemaname, tablename, statistics_sche
     null::real[]
 ;
 
-create table pg_catalog.pg_subscription (
-  oid oid,
-  subdbid oid,
-  subskiplsn pg_lsn,
-  subname name,
-  subowner oid,
-  subenabled boolean,
-  subbinary boolean,
-  substream "char",
-  subtwophasestate "char",
-  subdisableonerr boolean,
-  subpasswordrequired boolean,
-  subrunasowner boolean,
-  subfailover boolean,
-  subconninfo text,
-  subslotname name,
-  subsynccommit text,
-  subpublications text[],
-  suborigin text
-);
-
-create table pg_catalog.pg_subscription_rel (
-  srsubid oid,
-  srrelid oid,
-  srsubstate "char",
-  srsublsn pg_lsn
-);
-
 create view pg_catalog.pg_tables(schemaname, tablename, tableowner, tablespace, hasindexes, hasrules, hastriggers, rowsecurity) as
   select
     null::name,
     null::name,
     null::name,
     null::name,
-    null::boolean,
-    null::boolean,
-    null::boolean,
-    null::boolean
-;
-
-create table pg_catalog.pg_tablespace (
-  oid oid,
-  spcname name,
-  spcowner oid,
-  spcacl aclitem[],
-  spcoptions text[]
-);
-
-create view pg_catalog.pg_timezone_abbrevs(abbrev, utc_offset, is_dst) as
-  select
-    null::text,
-    null::interval,
-    null::boolean
-;
-
-create view pg_catalog.pg_timezone_names(name, abbrev, utc_offset, is_dst) as
-  select
-    null::text,
-    null::text,
-    null::interval,
-    null::boolean
-;
-
-create table pg_catalog.pg_transform (
-  oid oid,
-  trftype oid,
-  trflang oid,
-  trffromsql regproc,
-  trftosql regproc
-);
-
-create table pg_catalog.pg_trigger (
-  oid oid,
-  tgrelid oid,
-  tgparentid oid,
-  tgname name,
-  tgfoid oid,
-  tgtype smallint,
-  tgenabled "char",
-  tgisinternal boolean,
-  tgconstrrelid oid,
-  tgconstrindid oid,
-  tgconstraint oid,
-  tgdeferrable boolean,
-  tginitdeferred boolean,
-  tgnargs smallint,
-  tgattr int2vector,
-  tgargs bytea,
-  tgqual pg_node_tree,
-  tgoldtable name,
-  tgnewtable name
-);
-
-create table pg_catalog.pg_ts_config (
-  oid oid,
-  cfgname name,
-  cfgnamespace oid,
-  cfgowner oid,
-  cfgparser oid
-);
-
-create table pg_catalog.pg_ts_config_map (
-  mapcfg oid,
-  maptokentype integer,
-  mapseqno integer,
-  mapdict oid
-);
-
-create table pg_catalog.pg_ts_dict (
-  oid oid,
-  dictname name,
-  dictnamespace oid,
-  dictowner oid,
-  dicttemplate oid,
-  dictinitoption text
-);
-
-create table pg_catalog.pg_ts_parser (
-  oid oid,
-  prsname name,
-  prsnamespace oid,
-  prsstart regproc,
-  prstoken regproc,
-  prsend regproc,
-  prsheadline regproc,
-  prslextype regproc
-);
+    null::boolean,
+    null::boolean,
+    null::boolean,
+    null::boolean
+;
 
-create table pg_catalog.pg_ts_template (
-  oid oid,
-  tmplname name,
-  tmplnamespace oid,
-  tmplinit regproc,
-  tmpllexize regproc
-);
+create view pg_catalog.pg_timezone_abbrevs(abbrev, utc_offset, is_dst) as
+  select
+    null::text,
+    null::interval,
+    null::boolean
+;
 
-create table pg_catalog.pg_type (
-  oid oid,
-  typname name,
-  typnamespace oid,
-  typowner oid,
-  typlen smallint,
-  typbyval boolean,
-  typtype "char",
-  typcategory "char",
-  typispreferred boolean,
-  typisdefined boolean,
-  typdelim "char",
-  typrelid oid,
-  typsubscript regproc,
-  typelem oid,
-  typarray oid,
-  typinput regproc,
-  typoutput regproc,
-  typreceive regproc,
-  typsend regproc,
-  typmodin regproc,
-  typmodout regproc,
-  typanalyze regproc,
-  typalign "char",
-  typstorage "char",
-  typnotnull boolean,
-  typbasetype oid,
-  typtypmod integer,
-  typndims integer,
-  typcollation oid,
-  typdefaultbin pg_node_tree,
-  typdefault text,
-  typacl aclitem[]
-);
+create view pg_catalog.pg_timezone_names(name, abbrev, utc_offset, is_dst) as
+  select
+    null::text,
+    null::text,
+    null::interval,
+    null::boolean
+;
 
 create view pg_catalog.pg_user(usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, passwd, valuntil, useconfig) as
   select
@@ -3303,13 +3310,6 @@ create view pg_catalog.pg_user(usename, usesysid, usecreatedb, usesuper, userepl
     null::text[]
 ;
 
-create table pg_catalog.pg_user_mapping (
-  oid oid,
-  umuser oid,
-  umserver oid,
-  umoptions text[]
-);
-
 create view pg_catalog.pg_user_mappings(umid, srvid, srvname, umuser, usename, umoptions) as
   select
     null::oid,
@@ -13557,15 +13557,6 @@ create function pg_catalog.plainto_tsquery(regconfig, text) returns tsquery
 create function pg_catalog.plainto_tsquery(text) returns tsquery
   language internal;
 
-create function pg_catalog.plpgsql_call_handler() returns language_handler
-  language c;
-
-create function pg_catalog.plpgsql_inline_handler(internal) returns void
-  language c;
-
-create function pg_catalog.plpgsql_validator(oid) returns void
-  language c;
-
 -- center of
 create function pg_catalog.point(box) returns point
   language internal;
@@ -17475,23 +17466,23 @@ create operator pg_catalog.!! (
 
 -- does not match regular expression, case-sensitive
 create operator pg_catalog.!~ (
-  leftarg = text,
+  leftarg = character,
   rightarg = text,
-  function = pg_catalog.textregexne
+  function = pg_catalog.bpcharregexne
 );
 
 -- does not match regular expression, case-sensitive
 create operator pg_catalog.!~ (
-  leftarg = character,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.bpcharregexne
+  function = pg_catalog.nameregexne
 );
 
 -- does not match regular expression, case-sensitive
 create operator pg_catalog.!~ (
-  leftarg = name,
+  leftarg = text,
   rightarg = text,
-  function = pg_catalog.nameregexne
+  function = pg_catalog.textregexne
 );
 
 -- does not match regular expression, case-insensitive
@@ -17503,16 +17494,16 @@ create operator pg_catalog.!~* (
 
 -- does not match regular expression, case-insensitive
 create operator pg_catalog.!~* (
-  leftarg = text,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.texticregexne
+  function = pg_catalog.nameicregexne
 );
 
 -- does not match regular expression, case-insensitive
 create operator pg_catalog.!~* (
-  leftarg = name,
+  leftarg = text,
   rightarg = text,
-  function = pg_catalog.nameicregexne
+  function = pg_catalog.texticregexne
 );
 
 -- does not match LIKE expression
@@ -17524,9 +17515,9 @@ create operator pg_catalog.!~~ (
 
 -- does not match LIKE expression
 create operator pg_catalog.!~~ (
-  leftarg = text,
+  leftarg = character,
   rightarg = text,
-  function = pg_catalog.textnlike
+  function = pg_catalog.bpcharnlike
 );
 
 -- does not match LIKE expression
@@ -17538,23 +17529,23 @@ create operator pg_catalog.!~~ (
 
 -- does not match LIKE expression
 create operator pg_catalog.!~~ (
-  leftarg = character,
+  leftarg = text,
   rightarg = text,
-  function = pg_catalog.bpcharnlike
+  function = pg_catalog.textnlike
 );
 
 -- does not match LIKE expression, case-insensitive
 create operator pg_catalog.!~~* (
-  leftarg = name,
+  leftarg = character,
   rightarg = text,
-  function = pg_catalog.nameicnlike
+  function = pg_catalog.bpcharicnlike
 );
 
 -- does not match LIKE expression, case-insensitive
 create operator pg_catalog.!~~* (
-  leftarg = character,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.bpcharicnlike
+  function = pg_catalog.nameicnlike
 );
 
 -- does not match LIKE expression, case-insensitive
@@ -17564,20 +17555,6 @@ create operator pg_catalog.!~~* (
   function = pg_catalog.texticnlike
 );
 
--- box intersection
-create operator pg_catalog.# (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_intersect
-);
-
--- intersection point
-create operator pg_catalog.# (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_interpt
-);
-
 -- number of points
 create operator pg_catalog.# (
   rightarg = path,
@@ -17590,11 +17567,11 @@ create operator pg_catalog.# (
   function = pg_catalog.poly_npoints
 );
 
--- intersection point
+-- bitwise exclusive or
 create operator pg_catalog.# (
-  leftarg = line,
-  rightarg = line,
-  function = pg_catalog.line_interpt
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8xor
 );
 
 -- bitwise exclusive or
@@ -17604,11 +17581,11 @@ create operator pg_catalog.# (
   function = pg_catalog.bitxor
 );
 
--- bitwise exclusive or
+-- box intersection
 create operator pg_catalog.# (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2xor
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_intersect
 );
 
 -- bitwise exclusive or
@@ -17618,18 +17595,32 @@ create operator pg_catalog.# (
   function = pg_catalog.int4xor
 );
 
+-- intersection point
+create operator pg_catalog.# (
+  leftarg = line,
+  rightarg = line,
+  function = pg_catalog.line_interpt
+);
+
+-- intersection point
+create operator pg_catalog.# (
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_interpt
+);
+
 -- bitwise exclusive or
 create operator pg_catalog.# (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8xor
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2xor
 );
 
 -- closest point to A on B
 create operator pg_catalog.## (
-  leftarg = point,
-  rightarg = box,
-  function = pg_catalog.close_pb
+  leftarg = line,
+  rightarg = lseg,
+  function = pg_catalog.close_ls
 );
 
 -- closest point to A on B
@@ -17648,23 +17639,23 @@ create operator pg_catalog.## (
 
 -- closest point to A on B
 create operator pg_catalog.## (
-  leftarg = line,
-  rightarg = lseg,
-  function = pg_catalog.close_ls
+  leftarg = point,
+  rightarg = box,
+  function = pg_catalog.close_pb
 );
 
 -- closest point to A on B
 create operator pg_catalog.## (
   leftarg = point,
-  rightarg = lseg,
-  function = pg_catalog.close_ps
+  rightarg = line,
+  function = pg_catalog.close_pl
 );
 
 -- closest point to A on B
 create operator pg_catalog.## (
   leftarg = point,
-  rightarg = line,
-  function = pg_catalog.close_pl
+  rightarg = lseg,
+  function = pg_catalog.close_ps
 );
 
 -- delete path
@@ -17704,9 +17695,9 @@ create operator pg_catalog.#>> (
 
 -- modulus
 create operator pg_catalog.% (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2mod
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8mod
 );
 
 -- modulus
@@ -17718,16 +17709,16 @@ create operator pg_catalog.% (
 
 -- modulus
 create operator pg_catalog.% (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8mod
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_mod
 );
 
 -- modulus
 create operator pg_catalog.% (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_mod
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2mod
 );
 
 -- bitwise and
@@ -17737,6 +17728,13 @@ create operator pg_catalog.& (
   function = pg_catalog.int8and
 );
 
+-- bitwise and
+create operator pg_catalog.& (
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.bitand
+);
+
 -- bitwise and
 create operator pg_catalog.& (
   leftarg = inet,
@@ -17746,37 +17744,37 @@ create operator pg_catalog.& (
 
 -- bitwise and
 create operator pg_catalog.& (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2and
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4and
 );
 
 -- bitwise and
 create operator pg_catalog.& (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_and
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_and
 );
 
 -- bitwise and
 create operator pg_catalog.& (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.bitand
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_and
 );
 
 -- bitwise and
 create operator pg_catalog.& (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_and
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2and
 );
 
--- bitwise and
-create operator pg_catalog.& (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4and
+-- overlaps
+create operator pg_catalog.&& (
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.arrayoverlap
 );
 
 -- overlaps
@@ -17788,9 +17786,9 @@ create operator pg_catalog.&& (
 
 -- overlaps
 create operator pg_catalog.&& (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.arrayoverlap
+  leftarg = anymultirange,
+  rightarg = anyrange,
+  function = pg_catalog.multirange_overlaps_range
 );
 
 -- overlaps
@@ -17802,16 +17800,23 @@ create operator pg_catalog.&& (
 
 -- overlaps
 create operator pg_catalog.&& (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_overlap
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_overlaps
+);
+
+-- overlaps
+create operator pg_catalog.&& (
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_overlap
 );
 
 -- overlaps
 create operator pg_catalog.&& (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_overlap
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_overlap
 );
 
 -- overlaps (is subnet or supernet)
@@ -17823,9 +17828,9 @@ create operator pg_catalog.&& (
 
 -- overlaps
 create operator pg_catalog.&& (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_overlaps
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_overlap
 );
 
 -- AND-concatenate
@@ -17835,18 +17840,25 @@ create operator pg_catalog.&& (
   function = pg_catalog.tsquery_and
 );
 
--- overlaps
-create operator pg_catalog.&& (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_overlap
+-- overlaps or is left of
+create operator pg_catalog.&< (
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_overleft_multirange
 );
 
--- overlaps
-create operator pg_catalog.&& (
+-- overlaps or is left of
+create operator pg_catalog.&< (
   leftarg = anymultirange,
   rightarg = anyrange,
-  function = pg_catalog.multirange_overlaps_range
+  function = pg_catalog.multirange_overleft_range
+);
+
+-- overlaps or is left of
+create operator pg_catalog.&< (
+  leftarg = anyrange,
+  rightarg = anymultirange,
+  function = pg_catalog.range_overleft_multirange
 );
 
 -- overlaps or is left of
@@ -17870,27 +17882,6 @@ create operator pg_catalog.&< (
   function = pg_catalog.circle_overleft
 );
 
--- overlaps or is left of
-create operator pg_catalog.&< (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_overleft_multirange
-);
-
--- overlaps or is left of
-create operator pg_catalog.&< (
-  leftarg = anymultirange,
-  rightarg = anyrange,
-  function = pg_catalog.multirange_overleft_range
-);
-
--- overlaps or is left of
-create operator pg_catalog.&< (
-  leftarg = anyrange,
-  rightarg = anymultirange,
-  function = pg_catalog.range_overleft_multirange
-);
-
 -- overlaps or is left of
 create operator pg_catalog.&< (
   leftarg = polygon,
@@ -17907,30 +17898,30 @@ create operator pg_catalog.&<| (
 
 -- overlaps or is below
 create operator pg_catalog.&<| (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_overbelow
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_overbelow
 );
 
 -- overlaps or is below
 create operator pg_catalog.&<| (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_overbelow
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_overbelow
 );
 
 -- overlaps or is right of
 create operator pg_catalog.&> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_overright
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_overright_multirange
 );
 
 -- overlaps or is right of
 create operator pg_catalog.&> (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_overright
+  leftarg = anymultirange,
+  rightarg = anyrange,
+  function = pg_catalog.multirange_overright_range
 );
 
 -- overlaps or is right of
@@ -17949,16 +17940,9 @@ create operator pg_catalog.&> (
 
 -- overlaps or is right of
 create operator pg_catalog.&> (
-  leftarg = anymultirange,
-  rightarg = anyrange,
-  function = pg_catalog.multirange_overright_range
-);
-
--- overlaps or is right of
-create operator pg_catalog.&> (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_overright_multirange
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_overright
 );
 
 -- overlaps or is right of
@@ -17968,67 +17952,67 @@ create operator pg_catalog.&> (
   function = pg_catalog.circle_overright
 );
 
--- multiply
-create operator pg_catalog.* (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_mul
+-- overlaps or is right of
+create operator pg_catalog.&> (
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_overright
 );
 
--- multiply
+-- multirange intersect
 create operator pg_catalog.* (
-  leftarg = real,
-  rightarg = money,
-  function = pg_catalog.flt4_mul_cash
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_intersect
 );
 
--- multiply
+-- range intersection
 create operator pg_catalog.* (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4mul
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_intersect
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = money,
-  rightarg = real,
-  function = pg_catalog.cash_mul_flt4
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2mul
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24mul
+  leftarg = bigint,
+  rightarg = money,
+  function = pg_catalog.int8_mul_cash
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = integer,
+  leftarg = bigint,
   rightarg = smallint,
-  function = pg_catalog.int42mul
+  function = pg_catalog.int82mul
 );
 
--- range intersection
+-- multiply box by point (scale)
 create operator pg_catalog.* (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_intersect
+  leftarg = box,
+  rightarg = point,
+  function = pg_catalog.box_mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4mul
+  leftarg = circle,
+  rightarg = point,
+  function = pg_catalog.circle_mul_pt
 );
 
 -- multiply
@@ -18047,16 +18031,9 @@ create operator pg_catalog.* (
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = interval,
-  rightarg = double precision,
-  function = pg_catalog.interval_mul
-);
-
--- multiply
-create operator pg_catalog.* (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48mul
+  leftarg = double precision,
+  rightarg = money,
+  function = pg_catalog.flt8_mul_cash
 );
 
 -- multiply
@@ -18066,130 +18043,144 @@ create operator pg_catalog.* (
   function = pg_catalog.float84mul
 );
 
--- multiply points (scale/rotate)
+-- multiply
 create operator pg_catalog.* (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_mul
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48mul
 );
 
--- multiply (rotate/scale path)
+-- multiply
 create operator pg_catalog.* (
-  leftarg = path,
-  rightarg = point,
-  function = pg_catalog.path_mul_pt
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4mul
 );
 
--- multirange intersect
+-- multiply
 create operator pg_catalog.* (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_intersect
+  leftarg = integer,
+  rightarg = money,
+  function = pg_catalog.int4_mul_cash
 );
 
--- multiply box by point (scale)
+-- multiply
 create operator pg_catalog.* (
-  leftarg = box,
-  rightarg = point,
-  function = pg_catalog.box_mul
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28mul
+  leftarg = interval,
+  rightarg = double precision,
+  function = pg_catalog.interval_mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82mul
+  leftarg = money,
+  rightarg = bigint,
+  function = pg_catalog.cash_mul_int8
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48mul
+  leftarg = money,
+  rightarg = double precision,
+  function = pg_catalog.cash_mul_flt8
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = bigint,
+  leftarg = money,
   rightarg = integer,
-  function = pg_catalog.int84mul
+  function = pg_catalog.cash_mul_int4
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = circle,
-  rightarg = point,
-  function = pg_catalog.circle_mul_pt
+  leftarg = money,
+  rightarg = real,
+  function = pg_catalog.cash_mul_flt4
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8mul
+  leftarg = money,
+  rightarg = smallint,
+  function = pg_catalog.cash_mul_int2
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = double precision,
-  rightarg = money,
-  function = pg_catalog.flt8_mul_cash
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_mul
+);
+
+-- multiply (rotate/scale path)
+create operator pg_catalog.* (
+  leftarg = path,
+  rightarg = point,
+  function = pg_catalog.path_mul_pt
+);
+
+-- multiply points (scale/rotate)
+create operator pg_catalog.* (
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = money,
+  leftarg = real,
   rightarg = double precision,
-  function = pg_catalog.cash_mul_flt8
+  function = pg_catalog.float48mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = money,
-  rightarg = smallint,
-  function = pg_catalog.cash_mul_int2
+  leftarg = real,
+  rightarg = money,
+  function = pg_catalog.flt4_mul_cash
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = money,
-  rightarg = integer,
-  function = pg_catalog.cash_mul_int4
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = money,
+  leftarg = smallint,
   rightarg = bigint,
-  function = pg_catalog.cash_mul_int8
+  function = pg_catalog.int28mul
 );
 
 -- multiply
 create operator pg_catalog.* (
   leftarg = smallint,
-  rightarg = money,
-  function = pg_catalog.int2_mul_cash
+  rightarg = integer,
+  function = pg_catalog.int24mul
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = integer,
+  leftarg = smallint,
   rightarg = money,
-  function = pg_catalog.int4_mul_cash
+  function = pg_catalog.int2_mul_cash
 );
 
 -- multiply
 create operator pg_catalog.* (
-  leftarg = bigint,
-  rightarg = money,
-  function = pg_catalog.int8_mul_cash
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2mul
 );
 
 -- less than
@@ -18234,108 +18225,96 @@ create operator pg_catalog.*>= (
   function = pg_catalog.record_image_ge
 );
 
--- convert date and time to timestamp
-create operator pg_catalog.+ (
-  leftarg = date,
-  rightarg = time without time zone,
-  function = pg_catalog.datetime_pl
-);
-
--- add
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = numeric,
-  rightarg = pg_lsn,
-  function = pg_catalog.numeric_pl_pg_lsn
+  rightarg = bigint,
+  function = pg_catalog.int8up
 );
 
--- convert time and date to timestamp
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = time without time zone,
-  rightarg = date,
-  function = pg_catalog.timedate_pl
+  rightarg = double precision,
+  function = pg_catalog.float8up
 );
 
--- add
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48pl
+  rightarg = integer,
+  function = pg_catalog.int4up
 );
 
--- convert time with time zone and date to timestamp with time zone
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = time with time zone,
-  rightarg = date,
-  function = pg_catalog.timetzdate_pl
+  rightarg = numeric,
+  function = pg_catalog.numeric_uplus
 );
 
--- add
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = timestamp with time zone,
-  rightarg = interval,
-  function = pg_catalog.timestamptz_pl_interval
+  rightarg = real,
+  function = pg_catalog.float4up
 );
 
--- add
+-- unary plus
 create operator pg_catalog.+ (
-  leftarg = inet,
-  rightarg = bigint,
-  function = pg_catalog.inetpl
+  rightarg = smallint,
+  function = pg_catalog.int2up
 );
 
--- add
+-- add/update ACL item
 create operator pg_catalog.+ (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4pl
+  leftarg = aclitem[],
+  rightarg = aclitem,
+  function = pg_catalog.aclinsert
 );
 
--- add
+-- multirange union
 create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_pl
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_union
 );
 
--- unary plus
+-- range union
 create operator pg_catalog.+ (
-  rightarg = double precision,
-  function = pg_catalog.float8up
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_union
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_pl
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = time without time zone,
-  function = pg_catalog.interval_pl_time
+  leftarg = bigint,
+  rightarg = inet,
+  function = pg_catalog.int8pl_inet
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = date,
-  function = pg_catalog.interval_pl_date
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = time with time zone,
-  function = pg_catalog.interval_pl_timetz
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82pl
 );
 
--- add
+-- add point to box (translate)
 create operator pg_catalog.+ (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84pl
+  leftarg = box,
+  rightarg = point,
+  function = pg_catalog.box_add
 );
 
 -- add
@@ -18345,59 +18324,60 @@ create operator pg_catalog.+ (
   function = pg_catalog.circle_add_pt
 );
 
--- unary plus
+-- add
 create operator pg_catalog.+ (
-  rightarg = numeric,
-  function = pg_catalog.numeric_uplus
+  leftarg = date,
+  rightarg = integer,
+  function = pg_catalog.date_pli
 );
 
--- range union
+-- add
 create operator pg_catalog.+ (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_union
+  leftarg = date,
+  rightarg = interval,
+  function = pg_catalog.date_pl_interval
 );
 
--- add
+-- convert date and time with time zone to timestamp with time zone
 create operator pg_catalog.+ (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2pl
+  leftarg = date,
+  rightarg = time with time zone,
+  function = pg_catalog.datetimetz_pl
 );
 
--- add
+-- convert date and time to timestamp
 create operator pg_catalog.+ (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4pl
+  leftarg = date,
+  rightarg = time without time zone,
+  function = pg_catalog.datetime_pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24pl
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42pl
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = pg_lsn,
-  rightarg = numeric,
-  function = pg_catalog.pg_lsn_pli
+  leftarg = inet,
+  rightarg = bigint,
+  function = pg_catalog.inetpl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8pl
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48pl
 );
 
 -- add
@@ -18409,69 +18389,79 @@ create operator pg_catalog.+ (
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = date,
+  leftarg = integer,
   rightarg = integer,
-  function = pg_catalog.date_pli
+  function = pg_catalog.int4pl
 );
 
--- add points (translate)
+-- add
 create operator pg_catalog.+ (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_add
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42pl
 );
 
--- unary plus
+-- add
 create operator pg_catalog.+ (
-  rightarg = bigint,
-  function = pg_catalog.int8up
+  leftarg = interval,
+  rightarg = date,
+  function = pg_catalog.interval_pl_date
 );
 
--- add/update ACL item
+-- add
 create operator pg_catalog.+ (
-  leftarg = aclitem[],
-  rightarg = aclitem,
-  function = pg_catalog.aclinsert
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = timestamp without time zone,
-  rightarg = interval,
-  function = pg_catalog.timestamp_pl_interval
+  leftarg = interval,
+  rightarg = time with time zone,
+  function = pg_catalog.interval_pl_timetz
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = time with time zone,
-  rightarg = interval,
-  function = pg_catalog.timetz_pl_interval
+  leftarg = interval,
+  rightarg = time without time zone,
+  function = pg_catalog.interval_pl_time
 );
 
--- unary plus
+-- add
 create operator pg_catalog.+ (
-  rightarg = smallint,
-  function = pg_catalog.int2up
+  leftarg = interval,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.interval_pl_timestamptz
 );
 
--- unary plus
+-- add
 create operator pg_catalog.+ (
-  rightarg = integer,
-  function = pg_catalog.int4up
+  leftarg = interval,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.interval_pl_timestamp
 );
 
--- add (translate path)
+-- add
 create operator pg_catalog.+ (
-  leftarg = path,
-  rightarg = point,
-  function = pg_catalog.path_add_pt
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_pl
+);
+
+-- add
+create operator pg_catalog.+ (
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_add
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = time without time zone,
-  rightarg = interval,
-  function = pg_catalog.time_pl_interval
+  leftarg = numeric,
+  rightarg = pg_lsn,
+  function = pg_catalog.numeric_pl_pg_lsn
 );
 
 -- concatenate
@@ -18481,45 +18471,39 @@ create operator pg_catalog.+ (
   function = pg_catalog.path_add
 );
 
--- add
-create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.interval_pl_timestamp
-);
-
--- add
+-- add (translate path)
 create operator pg_catalog.+ (
-  leftarg = interval,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.interval_pl_timestamptz
+  leftarg = path,
+  rightarg = point,
+  function = pg_catalog.path_add_pt
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82pl
+  leftarg = pg_lsn,
+  rightarg = numeric,
+  function = pg_catalog.pg_lsn_pli
 );
 
--- add point to box (translate)
+-- add points (translate)
 create operator pg_catalog.+ (
-  leftarg = box,
+  leftarg = point,
   rightarg = point,
-  function = pg_catalog.box_add
+  function = pg_catalog.point_add
 );
 
--- convert date and time with time zone to timestamp with time zone
+-- add
 create operator pg_catalog.+ (
-  leftarg = date,
-  rightarg = time with time zone,
-  function = pg_catalog.datetimetz_pl
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48pl
 );
 
--- unary plus
+-- add
 create operator pg_catalog.+ (
+  leftarg = real,
   rightarg = real,
-  function = pg_catalog.float4up
+  function = pg_catalog.float4pl
 );
 
 -- add
@@ -18531,57 +18515,70 @@ create operator pg_catalog.+ (
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = bigint,
-  rightarg = inet,
-  function = pg_catalog.int8pl_inet
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_add
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2pl
 );
 
--- multirange union
+-- convert time with time zone and date to timestamp with time zone
 create operator pg_catalog.+ (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_union
+  leftarg = time with time zone,
+  rightarg = date,
+  function = pg_catalog.timetzdate_pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48pl
+  leftarg = time with time zone,
+  rightarg = interval,
+  function = pg_catalog.timetz_pl_interval
+);
+
+-- convert time and date to timestamp
+create operator pg_catalog.+ (
+  leftarg = time without time zone,
+  rightarg = date,
+  function = pg_catalog.timedate_pl
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8pl
+  leftarg = time without time zone,
+  rightarg = interval,
+  function = pg_catalog.time_pl_interval
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = date,
+  leftarg = timestamp with time zone,
   rightarg = interval,
-  function = pg_catalog.date_pl_interval
+  function = pg_catalog.timestamptz_pl_interval
 );
 
 -- add
 create operator pg_catalog.+ (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84pl
+  leftarg = timestamp without time zone,
+  rightarg = interval,
+  function = pg_catalog.timestamp_pl_interval
 );
 
 -- negate
 create operator pg_catalog.- (
-  rightarg = real,
-  function = pg_catalog.float4um
+  rightarg = bigint,
+  function = pg_catalog.int8um
+);
+
+-- negate
+create operator pg_catalog.- (
+  rightarg = double precision,
+  function = pg_catalog.float8um
 );
 
 -- negate
@@ -18592,188 +18589,180 @@ create operator pg_catalog.- (
 
 -- negate
 create operator pg_catalog.- (
-  rightarg = smallint,
-  function = pg_catalog.int2um
+  rightarg = interval,
+  function = pg_catalog.interval_um
 );
 
--- subtract
+-- negate
 create operator pg_catalog.- (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_mi
+  rightarg = numeric,
+  function = pg_catalog.numeric_uminus
 );
 
--- subtract
+-- negate
 create operator pg_catalog.- (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8mi
+  rightarg = real,
+  function = pg_catalog.float4um
 );
 
 -- negate
 create operator pg_catalog.- (
-  rightarg = double precision,
-  function = pg_catalog.float8um
+  rightarg = smallint,
+  function = pg_catalog.int2um
 );
 
--- subtract
+-- remove ACL item
 create operator pg_catalog.- (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_mi_time
+  leftarg = aclitem[],
+  rightarg = aclitem,
+  function = pg_catalog.aclremove
 );
 
--- subtract
+-- multirange minus
 create operator pg_catalog.- (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.inetmi
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_minus
 );
 
--- subtract
+-- range difference
 create operator pg_catalog.- (
-  leftarg = inet,
-  rightarg = bigint,
-  function = pg_catalog.inetmi_int8
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_minus
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_mi
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = timestamp without time zone,
-  rightarg = interval,
-  function = pg_catalog.timestamp_mi_interval
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = date,
-  rightarg = interval,
-  function = pg_catalog.date_mi_interval
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82mi
 );
 
--- minus
+-- subtract point from box (translate)
 create operator pg_catalog.- (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_mi
+  leftarg = box,
+  rightarg = point,
+  function = pg_catalog.box_sub
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = pg_lsn,
-  rightarg = numeric,
-  function = pg_catalog.pg_lsn_mii
+  leftarg = circle,
+  rightarg = point,
+  function = pg_catalog.circle_sub_pt
 );
 
--- remove ACL item
+-- subtract
 create operator pg_catalog.- (
-  leftarg = aclitem[],
-  rightarg = aclitem,
-  function = pg_catalog.aclremove
+  leftarg = date,
+  rightarg = date,
+  function = pg_catalog.date_mi
 );
 
--- negate
+-- subtract
 create operator pg_catalog.- (
-  rightarg = bigint,
-  function = pg_catalog.int8um
+  leftarg = date,
+  rightarg = integer,
+  function = pg_catalog.date_mii
 );
 
--- delete object field
+-- subtract
 create operator pg_catalog.- (
-  leftarg = jsonb,
-  rightarg = text,
-  function = pg_catalog.jsonb_delete
+  leftarg = date,
+  rightarg = interval,
+  function = pg_catalog.date_mi_interval
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = real,
+  leftarg = double precision,
   rightarg = double precision,
-  function = pg_catalog.float48mi
+  function = pg_catalog.float8mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8mi
-);
-
--- delete array element
-create operator pg_catalog.- (
-  leftarg = jsonb,
-  rightarg = integer,
-  function = pg_catalog.jsonb_delete
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84mi
+  leftarg = inet,
+  rightarg = bigint,
+  function = pg_catalog.inetmi_int8
 );
 
--- delete object fields
+-- subtract
 create operator pg_catalog.- (
-  leftarg = jsonb,
-  rightarg = text[],
-  function = pg_catalog.jsonb_delete
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.inetmi
 );
 
--- multirange minus
+-- subtract
 create operator pg_catalog.- (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_minus
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48mi
 );
 
--- subtract points (translate)
+-- subtract
 create operator pg_catalog.- (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_sub
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4mi
 );
 
--- subtract (translate path)
+-- subtract
 create operator pg_catalog.- (
-  leftarg = path,
-  rightarg = point,
-  function = pg_catalog.path_sub_pt
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42mi
 );
 
--- subtract point from box (translate)
+-- subtract
 create operator pg_catalog.- (
-  leftarg = box,
-  rightarg = point,
-  function = pg_catalog.box_sub
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_mi
 );
 
--- subtract
+-- delete array element
 create operator pg_catalog.- (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28mi
+  leftarg = jsonb,
+  rightarg = integer,
+  function = pg_catalog.jsonb_delete
 );
 
--- subtract
+-- delete object field
 create operator pg_catalog.- (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82mi
+  leftarg = jsonb,
+  rightarg = text,
+  function = pg_catalog.jsonb_delete
 );
 
--- subtract
+-- delete object fields
 create operator pg_catalog.- (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48mi
+  leftarg = jsonb,
+  rightarg = text[],
+  function = pg_catalog.jsonb_delete
 );
 
 -- subtract
@@ -18785,119 +18774,121 @@ create operator pg_catalog.- (
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84mi
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_sub
 );
 
--- subtract
+-- subtract (translate path)
 create operator pg_catalog.- (
-  leftarg = timestamp with time zone,
-  rightarg = interval,
-  function = pg_catalog.timestamptz_mi_interval
+  leftarg = path,
+  rightarg = point,
+  function = pg_catalog.path_sub_pt
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_mi
+  leftarg = pg_lsn,
+  rightarg = numeric,
+  function = pg_catalog.pg_lsn_mii
 );
 
--- subtract
+-- minus
 create operator pg_catalog.- (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_mi
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_mi
 );
 
--- negate
+-- subtract points (translate)
 create operator pg_catalog.- (
-  rightarg = interval,
-  function = pg_catalog.interval_um
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_sub
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = circle,
-  rightarg = point,
-  function = pg_catalog.circle_sub_pt
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = date,
-  rightarg = integer,
-  function = pg_catalog.date_mii
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4mi
 );
 
 -- subtract
 create operator pg_catalog.- (
   leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2mi
+  rightarg = bigint,
+  function = pg_catalog.int28mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = integer,
+  leftarg = smallint,
   rightarg = integer,
-  function = pg_catalog.int4mi
+  function = pg_catalog.int24mi
 );
 
 -- subtract
 create operator pg_catalog.- (
   leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24mi
+  rightarg = smallint,
+  function = pg_catalog.int2mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42mi
+  leftarg = time with time zone,
+  rightarg = interval,
+  function = pg_catalog.timetz_mi_interval
 );
 
--- range difference
+-- subtract
 create operator pg_catalog.- (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_minus
+  leftarg = time without time zone,
+  rightarg = interval,
+  function = pg_catalog.time_mi_interval
 );
 
--- negate
+-- subtract
 create operator pg_catalog.- (
-  rightarg = numeric,
-  function = pg_catalog.numeric_uminus
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_mi_time
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = time with time zone,
+  leftarg = timestamp with time zone,
   rightarg = interval,
-  function = pg_catalog.timetz_mi_interval
+  function = pg_catalog.timestamptz_mi_interval
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = time without time zone,
-  rightarg = interval,
-  function = pg_catalog.time_mi_interval
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_mi
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4mi
+  leftarg = timestamp without time zone,
+  rightarg = interval,
+  function = pg_catalog.timestamp_mi_interval
 );
 
 -- subtract
 create operator pg_catalog.- (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_sub
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_mi
 );
 
 -- get json array element
@@ -18928,11 +18919,11 @@ create operator pg_catalog.-> (
   function = pg_catalog.jsonb_object_field
 );
 
--- get jsonb object field as text
+-- get json array element as text
 create operator pg_catalog.->> (
-  leftarg = jsonb,
-  rightarg = text,
-  function = pg_catalog.jsonb_object_field_text
+  leftarg = json,
+  rightarg = integer,
+  function = pg_catalog.json_array_element_text
 );
 
 -- get json object field as text
@@ -18942,18 +18933,18 @@ create operator pg_catalog.->> (
   function = pg_catalog.json_object_field_text
 );
 
--- get json array element as text
+-- get jsonb array element as text
 create operator pg_catalog.->> (
-  leftarg = json,
+  leftarg = jsonb,
   rightarg = integer,
-  function = pg_catalog.json_array_element_text
+  function = pg_catalog.jsonb_array_element_text
 );
 
--- get jsonb array element as text
+-- get jsonb object field as text
 create operator pg_catalog.->> (
   leftarg = jsonb,
-  rightarg = integer,
-  function = pg_catalog.jsonb_array_element_text
+  rightarg = text,
+  function = pg_catalog.jsonb_object_field_text
 );
 
 -- is adjacent to
@@ -18963,13 +18954,6 @@ create operator pg_catalog.-|- (
   function = pg_catalog.multirange_adjacent_multirange
 );
 
--- is adjacent to
-create operator pg_catalog.-|- (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_adjacent
-);
-
 -- is adjacent to
 create operator pg_catalog.-|- (
   leftarg = anymultirange,
@@ -18984,46 +18968,60 @@ create operator pg_catalog.-|- (
   function = pg_catalog.range_adjacent_multirange
 );
 
+-- is adjacent to
+create operator pg_catalog.-|- (
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_adjacent
+);
+
 -- divide
 create operator pg_catalog./ (
-  leftarg = money,
+  leftarg = bigint,
   rightarg = bigint,
-  function = pg_catalog.cash_div_int8
+  function = pg_catalog.int8div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = interval,
-  rightarg = double precision,
-  function = pg_catalog.interval_div
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = money,
-  rightarg = integer,
-  function = pg_catalog.cash_div_int4
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82div
 );
 
--- divide (rotate/scale path)
+-- divide box by point (scale)
 create operator pg_catalog./ (
-  leftarg = path,
+  leftarg = box,
   rightarg = point,
-  function = pg_catalog.path_div_pt
+  function = pg_catalog.box_div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82div
+  leftarg = circle,
+  rightarg = point,
+  function = pg_catalog.circle_div_pt
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = money,
-  rightarg = smallint,
-  function = pg_catalog.cash_div_int2
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8div
+);
+
+-- divide
+create operator pg_catalog./ (
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84div
 );
 
 -- divide
@@ -19033,95 +19031,102 @@ create operator pg_catalog./ (
   function = pg_catalog.int48div
 );
 
--- divide points (scale/rotate)
+-- divide
 create operator pg_catalog./ (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_div
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84div
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = circle,
-  rightarg = point,
-  function = pg_catalog.circle_div_pt
+  leftarg = interval,
+  rightarg = double precision,
+  function = pg_catalog.interval_div
 );
 
 -- divide
 create operator pg_catalog./ (
   leftarg = money,
-  rightarg = real,
-  function = pg_catalog.cash_div_flt4
+  rightarg = bigint,
+  function = pg_catalog.cash_div_int8
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_div
+  leftarg = money,
+  rightarg = double precision,
+  function = pg_catalog.cash_div_flt8
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = integer,
+  leftarg = money,
   rightarg = integer,
-  function = pg_catalog.int4div
+  function = pg_catalog.cash_div_int4
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24div
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_div_cash
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = double precision,
+  leftarg = money,
   rightarg = real,
-  function = pg_catalog.float84div
+  function = pg_catalog.cash_div_flt4
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48div
+  leftarg = money,
+  rightarg = smallint,
+  function = pg_catalog.cash_div_int2
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42div
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_div
 );
 
--- divide
+-- divide (rotate/scale path)
 create operator pg_catalog./ (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2div
+  leftarg = path,
+  rightarg = point,
+  function = pg_catalog.path_div_pt
+);
+
+-- divide points (scale/rotate)
+create operator pg_catalog./ (
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_div
 );
 
 -- divide
 create operator pg_catalog./ (
   leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4div
+  rightarg = double precision,
+  function = pg_catalog.float48div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8div
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4div
 );
 
 -- divide
@@ -19131,60 +19136,60 @@ create operator pg_catalog./ (
   function = pg_catalog.int28div
 );
 
--- divide box by point (scale)
+-- divide
 create operator pg_catalog./ (
-  leftarg = box,
-  rightarg = point,
-  function = pg_catalog.box_div
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24div
 );
 
 -- divide
 create operator pg_catalog./ (
-  leftarg = money,
-  rightarg = double precision,
-  function = pg_catalog.cash_div_flt8
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2div
 );
 
--- divide
-create operator pg_catalog./ (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_div_cash
+-- less than
+create operator pg_catalog.< (
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.charlt
 );
 
--- divide
-create operator pg_catalog./ (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8div
+-- less than
+create operator pg_catalog.< (
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.array_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_lt
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_lt
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = name,
-  rightarg = name,
-  function = pg_catalog.namelt
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbitlt
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8lt
 );
 
 -- less than
@@ -19196,58 +19201,65 @@ create operator pg_catalog.< (
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_lt
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = oid,
-  rightarg = oid,
-  function = pg_catalog.oidlt
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.bitlt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_lt
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbitlt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_lt
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.boollt
 );
 
--- less than
+-- less than by area
 create operator pg_catalog.< (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_lt
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = date,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.date_lt_timestamp
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.bytealt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = text,
-  rightarg = name,
-  function = pg_catalog.textltname
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpcharlt
+);
+
+-- less than by area
+create operator pg_catalog.< (
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.bytealt
+  leftarg = date,
+  rightarg = date,
+  function = pg_catalog.date_lt
 );
 
 -- less than
@@ -19259,142 +19271,156 @@ create operator pg_catalog.< (
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8lt
+  leftarg = date,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.date_lt_timestamp
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp without time zone,
-  rightarg = date,
-  function = pg_catalog.timestamp_lt_date
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.bitlt
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp with time zone,
-  rightarg = date,
-  function = pg_catalog.timestamptz_lt_date
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_lt_timestamptz
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8lt
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_n_lt
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.charlt
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_lt
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_lt
+);
+
+-- less than by length
+create operator pg_catalog.< (
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4lt
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_lt_timestamp
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.array_lt
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_lt
+  leftarg = name,
+  rightarg = name,
+  function = pg_catalog.namelt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_lt
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.namelttext
 );
 
--- less than by length
+-- less than
+create operator pg_catalog.< (
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_lt
+);
+
+-- less than
 create operator pg_catalog.< (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_lt
+  leftarg = oid,
+  rightarg = oid,
+  function = pg_catalog.oidlt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82lt
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectorlt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_lt
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_n_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpcharlt
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.namelttext
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_lt
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4lt
 );
 
 -- less than
@@ -19407,50 +19433,43 @@ create operator pg_catalog.< (
 -- less than
 create operator pg_catalog.< (
   leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2lt
+  rightarg = bigint,
+  function = pg_catalog.int28lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_lt
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24lt
 );
 
 -- less than
 create operator pg_catalog.< (
   leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28lt
+  rightarg = smallint,
+  function = pg_catalog.int2lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_lt
-);
-
--- less than by area
-create operator pg_catalog.< (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_lt
+  leftarg = text,
+  rightarg = name,
+  function = pg_catalog.textltname
 );
 
--- less than by area
+-- less than
 create operator pg_catalog.< (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_lt
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.text_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84lt
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tidlt
 );
 
 -- less than
@@ -19462,79 +19481,65 @@ create operator pg_catalog.< (
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.boollt
-);
-
--- less than
-create operator pg_catalog.< (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4lt
-);
-
--- less than
-create operator pg_catalog.< (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_lt
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_lt
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_lt_date
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48lt
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.text_lt
+  leftarg = timestamp with time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamptz_lt_timestamp
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = xid8,
-  rightarg = xid8,
-  function = pg_catalog.xid8lt
+  leftarg = timestamp without time zone,
+  rightarg = date,
+  function = pg_catalog.timestamp_lt_date
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tidlt
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_lt_timestamptz
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_lt
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42lt
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_lt
 );
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_lt
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_lt
 );
 
 -- less than
@@ -19546,37 +19551,37 @@ create operator pg_catalog.< (
 
 -- less than
 create operator pg_catalog.< (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectorlt
+  leftarg = xid8,
+  rightarg = xid8,
+  function = pg_catalog.xid8lt
 );
 
--- less than
-create operator pg_catalog.< (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24lt
+-- distance between
+create operator pg_catalog.<-> (
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_distance
 );
 
--- less than
-create operator pg_catalog.< (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48lt
+-- distance between
+create operator pg_catalog.<-> (
+  leftarg = box,
+  rightarg = lseg,
+  function = pg_catalog.dist_bs
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = point,
-  rightarg = lseg,
-  function = pg_catalog.dist_ps
+  leftarg = box,
+  rightarg = point,
+  function = pg_catalog.dist_bp
 );
 
--- phrase-concatenate
+-- distance between
 create operator pg_catalog.<-> (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_phrase
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_distance
 );
 
 -- distance between
@@ -19588,23 +19593,23 @@ create operator pg_catalog.<-> (
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = line,
-  rightarg = line,
-  function = pg_catalog.line_distance
+  leftarg = circle,
+  rightarg = polygon,
+  function = pg_catalog.dist_cpoly
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_distance
+  leftarg = line,
+  rightarg = line,
+  function = pg_catalog.line_distance
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = point,
-  rightarg = line,
-  function = pg_catalog.dist_pl
+  leftarg = line,
+  rightarg = lseg,
+  function = pg_catalog.dist_ls
 );
 
 -- distance between
@@ -19616,9 +19621,9 @@ create operator pg_catalog.<-> (
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_distance
+  leftarg = lseg,
+  rightarg = box,
+  function = pg_catalog.dist_sb
 );
 
 -- distance between
@@ -19630,37 +19635,23 @@ create operator pg_catalog.<-> (
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = point,
-  rightarg = circle,
-  function = pg_catalog.dist_pc
-);
-
--- distance between
-create operator pg_catalog.<-> (
-  leftarg = line,
+  leftarg = lseg,
   rightarg = lseg,
-  function = pg_catalog.dist_ls
-);
-
--- distance between
-create operator pg_catalog.<-> (
-  leftarg = circle,
-  rightarg = polygon,
-  function = pg_catalog.dist_cpoly
+  function = pg_catalog.lseg_distance
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_distance
+  leftarg = lseg,
+  rightarg = point,
+  function = pg_catalog.dist_sp
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = polygon,
-  rightarg = circle,
-  function = pg_catalog.dist_polyc
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_distance
 );
 
 -- distance between
@@ -19673,113 +19664,92 @@ create operator pg_catalog.<-> (
 -- distance between
 create operator pg_catalog.<-> (
   leftarg = point,
-  rightarg = path,
-  function = pg_catalog.dist_ppath
-);
-
--- distance between
-create operator pg_catalog.<-> (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_distance
-);
-
--- distance between
-create operator pg_catalog.<-> (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_distance
+  rightarg = box,
+  function = pg_catalog.dist_pb
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = box,
-  rightarg = lseg,
-  function = pg_catalog.dist_bs
+  leftarg = point,
+  rightarg = circle,
+  function = pg_catalog.dist_pc
 );
 
 -- distance between
 create operator pg_catalog.<-> (
   leftarg = point,
-  rightarg = polygon,
-  function = pg_catalog.dist_ppoly
+  rightarg = line,
+  function = pg_catalog.dist_pl
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = polygon,
-  rightarg = point,
-  function = pg_catalog.dist_polyp
+  leftarg = point,
+  rightarg = lseg,
+  function = pg_catalog.dist_ps
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = lseg,
-  rightarg = box,
-  function = pg_catalog.dist_sb
+  leftarg = point,
+  rightarg = path,
+  function = pg_catalog.dist_ppath
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = box,
+  leftarg = point,
   rightarg = point,
-  function = pg_catalog.dist_bp
+  function = pg_catalog.point_distance
 );
 
 -- distance between
 create operator pg_catalog.<-> (
   leftarg = point,
-  rightarg = box,
-  function = pg_catalog.dist_pb
+  rightarg = polygon,
+  function = pg_catalog.dist_ppoly
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = lseg,
-  rightarg = point,
-  function = pg_catalog.dist_sp
+  leftarg = polygon,
+  rightarg = circle,
+  function = pg_catalog.dist_polyc
 );
 
 -- distance between
 create operator pg_catalog.<-> (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_distance
-);
-
--- is left of
-create operator pg_catalog.<< (
-  leftarg = point,
+  leftarg = polygon,
   rightarg = point,
-  function = pg_catalog.point_left
+  function = pg_catalog.dist_polyp
 );
 
--- is left of
-create operator pg_catalog.<< (
+-- distance between
+create operator pg_catalog.<-> (
   leftarg = polygon,
   rightarg = polygon,
-  function = pg_catalog.poly_left
+  function = pg_catalog.poly_distance
 );
 
--- is left of
-create operator pg_catalog.<< (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_left
+-- phrase-concatenate
+create operator pg_catalog.<-> (
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_phrase
 );
 
--- is subnet
+-- is left of
 create operator pg_catalog.<< (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_sub
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_before_multirange
 );
 
--- bitwise shift left
+-- is left of
 create operator pg_catalog.<< (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4shl
+  leftarg = anymultirange,
+  rightarg = anyrange,
+  function = pg_catalog.multirange_before_range
 );
 
 -- is left of
@@ -19789,6 +19759,13 @@ create operator pg_catalog.<< (
   function = pg_catalog.range_before_multirange
 );
 
+-- is left of
+create operator pg_catalog.<< (
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_before
+);
+
 -- bitwise shift left
 create operator pg_catalog.<< (
   leftarg = bigint,
@@ -19812,30 +19789,44 @@ create operator pg_catalog.<< (
 
 -- is left of
 create operator pg_catalog.<< (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_before
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_left
+);
+
+-- is subnet
+create operator pg_catalog.<< (
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_sub
 );
 
 -- bitwise shift left
 create operator pg_catalog.<< (
-  leftarg = smallint,
+  leftarg = integer,
   rightarg = integer,
-  function = pg_catalog.int2shl
+  function = pg_catalog.int4shl
 );
 
 -- is left of
 create operator pg_catalog.<< (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_before_multirange
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_left
 );
 
 -- is left of
 create operator pg_catalog.<< (
-  leftarg = anymultirange,
-  rightarg = anyrange,
-  function = pg_catalog.multirange_before_range
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_left
+);
+
+-- bitwise shift left
+create operator pg_catalog.<< (
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int2shl
 );
 
 -- is subnet or equal
@@ -19861,184 +19852,184 @@ create operator pg_catalog.<<| (
 
 -- is below
 create operator pg_catalog.<<| (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_below
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_below
 );
 
 -- is below
 create operator pg_catalog.<<| (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_below
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_below
 );
 
--- less than or equal by area
+-- less than or equal
 create operator pg_catalog.<= (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_le
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.charle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_le
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.array_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_le
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82le
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28le
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.boolle
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_le
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = xid8,
-  rightarg = xid8,
-  function = pg_catalog.xid8le
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48le
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.bitle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = name,
-  rightarg = name,
-  function = pg_catalog.namele
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbitle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84le
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.boolle
 );
 
--- less than or equal
+-- less than or equal by area
 create operator pg_catalog.<= (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_le
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = oid,
-  rightarg = oid,
-  function = pg_catalog.oidle
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.byteale
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8le
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpcharle
 );
 
--- less than or equal
+-- less than or equal by area
 create operator pg_catalog.<= (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_n_le
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.charle
+  leftarg = date,
+  rightarg = date,
+  function = pg_catalog.date_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_le
+  leftarg = date,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.date_le_timestamptz
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpcharle
+  leftarg = date,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.date_le_timestamp
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = record,
-  rightarg = record,
-  function = pg_catalog.record_le
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_le
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_le
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_le
 );
 
--- less than or equal by area
+-- less than or equal
 create operator pg_catalog.<= (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_le
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_le
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_le
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42le
 );
 
 -- less than or equal
@@ -20050,401 +20041,401 @@ create operator pg_catalog.<= (
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_le
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_le
 );
 
--- less than or equal
+-- less than or equal by length
 create operator pg_catalog.<= (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84le
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_le
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48le
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_le
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tidle
+  leftarg = name,
+  rightarg = name,
+  function = pg_catalog.namele
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = text,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.text_le
+  function = pg_catalog.nameletext
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = time with time zone,
-  rightarg = time with time zone,
-  function = pg_catalog.timetz_le
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_le
+  leftarg = oid,
+  rightarg = oid,
+  function = pg_catalog.oidle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8le
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectorle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectorle
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_n_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = uuid,
-  rightarg = uuid,
-  function = pg_catalog.uuid_le
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
   leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4le
+  rightarg = double precision,
+  function = pg_catalog.float48le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2le
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4le
+  leftarg = record,
+  rightarg = record,
+  function = pg_catalog.record_le
 );
 
--- less than or equal by length
+-- less than or equal
 create operator pg_catalog.<= (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_le
+  leftarg = smallint,
+  rightarg = bigint,
+  function = pg_catalog.int28le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_le_timestamp
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_le_timestamptz
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = timestamp with time zone,
-  rightarg = date,
-  function = pg_catalog.timestamptz_le_date
+  leftarg = text,
+  rightarg = name,
+  function = pg_catalog.textlename
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.array_le
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.text_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = timestamp without time zone,
-  rightarg = date,
-  function = pg_catalog.timestamp_le_date
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tidle
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.bitle
+  leftarg = time with time zone,
+  rightarg = time with time zone,
+  function = pg_catalog.timetz_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = date,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.date_le_timestamptz
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = text,
-  rightarg = name,
-  function = pg_catalog.textlename
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_le_date
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_le
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = date,
+  leftarg = timestamp with time zone,
   rightarg = timestamp without time zone,
-  function = pg_catalog.date_le_timestamp
+  function = pg_catalog.timestamptz_le_timestamp
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
   leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_le
+  rightarg = date,
+  function = pg_catalog.timestamp_le_date
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbitle
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_le_timestamptz
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.nameletext
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.byteale
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_le
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24le
+  leftarg = uuid,
+  rightarg = uuid,
+  function = pg_catalog.uuid_le
 );
 
 -- less than or equal
 create operator pg_catalog.<= (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42le
-);
-
--- not equal
-create operator pg_catalog.<> (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4ne
+  leftarg = xid8,
+  rightarg = xid8,
+  function = pg_catalog.xid8le
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_ne
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.charne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_ne
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.array_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.array_ne
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.namenetext
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48ne
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.textne
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = xid,
+  leftarg = bigint,
   rightarg = integer,
-  function = pg_catalog.xidneqint4
+  function = pg_catalog.int84ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tidne
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectorne
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.bitne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = time with time zone,
-  rightarg = time with time zone,
-  function = pg_catalog.timetz_ne
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbitne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84ne
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.boolne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42ne
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.byteane
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_ne
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpcharne
 );
 
--- not equal
+-- not equal by area
 create operator pg_catalog.<> (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_ne
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4ne
+  leftarg = date,
+  rightarg = date,
+  function = pg_catalog.date_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_ne
+  leftarg = date,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.date_ne_timestamptz
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_ne
+  leftarg = date,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.date_ne_timestamp
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_ne
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
   leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8ne
+  rightarg = real,
+  function = pg_catalog.float84ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84ne
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = uuid,
-  rightarg = uuid,
-  function = pg_catalog.uuid_ne
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbitne
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
   leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48ne
+  rightarg = smallint,
+  function = pg_catalog.int42ne
+);
+
+-- not equal
+create operator pg_catalog.<> (
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_ne
 );
 
 -- not equal
@@ -20456,121 +20447,121 @@ create operator pg_catalog.<> (
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_ne
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2ne
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_ne
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_ne
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_ne
 );
 
--- not equal by area
+-- not equal
 create operator pg_catalog.<> (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_ne
+  leftarg = name,
+  rightarg = name,
+  function = pg_catalog.namene
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_ne
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.namenetext
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = record,
-  rightarg = record,
-  function = pg_catalog.record_ne
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_ne
+  leftarg = oid,
+  rightarg = oid,
+  function = pg_catalog.oidne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpcharne
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectorne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_ne
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.boolne
+  leftarg = point,
+  rightarg = point,
+  function = pg_catalog.point_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_ne
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_ne_timestamp
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_ne
+  leftarg = record,
+  rightarg = record,
+  function = pg_catalog.record_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = point,
-  rightarg = point,
-  function = pg_catalog.point_ne
+  leftarg = smallint,
+  rightarg = bigint,
+  function = pg_catalog.int28ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_ne_timestamptz
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_ne
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2ne
 );
 
 -- not equal
@@ -20582,51 +20573,51 @@ create operator pg_catalog.<> (
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.byteane
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.textne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.charne
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tidne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = timestamp with time zone,
-  rightarg = date,
-  function = pg_catalog.timestamptz_ne_date
+  leftarg = time with time zone,
+  rightarg = time with time zone,
+  function = pg_catalog.timetz_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28ne
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8ne
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_ne_date
 );
 
 -- not equal
-create operator pg_catalog.<> (
-  leftarg = name,
-  rightarg = name,
-  function = pg_catalog.namene
+create operator pg_catalog.<> (
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.bitne
+  leftarg = timestamp with time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamptz_ne_timestamp
 );
 
 -- not equal
@@ -20638,51 +20629,51 @@ create operator pg_catalog.<> (
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82ne
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_ne_timestamptz
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_ne
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = date,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.date_ne_timestamptz
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24ne
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = xid,
-  rightarg = xid,
-  function = pg_catalog.xidneq
+  leftarg = uuid,
+  rightarg = uuid,
+  function = pg_catalog.uuid_ne
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = date,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.date_ne_timestamp
+  leftarg = xid,
+  rightarg = integer,
+  function = pg_catalog.xidneqint4
 );
 
 -- not equal
 create operator pg_catalog.<> (
-  leftarg = oid,
-  rightarg = oid,
-  function = pg_catalog.oidne
+  leftarg = xid,
+  rightarg = xid,
+  function = pg_catalog.xidneq
 );
 
 -- not equal
@@ -20692,144 +20683,151 @@ create operator pg_catalog.<> (
   function = pg_catalog.xid8ne
 );
 
--- point within closed path, or point on open path
+-- is contained by
 create operator pg_catalog.<@ (
-  leftarg = point,
-  rightarg = path,
-  function = pg_catalog.on_ppath
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.arraycontained
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = point,
-  rightarg = polygon,
-  function = pg_catalog.pt_contained_poly
+  leftarg = anyelement,
+  rightarg = anymultirange,
+  function = pg_catalog.elem_contained_by_multirange
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_contained
+  leftarg = anyelement,
+  rightarg = anyrange,
+  function = pg_catalog.elem_contained_by_range
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = lseg,
-  rightarg = box,
-  function = pg_catalog.on_sb
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_contained_by_multirange
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = anyrange,
+  leftarg = anymultirange,
   rightarg = anyrange,
-  function = pg_catalog.range_contained_by
+  function = pg_catalog.multirange_contained_by_range
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = point,
-  rightarg = lseg,
-  function = pg_catalog.on_ps
+  leftarg = anyrange,
+  rightarg = anymultirange,
+  function = pg_catalog.range_contained_by_multirange
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = anymultirange,
+  leftarg = anyrange,
   rightarg = anyrange,
-  function = pg_catalog.multirange_contained_by_range
+  function = pg_catalog.range_contained_by
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_contained
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_contained
 );
 
--- lseg on line
+-- is contained by
 create operator pg_catalog.<@ (
-  leftarg = lseg,
-  rightarg = line,
-  function = pg_catalog.on_sl
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_contained
 );
 
--- point on line
+-- is contained by
 create operator pg_catalog.<@ (
-  leftarg = point,
-  rightarg = line,
-  function = pg_catalog.on_pl
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_contained
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.arraycontained
+  leftarg = lseg,
+  rightarg = box,
+  function = pg_catalog.on_sb
 );
 
--- is contained by
+-- lseg on line
 create operator pg_catalog.<@ (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_contained_by_multirange
+  leftarg = lseg,
+  rightarg = line,
+  function = pg_catalog.on_sl
 );
 
--- is contained by
+-- point inside box
 create operator pg_catalog.<@ (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsq_mcontained
+  leftarg = point,
+  rightarg = box,
+  function = pg_catalog.on_pb
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_contained
+  leftarg = point,
+  rightarg = circle,
+  function = pg_catalog.pt_contained_circle
 );
 
--- is contained by
+-- point on line
 create operator pg_catalog.<@ (
-  leftarg = anyelement,
-  rightarg = anymultirange,
-  function = pg_catalog.elem_contained_by_multirange
+  leftarg = point,
+  rightarg = line,
+  function = pg_catalog.on_pl
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = anyrange,
-  rightarg = anymultirange,
-  function = pg_catalog.range_contained_by_multirange
+  leftarg = point,
+  rightarg = lseg,
+  function = pg_catalog.on_ps
 );
 
--- is contained by
+-- point within closed path, or point on open path
 create operator pg_catalog.<@ (
   leftarg = point,
-  rightarg = circle,
-  function = pg_catalog.pt_contained_circle
+  rightarg = path,
+  function = pg_catalog.on_ppath
 );
 
--- point inside box
+-- is contained by
 create operator pg_catalog.<@ (
   leftarg = point,
-  rightarg = box,
-  function = pg_catalog.on_pb
+  rightarg = polygon,
+  function = pg_catalog.pt_contained_poly
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
-  leftarg = anyelement,
-  rightarg = anyrange,
-  function = pg_catalog.elem_contained_by_range
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_contained
 );
 
 -- is contained by
 create operator pg_catalog.<@ (
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsq_mcontained
+);
+
+-- is below (allows touching)
+create operator pg_catalog.<^ (
   leftarg = box,
   rightarg = box,
-  function = pg_catalog.box_contained
+  function = pg_catalog.box_below_eq
 );
 
 -- deprecated, use <<| instead
@@ -20839,18 +20837,18 @@ create operator pg_catalog.<^ (
   function = pg_catalog.point_below
 );
 
--- is below (allows touching)
-create operator pg_catalog.<^ (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_below_eq
+-- equal
+create operator pg_catalog.= (
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.chareq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24eq
+  leftarg = aclitem,
+  rightarg = aclitem,
+  function = pg_catalog.aclitemeq
 );
 
 -- equal
@@ -20862,16 +20860,30 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48eq
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_eq
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_eq
+);
+
+-- equal
+create operator pg_catalog.= (
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_eq
+);
+
+-- equal
+create operator pg_catalog.= (
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8eq
 );
 
 -- equal
@@ -20884,36 +20896,64 @@ create operator pg_catalog.= (
 -- equal
 create operator pg_catalog.= (
   leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8eq
+  rightarg = smallint,
+  function = pg_catalog.int82eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_n_eq
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.biteq
+);
+
+-- equal
+create operator pg_catalog.= (
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbiteq
+);
+
+-- equal
+create operator pg_catalog.= (
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.booleq
+);
+
+-- equal by area
+create operator pg_catalog.= (
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_eq
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.byteaeq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = aclitem,
-  rightarg = aclitem,
-  function = pg_catalog.aclitemeq
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpchareq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpchareq
+  leftarg = cid,
+  rightarg = cid,
+  function = pg_catalog.cideq
+);
+
+-- equal by area
+create operator pg_catalog.= (
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_eq
 );
 
 -- equal
@@ -20925,23 +20965,23 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_eq
+  leftarg = date,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.date_eq_timestamptz
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_eq
+  leftarg = date,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.date_eq_timestamp
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_eq
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8eq
 );
 
 -- equal
@@ -20953,51 +20993,44 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tideq
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = xid,
-  rightarg = integer,
-  function = pg_catalog.xideqint4
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = time with time zone,
-  rightarg = time with time zone,
-  function = pg_catalog.timetz_eq
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48eq
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8eq
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4eq
-);
-
--- equal by area
-create operator pg_catalog.= (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_eq
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_eq
 );
 
 -- equal
@@ -21009,23 +21042,9 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.biteq
-);
-
--- equal
-create operator pg_catalog.= (
-  leftarg = text,
-  rightarg = name,
-  function = pg_catalog.texteqname
-);
-
--- equal
-create operator pg_catalog.= (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbiteq
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_eq
 );
 
 -- equal
@@ -21035,13 +21054,6 @@ create operator pg_catalog.= (
   function = pg_catalog.macaddr_eq
 );
 
--- equal
-create operator pg_catalog.= (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.nameeqtext
-);
-
 -- equal
 create operator pg_catalog.= (
   leftarg = macaddr8,
@@ -21051,30 +21063,30 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_eq
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_eq
+  leftarg = name,
+  rightarg = name,
+  function = pg_catalog.nameeq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28eq
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.nameeqtext
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82eq
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_eq
 );
 
 -- equal
@@ -21086,170 +21098,170 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.byteaeq
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectoreq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42eq
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_n_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectoreq
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_eq
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = date,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.date_eq_timestamp
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = date,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.date_eq_timestamptz
+  leftarg = record,
+  rightarg = record,
+  function = pg_catalog.record_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp without time zone,
-  rightarg = date,
-  function = pg_catalog.timestamp_eq_date
+  leftarg = smallint,
+  rightarg = bigint,
+  function = pg_catalog.int28eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp with time zone,
-  rightarg = date,
-  function = pg_catalog.timestamptz_eq_date
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_eq_timestamptz
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_eq_timestamp
+  leftarg = text,
+  rightarg = name,
+  function = pg_catalog.texteqname
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.chareq
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.texteq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.booleq
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tideq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = uuid,
-  rightarg = uuid,
-  function = pg_catalog.uuid_eq
+  leftarg = time with time zone,
+  rightarg = time with time zone,
+  function = pg_catalog.timetz_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_eq
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_eq
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_eq_date
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_eq
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_eq
+  leftarg = timestamp with time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamptz_eq_timestamp
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_eq
+  leftarg = timestamp without time zone,
+  rightarg = date,
+  function = pg_catalog.timestamp_eq_date
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = record,
-  rightarg = record,
-  function = pg_catalog.record_eq
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_eq_timestamptz
 );
 
--- equal by area
-create operator pg_catalog.= (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_eq
+-- equal
+create operator pg_catalog.= (
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_eq
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_eq
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = cid,
-  rightarg = cid,
-  function = pg_catalog.cideq
+  leftarg = uuid,
+  rightarg = uuid,
+  function = pg_catalog.uuid_eq
 );
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = xid8,
-  rightarg = xid8,
-  function = pg_catalog.xid8eq
+  leftarg = xid,
+  rightarg = integer,
+  function = pg_catalog.xideqint4
 );
 
 -- equal
@@ -21261,37 +21273,44 @@ create operator pg_catalog.= (
 
 -- equal
 create operator pg_catalog.= (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.texteq
+  leftarg = xid8,
+  rightarg = xid8,
+  function = pg_catalog.xid8eq
 );
 
--- equal
-create operator pg_catalog.= (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4eq
+-- greater than
+create operator pg_catalog.> (
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.chargt
 );
 
--- equal
-create operator pg_catalog.= (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2eq
+-- greater than
+create operator pg_catalog.> (
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.array_gt
 );
 
--- equal
-create operator pg_catalog.= (
-  leftarg = name,
-  rightarg = name,
-  function = pg_catalog.nameeq
+-- greater than
+create operator pg_catalog.> (
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = date,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.date_gt_timestamptz
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_gt
+);
+
+-- greater than
+create operator pg_catalog.> (
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_gt
 );
 
 -- greater than
@@ -21303,16 +21322,16 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_n_gt
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = text,
-  rightarg = name,
-  function = pg_catalog.textgtname
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82gt
 );
 
 -- greater than
@@ -21324,37 +21343,37 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.array_gt
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbitgt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = timestamp without time zone,
-  rightarg = date,
-  function = pg_catalog.timestamp_gt_date
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.boolgt
 );
 
--- greater than
+-- greater than by area
 create operator pg_catalog.> (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28gt
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_gt
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.byteagt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4gt
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpchargt
 );
 
 -- greater than by area
@@ -21364,60 +21383,46 @@ create operator pg_catalog.> (
   function = pg_catalog.circle_gt
 );
 
--- greater than by length
-create operator pg_catalog.> (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_gt
-);
-
 -- greater than
 create operator pg_catalog.> (
-  leftarg = timestamp with time zone,
+  leftarg = date,
   rightarg = date,
-  function = pg_catalog.timestamptz_gt_date
+  function = pg_catalog.date_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_gt
+  leftarg = date,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.date_gt_timestamptz
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = timestamp with time zone,
+  leftarg = date,
   rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_gt_timestamp
-);
-
--- greater than
-create operator pg_catalog.> (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_gt_timestamptz
+  function = pg_catalog.date_gt_timestamp
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = xid8,
-  rightarg = xid8,
-  function = pg_catalog.xid8gt
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42gt
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24gt
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_gt
 );
 
 -- greater than
@@ -21429,79 +21434,58 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.chargt
-);
-
--- greater than by area
-create operator pg_catalog.> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_gt
-);
-
--- greater than
-create operator pg_catalog.> (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.byteagt
-);
-
--- greater than
-create operator pg_catalog.> (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_gt
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpchargt
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = record,
-  rightarg = record,
-  function = pg_catalog.record_gt
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_gt
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_gt
 );
 
--- greater than
+-- greater than by length
 create operator pg_catalog.> (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_gt
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbitgt
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_gt
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_gt
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_gt
 );
 
 -- greater than
@@ -21513,23 +21497,16 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_gt
-);
-
--- greater than
-create operator pg_catalog.> (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_gt
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.namegttext
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82gt
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_gt
 );
 
 -- greater than
@@ -21541,86 +21518,86 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84gt
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectorgt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_gt
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_n_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_gt
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_gt
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.namegttext
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.boolgt
+  leftarg = record,
+  rightarg = record,
+  function = pg_catalog.record_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_gt
+  leftarg = smallint,
+  rightarg = bigint,
+  function = pg_catalog.int28gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_gt
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84gt
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48gt
+  leftarg = text,
+  rightarg = name,
+  function = pg_catalog.textgtname
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tidgt
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.text_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_gt
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tidgt
 );
 
 -- greater than
@@ -21632,219 +21609,233 @@ create operator pg_catalog.> (
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_gt
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectorgt
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_gt_date
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8gt
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = date,
+  leftarg = timestamp with time zone,
   rightarg = timestamp without time zone,
-  function = pg_catalog.date_gt_timestamp
+  function = pg_catalog.timestamptz_gt_timestamp
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_gt
+  leftarg = timestamp without time zone,
+  rightarg = date,
+  function = pg_catalog.timestamp_gt_date
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = uuid,
-  rightarg = uuid,
-  function = pg_catalog.uuid_gt
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_gt_timestamptz
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4gt
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2gt
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_gt
 );
 
 -- greater than
 create operator pg_catalog.> (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.text_gt
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_gt
 );
 
--- greater than or equal
-create operator pg_catalog.>= (
-  leftarg = interval,
-  rightarg = interval,
-  function = pg_catalog.interval_ge
+-- greater than
+create operator pg_catalog.> (
+  leftarg = uuid,
+  rightarg = uuid,
+  function = pg_catalog.uuid_gt
+);
+
+-- greater than
+create operator pg_catalog.> (
+  leftarg = xid8,
+  rightarg = xid8,
+  function = pg_catalog.xid8gt
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = macaddr8,
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_ge
+  leftarg = "char",
+  rightarg = "char",
+  function = pg_catalog.charge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = integer,
-  rightarg = smallint,
-  function = pg_catalog.int42ge
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.array_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int24ge
+  leftarg = anyenum,
+  rightarg = anyenum,
+  function = pg_catalog.enum_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_ge
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.byteage
+  leftarg = anyrange,
+  rightarg = anyrange,
+  function = pg_catalog.range_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.varbitge
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = oid,
-  rightarg = oid,
-  function = pg_catalog.oidge
+  leftarg = bigint,
+  rightarg = integer,
+  function = pg_catalog.int84ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.namegetext
+  leftarg = bigint,
+  rightarg = smallint,
+  function = pg_catalog.int82ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp without time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamp_ge
+  leftarg = bit,
+  rightarg = bit,
+  function = pg_catalog.bitge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = date,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.date_ge_timestamp
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.varbitge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = date,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.date_ge_timestamptz
+  leftarg = boolean,
+  rightarg = boolean,
+  function = pg_catalog.boolge
 );
 
--- greater than or equal
+-- greater than or equal by area
 create operator pg_catalog.>= (
-  leftarg = text,
-  rightarg = name,
-  function = pg_catalog.textgename
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = xid8,
-  rightarg = xid8,
-  function = pg_catalog.xid8ge
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.byteage
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp without time zone,
-  rightarg = date,
-  function = pg_catalog.timestamp_ge_date
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpcharge
 );
 
--- greater than or equal
+-- greater than or equal by area
 create operator pg_catalog.>= (
-  leftarg = bit,
-  rightarg = bit,
-  function = pg_catalog.bitge
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp with time zone,
+  leftarg = date,
   rightarg = date,
-  function = pg_catalog.timestamptz_ge_date
+  function = pg_catalog.date_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp without time zone,
+  leftarg = date,
   rightarg = timestamp with time zone,
-  function = pg_catalog.timestamp_ge_timestamptz
+  function = pg_catalog.date_ge_timestamptz
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = name,
-  rightarg = name,
-  function = pg_catalog.namege
+  leftarg = date,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.date_ge_timestamp
+);
+
+-- greater than or equal
+create operator pg_catalog.>= (
+  leftarg = double precision,
+  rightarg = double precision,
+  function = pg_catalog.float8ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp without time zone,
-  function = pg_catalog.timestamptz_ge_timestamp
+  leftarg = double precision,
+  rightarg = real,
+  function = pg_catalog.float84ge
 );
 
--- greater than or equal by length
+-- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_ge
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.network_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2ge
+  leftarg = integer,
+  rightarg = bigint,
+  function = pg_catalog.int48ge
 );
 
 -- greater than or equal
@@ -21854,270 +21845,270 @@ create operator pg_catalog.>= (
   function = pg_catalog.int4ge
 );
 
--- greater than or equal by area
+-- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_ge
+  leftarg = integer,
+  rightarg = smallint,
+  function = pg_catalog.int42ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.text_ge
+  leftarg = interval,
+  rightarg = interval,
+  function = pg_catalog.interval_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = uuid,
-  rightarg = uuid,
-  function = pg_catalog.uuid_ge
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_ge
 );
 
--- greater than or equal
+-- greater than or equal by length
 create operator pg_catalog.>= (
-  leftarg = real,
-  rightarg = real,
-  function = pg_catalog.float4ge
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = pg_lsn,
-  rightarg = pg_lsn,
-  function = pg_catalog.pg_lsn_ge
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = double precision,
-  rightarg = double precision,
-  function = pg_catalog.float8ge
+  leftarg = macaddr8,
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = time with time zone,
-  rightarg = time with time zone,
-  function = pg_catalog.timetz_ge
+  leftarg = money,
+  rightarg = money,
+  function = pg_catalog.cash_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = tid,
-  rightarg = tid,
-  function = pg_catalog.tidge
+  leftarg = name,
+  rightarg = name,
+  function = pg_catalog.namege
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = anyenum,
-  rightarg = anyenum,
-  function = pg_catalog.enum_ge
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.namegetext
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = real,
-  rightarg = double precision,
-  function = pg_catalog.float48ge
+  leftarg = numeric,
+  rightarg = numeric,
+  function = pg_catalog.numeric_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.array_ge
+  leftarg = oid,
+  rightarg = oid,
+  function = pg_catalog.oidge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_ge
+  leftarg = oidvector,
+  rightarg = oidvector,
+  function = pg_catalog.oidvectorge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = double precision,
-  rightarg = real,
-  function = pg_catalog.float84ge
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_n_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_ge
+  leftarg = pg_lsn,
+  rightarg = pg_lsn,
+  function = pg_catalog.pg_lsn_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_ge
+  leftarg = real,
+  rightarg = double precision,
+  function = pg_catalog.float48ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = timestamp with time zone,
-  rightarg = timestamp with time zone,
-  function = pg_catalog.timestamptz_ge
+  leftarg = real,
+  rightarg = real,
+  function = pg_catalog.float4ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_ge
+  leftarg = record,
+  rightarg = record,
+  function = pg_catalog.record_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = time without time zone,
-  rightarg = time without time zone,
-  function = pg_catalog.time_ge
+  leftarg = smallint,
+  rightarg = bigint,
+  function = pg_catalog.int28ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = date,
-  rightarg = date,
-  function = pg_catalog.date_ge
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int24ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpcharge
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = record,
-  rightarg = record,
-  function = pg_catalog.record_ge
+  leftarg = text,
+  rightarg = name,
+  function = pg_catalog.textgename
 );
 
--- greater than or equal by area
+-- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_ge
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.text_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = oidvector,
-  rightarg = oidvector,
-  function = pg_catalog.oidvectorge
+  leftarg = tid,
+  rightarg = tid,
+  function = pg_catalog.tidge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = "char",
-  rightarg = "char",
-  function = pg_catalog.charge
+  leftarg = time with time zone,
+  rightarg = time with time zone,
+  function = pg_catalog.timetz_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_ge
+  leftarg = time without time zone,
+  rightarg = time without time zone,
+  function = pg_catalog.time_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_n_ge
+  leftarg = timestamp with time zone,
+  rightarg = date,
+  function = pg_catalog.timestamptz_ge_date
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8ge
+  leftarg = timestamp with time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamptz_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = money,
-  rightarg = money,
-  function = pg_catalog.cash_ge
+  leftarg = timestamp with time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamptz_ge_timestamp
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = numeric,
-  rightarg = numeric,
-  function = pg_catalog.numeric_ge
+  leftarg = timestamp without time zone,
+  rightarg = date,
+  function = pg_catalog.timestamp_ge_date
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = boolean,
-  rightarg = boolean,
-  function = pg_catalog.boolge
+  leftarg = timestamp without time zone,
+  rightarg = timestamp with time zone,
+  function = pg_catalog.timestamp_ge_timestamptz
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = bigint,
-  rightarg = integer,
-  function = pg_catalog.int84ge
+  leftarg = timestamp without time zone,
+  rightarg = timestamp without time zone,
+  function = pg_catalog.timestamp_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = smallint,
-  rightarg = bigint,
-  function = pg_catalog.int28ge
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.network_ge
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = bigint,
-  rightarg = smallint,
-  function = pg_catalog.int82ge
+  leftarg = uuid,
+  rightarg = uuid,
+  function = pg_catalog.uuid_ge
 );
 
 -- greater than or equal
 create operator pg_catalog.>= (
-  leftarg = integer,
-  rightarg = bigint,
-  function = pg_catalog.int48ge
+  leftarg = xid8,
+  rightarg = xid8,
+  function = pg_catalog.xid8ge
 );
 
 -- is right of
 create operator pg_catalog.>> (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_right
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_after_multirange
 );
 
--- bitwise shift right
+-- is right of
 create operator pg_catalog.>> (
-  leftarg = integer,
-  rightarg = integer,
-  function = pg_catalog.int4shr
+  leftarg = anymultirange,
+  rightarg = anyrange,
+  function = pg_catalog.multirange_after_range
 );
 
 -- is right of
 create operator pg_catalog.>> (
-  leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_right
+  leftarg = anyrange,
+  rightarg = anymultirange,
+  function = pg_catalog.range_after_multirange
 );
 
 -- is right of
@@ -22129,44 +22120,30 @@ create operator pg_catalog.>> (
 
 -- bitwise shift right
 create operator pg_catalog.>> (
-  leftarg = bit,
+  leftarg = bigint,
   rightarg = integer,
-  function = pg_catalog.bitshiftright
-);
-
--- is right of
-create operator pg_catalog.>> (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_after_multirange
+  function = pg_catalog.int8shr
 );
 
 -- bitwise shift right
 create operator pg_catalog.>> (
-  leftarg = bigint,
+  leftarg = bit,
   rightarg = integer,
-  function = pg_catalog.int8shr
+  function = pg_catalog.bitshiftright
 );
 
 -- is right of
 create operator pg_catalog.>> (
-  leftarg = anyrange,
-  rightarg = anymultirange,
-  function = pg_catalog.range_after_multirange
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_right
 );
 
 -- is right of
 create operator pg_catalog.>> (
-  leftarg = anymultirange,
-  rightarg = anyrange,
-  function = pg_catalog.multirange_after_range
-);
-
--- bitwise shift right
-create operator pg_catalog.>> (
-  leftarg = smallint,
-  rightarg = integer,
-  function = pg_catalog.int2shr
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_right
 );
 
 -- is supernet
@@ -22176,6 +22153,13 @@ create operator pg_catalog.>> (
   function = pg_catalog.network_sup
 );
 
+-- bitwise shift right
+create operator pg_catalog.>> (
+  leftarg = integer,
+  rightarg = integer,
+  function = pg_catalog.int4shr
+);
+
 -- is right of
 create operator pg_catalog.>> (
   leftarg = point,
@@ -22185,9 +22169,16 @@ create operator pg_catalog.>> (
 
 -- is right of
 create operator pg_catalog.>> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_right
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_right
+);
+
+-- bitwise shift right
+create operator pg_catalog.>> (
+  leftarg = smallint,
+  rightarg = integer,
+  function = pg_catalog.int2shr
 );
 
 -- is supernet or equal
@@ -22218,53 +22209,53 @@ create operator pg_catalog.? (
   function = pg_catalog.jsonb_exists
 );
 
--- intersect
+-- deprecated, use && instead
 create operator pg_catalog.?# (
-  leftarg = lseg,
-  rightarg = lseg,
-  function = pg_catalog.lseg_intersect
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_overlap
 );
 
 -- intersect
 create operator pg_catalog.?# (
-  leftarg = lseg,
+  leftarg = line,
   rightarg = box,
-  function = pg_catalog.inter_sb
+  function = pg_catalog.inter_lb
 );
 
 -- intersect
 create operator pg_catalog.?# (
   leftarg = line,
-  rightarg = box,
-  function = pg_catalog.inter_lb
+  rightarg = line,
+  function = pg_catalog.line_intersect
 );
 
--- deprecated, use && instead
+-- intersect
 create operator pg_catalog.?# (
-  leftarg = box,
+  leftarg = lseg,
   rightarg = box,
-  function = pg_catalog.box_overlap
+  function = pg_catalog.inter_sb
 );
 
 -- intersect
 create operator pg_catalog.?# (
-  leftarg = line,
+  leftarg = lseg,
   rightarg = line,
-  function = pg_catalog.line_intersect
+  function = pg_catalog.inter_sl
 );
 
 -- intersect
 create operator pg_catalog.?# (
-  leftarg = path,
-  rightarg = path,
-  function = pg_catalog.path_inter
+  leftarg = lseg,
+  rightarg = lseg,
+  function = pg_catalog.lseg_intersect
 );
 
 -- intersect
 create operator pg_catalog.?# (
-  leftarg = lseg,
-  rightarg = line,
-  function = pg_catalog.inter_sl
+  leftarg = path,
+  rightarg = path,
+  function = pg_catalog.path_inter
 );
 
 -- all keys exist
@@ -22280,6 +22271,12 @@ create operator pg_catalog.?- (
   function = pg_catalog.line_horizontal
 );
 
+-- horizontal
+create operator pg_catalog.?- (
+  rightarg = lseg,
+  function = pg_catalog.lseg_horizontal
+);
+
 -- horizontally aligned
 create operator pg_catalog.?- (
   leftarg = point,
@@ -22287,10 +22284,11 @@ create operator pg_catalog.?- (
   function = pg_catalog.point_horiz
 );
 
--- horizontal
-create operator pg_catalog.?- (
-  rightarg = lseg,
-  function = pg_catalog.lseg_horizontal
+-- perpendicular
+create operator pg_catalog.?-| (
+  leftarg = line,
+  rightarg = line,
+  function = pg_catalog.line_perp
 );
 
 -- perpendicular
@@ -22300,13 +22298,6 @@ create operator pg_catalog.?-| (
   function = pg_catalog.lseg_perp
 );
 
--- perpendicular
-create operator pg_catalog.?-| (
-  leftarg = line,
-  rightarg = line,
-  function = pg_catalog.line_perp
-);
-
 -- vertical
 create operator pg_catalog.?| (
   rightarg = line,
@@ -22349,32 +22340,26 @@ create operator pg_catalog.?|| (
 
 -- absolute value
 create operator pg_catalog.@ (
-  rightarg = double precision,
-  function = pg_catalog.float8abs
-);
-
--- absolute value
-create operator pg_catalog.@ (
-  rightarg = numeric,
-  function = pg_catalog.numeric_abs
+  rightarg = bigint,
+  function = pg_catalog.int8abs
 );
 
 -- absolute value
 create operator pg_catalog.@ (
-  rightarg = smallint,
-  function = pg_catalog.int2abs
+  rightarg = double precision,
+  function = pg_catalog.float8abs
 );
 
 -- absolute value
 create operator pg_catalog.@ (
-  rightarg = bigint,
-  function = pg_catalog.int8abs
+  rightarg = integer,
+  function = pg_catalog.int4abs
 );
 
 -- absolute value
 create operator pg_catalog.@ (
-  rightarg = integer,
-  function = pg_catalog.int4abs
+  rightarg = numeric,
+  function = pg_catalog.numeric_abs
 );
 
 -- absolute value
@@ -22383,10 +22368,10 @@ create operator pg_catalog.@ (
   function = pg_catalog.float4abs
 );
 
--- sum of path segment lengths
-create operator pg_catalog.@-@ (
-  rightarg = path,
-  function = pg_catalog.path_length
+-- absolute value
+create operator pg_catalog.@ (
+  rightarg = smallint,
+  function = pg_catalog.int2abs
 );
 
 -- distance between endpoints
@@ -22395,74 +22380,73 @@ create operator pg_catalog.@-@ (
   function = pg_catalog.lseg_length
 );
 
--- contains
-create operator pg_catalog.@> (
-  leftarg = anymultirange,
-  rightarg = anymultirange,
-  function = pg_catalog.multirange_contains_multirange
+-- sum of path segment lengths
+create operator pg_catalog.@-@ (
+  rightarg = path,
+  function = pg_catalog.path_length
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsq_mcontains
+  leftarg = aclitem[],
+  rightarg = aclitem,
+  function = pg_catalog.aclcontains
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = anymultirange,
-  rightarg = anyrange,
-  function = pg_catalog.multirange_contains_range
+  leftarg = anyarray,
+  rightarg = anyarray,
+  function = pg_catalog.arraycontains
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = circle,
-  rightarg = point,
-  function = pg_catalog.circle_contain_pt
+  leftarg = anymultirange,
+  rightarg = anyelement,
+  function = pg_catalog.multirange_contains_elem
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = polygon,
-  rightarg = polygon,
-  function = pg_catalog.poly_contain
+  leftarg = anymultirange,
+  rightarg = anymultirange,
+  function = pg_catalog.multirange_contains_multirange
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_contain
+  leftarg = anymultirange,
+  rightarg = anyrange,
+  function = pg_catalog.multirange_contains_range
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = anymultirange,
+  leftarg = anyrange,
   rightarg = anyelement,
-  function = pg_catalog.multirange_contains_elem
+  function = pg_catalog.range_contains_elem
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_contains
+  leftarg = anyrange,
+  rightarg = anymultirange,
+  function = pg_catalog.range_contains_multirange
 );
 
 -- contains
 create operator pg_catalog.@> (
   leftarg = anyrange,
-  rightarg = anymultirange,
-  function = pg_catalog.range_contains_multirange
+  rightarg = anyrange,
+  function = pg_catalog.range_contains
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = anyarray,
-  rightarg = anyarray,
-  function = pg_catalog.arraycontains
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_contain
 );
 
 -- contains
@@ -22474,23 +22458,30 @@ create operator pg_catalog.@> (
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = path,
-  rightarg = point,
-  function = pg_catalog.path_contain_pt
+  leftarg = circle,
+  rightarg = circle,
+  function = pg_catalog.circle_contain
 );
 
 -- contains
 create operator pg_catalog.@> (
   leftarg = circle,
-  rightarg = circle,
-  function = pg_catalog.circle_contain
+  rightarg = point,
+  function = pg_catalog.circle_contain_pt
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = aclitem[],
-  rightarg = aclitem,
-  function = pg_catalog.aclcontains
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_contains
+);
+
+-- contains
+create operator pg_catalog.@> (
+  leftarg = path,
+  rightarg = point,
+  function = pg_catalog.path_contain_pt
 );
 
 -- contains
@@ -22502,16 +22493,16 @@ create operator pg_catalog.@> (
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = anyrange,
-  rightarg = anyelement,
-  function = pg_catalog.range_contains_elem
+  leftarg = polygon,
+  rightarg = polygon,
+  function = pg_catalog.poly_contain
 );
 
 -- contains
 create operator pg_catalog.@> (
-  leftarg = anyrange,
-  rightarg = anyrange,
-  function = pg_catalog.range_contains
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsq_mcontains
 );
 
 -- jsonpath exists
@@ -22523,8 +22514,14 @@ create operator pg_catalog.@? (
 
 -- center of
 create operator pg_catalog.@@ (
-  rightarg = polygon,
-  function = pg_catalog.poly_center
+  rightarg = box,
+  function = pg_catalog.box_center
+);
+
+-- center of
+create operator pg_catalog.@@ (
+  rightarg = circle,
+  function = pg_catalog.circle_center
 );
 
 -- center of
@@ -22533,10 +22530,17 @@ create operator pg_catalog.@@ (
   function = pg_catalog.lseg_center
 );
 
--- center of
+-- center of
+create operator pg_catalog.@@ (
+  rightarg = polygon,
+  function = pg_catalog.poly_center
+);
+
+-- jsonpath match
 create operator pg_catalog.@@ (
-  rightarg = box,
-  function = pg_catalog.box_center
+  leftarg = jsonb,
+  rightarg = jsonpath,
+  function = pg_catalog.jsonb_path_match_opr
 );
 
 -- text search match
@@ -22546,19 +22550,6 @@ create operator pg_catalog.@@ (
   function = pg_catalog.ts_match_tt
 );
 
--- text search match
-create operator pg_catalog.@@ (
-  leftarg = tsquery,
-  rightarg = tsvector,
-  function = pg_catalog.ts_match_qv
-);
-
--- center of
-create operator pg_catalog.@@ (
-  rightarg = circle,
-  function = pg_catalog.circle_center
-);
-
 -- text search match
 create operator pg_catalog.@@ (
   leftarg = text,
@@ -22566,11 +22557,11 @@ create operator pg_catalog.@@ (
   function = pg_catalog.ts_match_tq
 );
 
--- jsonpath match
+-- text search match
 create operator pg_catalog.@@ (
-  leftarg = jsonb,
-  rightarg = jsonpath,
-  function = pg_catalog.jsonb_path_match_opr
+  leftarg = tsquery,
+  rightarg = tsvector,
+  function = pg_catalog.ts_match_qv
 );
 
 -- text search match
@@ -22582,16 +22573,16 @@ create operator pg_catalog.@@ (
 
 -- deprecated, use @@ instead
 create operator pg_catalog.@@@ (
-  leftarg = tsvector,
-  rightarg = tsquery,
-  function = pg_catalog.ts_match_vq
+  leftarg = tsquery,
+  rightarg = tsvector,
+  function = pg_catalog.ts_match_qv
 );
 
 -- deprecated, use @@ instead
 create operator pg_catalog.@@@ (
-  leftarg = tsquery,
-  rightarg = tsvector,
-  function = pg_catalog.ts_match_qv
+  leftarg = tsvector,
+  rightarg = tsquery,
+  function = pg_catalog.ts_match_vq
 );
 
 -- exponentiation
@@ -22617,16 +22608,9 @@ create operator pg_catalog.^@ (
 
 -- bitwise or
 create operator pg_catalog.| (
-  leftarg = smallint,
-  rightarg = smallint,
-  function = pg_catalog.int2or
-);
-
--- bitwise or
-create operator pg_catalog.| (
-  leftarg = inet,
-  rightarg = inet,
-  function = pg_catalog.inetor
+  leftarg = bigint,
+  rightarg = bigint,
+  function = pg_catalog.int8or
 );
 
 -- bitwise or
@@ -22638,9 +22622,9 @@ create operator pg_catalog.| (
 
 -- bitwise or
 create operator pg_catalog.| (
-  leftarg = macaddr,
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_or
+  leftarg = inet,
+  rightarg = inet,
+  function = pg_catalog.inetor
 );
 
 -- bitwise or
@@ -22652,9 +22636,9 @@ create operator pg_catalog.| (
 
 -- bitwise or
 create operator pg_catalog.| (
-  leftarg = bigint,
-  rightarg = bigint,
-  function = pg_catalog.int8or
+  leftarg = macaddr,
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_or
 );
 
 -- bitwise or
@@ -22664,6 +22648,20 @@ create operator pg_catalog.| (
   function = pg_catalog.macaddr8_or
 );
 
+-- bitwise or
+create operator pg_catalog.| (
+  leftarg = smallint,
+  rightarg = smallint,
+  function = pg_catalog.int2or
+);
+
+-- overlaps or is above
+create operator pg_catalog.|&> (
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_overabove
+);
+
 -- overlaps or is above
 create operator pg_catalog.|&> (
   leftarg = circle,
@@ -22678,13 +22676,6 @@ create operator pg_catalog.|&> (
   function = pg_catalog.poly_overabove
 );
 
--- overlaps or is above
-create operator pg_catalog.|&> (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_overabove
-);
-
 -- square root
 create operator pg_catalog.|/ (
   rightarg = double precision,
@@ -22719,20 +22710,6 @@ create operator pg_catalog.|>> (
   function = pg_catalog.poly_above
 );
 
--- concatenate
-create operator pg_catalog.|| (
-  leftarg = anycompatiblearray,
-  rightarg = anycompatiblearray,
-  function = pg_catalog.array_cat
-);
-
--- OR-concatenate
-create operator pg_catalog.|| (
-  leftarg = tsquery,
-  rightarg = tsquery,
-  function = pg_catalog.tsquery_or
-);
-
 -- prepend element onto front of array
 create operator pg_catalog.|| (
   leftarg = anycompatible,
@@ -22740,25 +22717,32 @@ create operator pg_catalog.|| (
   function = pg_catalog.array_prepend
 );
 
--- concatenate
+-- append element onto end of array
 create operator pg_catalog.|| (
-  leftarg = tsvector,
-  rightarg = tsvector,
-  function = pg_catalog.tsvector_concat
+  leftarg = anycompatiblearray,
+  rightarg = anycompatible,
+  function = pg_catalog.array_append
 );
 
 -- concatenate
 create operator pg_catalog.|| (
-  leftarg = jsonb,
-  rightarg = jsonb,
-  function = pg_catalog.jsonb_concat
+  leftarg = anycompatiblearray,
+  rightarg = anycompatiblearray,
+  function = pg_catalog.array_cat
 );
 
 -- concatenate
 create operator pg_catalog.|| (
-  leftarg = text,
+  leftarg = anynonarray,
   rightarg = text,
-  function = pg_catalog.textcat
+  function = pg_catalog.anytextcat
+);
+
+-- concatenate
+create operator pg_catalog.|| (
+  leftarg = bit varying,
+  rightarg = bit varying,
+  function = pg_catalog.bitcat
 );
 
 -- concatenate
@@ -22770,30 +22754,37 @@ create operator pg_catalog.|| (
 
 -- concatenate
 create operator pg_catalog.|| (
-  leftarg = bit varying,
-  rightarg = bit varying,
-  function = pg_catalog.bitcat
+  leftarg = jsonb,
+  rightarg = jsonb,
+  function = pg_catalog.jsonb_concat
 );
 
--- append element onto end of array
+-- concatenate
 create operator pg_catalog.|| (
-  leftarg = anycompatiblearray,
-  rightarg = anycompatible,
-  function = pg_catalog.array_append
+  leftarg = text,
+  rightarg = anynonarray,
+  function = pg_catalog.textanycat
 );
 
 -- concatenate
 create operator pg_catalog.|| (
-  leftarg = anynonarray,
+  leftarg = text,
   rightarg = text,
-  function = pg_catalog.anytextcat
+  function = pg_catalog.textcat
+);
+
+-- OR-concatenate
+create operator pg_catalog.|| (
+  leftarg = tsquery,
+  rightarg = tsquery,
+  function = pg_catalog.tsquery_or
 );
 
 -- concatenate
 create operator pg_catalog.|| (
-  leftarg = text,
-  rightarg = anynonarray,
-  function = pg_catalog.textanycat
+  leftarg = tsvector,
+  rightarg = tsvector,
+  function = pg_catalog.tsvector_concat
 );
 
 -- cube root
@@ -22808,36 +22799,34 @@ create operator pg_catalog.~ (
   function = pg_catalog.int8not
 );
 
--- matches regular expression, case-sensitive
+-- bitwise not
 create operator pg_catalog.~ (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.nameregexeq
+  rightarg = bit,
+  function = pg_catalog.bitnot
 );
 
 -- bitwise not
 create operator pg_catalog.~ (
-  rightarg = macaddr,
-  function = pg_catalog.macaddr_not
+  rightarg = inet,
+  function = pg_catalog.inetnot
 );
 
 -- bitwise not
 create operator pg_catalog.~ (
-  rightarg = macaddr8,
-  function = pg_catalog.macaddr8_not
+  rightarg = integer,
+  function = pg_catalog.int4not
 );
 
--- matches regular expression, case-sensitive
+-- bitwise not
 create operator pg_catalog.~ (
-  leftarg = text,
-  rightarg = text,
-  function = pg_catalog.textregexeq
+  rightarg = macaddr,
+  function = pg_catalog.macaddr_not
 );
 
 -- bitwise not
 create operator pg_catalog.~ (
-  rightarg = integer,
-  function = pg_catalog.int4not
+  rightarg = macaddr8,
+  function = pg_catalog.macaddr8_not
 );
 
 -- bitwise not
@@ -22853,30 +22842,32 @@ create operator pg_catalog.~ (
   function = pg_catalog.bpcharregexeq
 );
 
--- bitwise not
+-- matches regular expression, case-sensitive
 create operator pg_catalog.~ (
-  rightarg = inet,
-  function = pg_catalog.inetnot
+  leftarg = name,
+  rightarg = text,
+  function = pg_catalog.nameregexeq
 );
 
--- bitwise not
+-- matches regular expression, case-sensitive
 create operator pg_catalog.~ (
-  rightarg = bit,
-  function = pg_catalog.bitnot
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.textregexeq
 );
 
 -- matches regular expression, case-insensitive
 create operator pg_catalog.~* (
-  leftarg = name,
+  leftarg = character,
   rightarg = text,
-  function = pg_catalog.nameicregexeq
+  function = pg_catalog.bpcharicregexeq
 );
 
 -- matches regular expression, case-insensitive
 create operator pg_catalog.~* (
-  leftarg = character,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.bpcharicregexeq
+  function = pg_catalog.nameicregexeq
 );
 
 -- matches regular expression, case-insensitive
@@ -22900,6 +22891,13 @@ create operator pg_catalog.~<=~ (
   function = pg_catalog.text_pattern_le
 );
 
+-- less than
+create operator pg_catalog.~<~ (
+  leftarg = character,
+  rightarg = character,
+  function = pg_catalog.bpchar_pattern_lt
+);
+
 -- less than
 create operator pg_catalog.~<~ (
   leftarg = text,
@@ -22907,11 +22905,11 @@ create operator pg_catalog.~<~ (
   function = pg_catalog.text_pattern_lt
 );
 
--- less than
-create operator pg_catalog.~<~ (
-  leftarg = character,
-  rightarg = character,
-  function = pg_catalog.bpchar_pattern_lt
+-- same as
+create operator pg_catalog.~= (
+  leftarg = box,
+  rightarg = box,
+  function = pg_catalog.box_same
 );
 
 -- same as
@@ -22935,13 +22933,6 @@ create operator pg_catalog.~= (
   function = pg_catalog.poly_same
 );
 
--- same as
-create operator pg_catalog.~= (
-  leftarg = box,
-  rightarg = box,
-  function = pg_catalog.box_same
-);
-
 -- greater than or equal
 create operator pg_catalog.~>=~ (
   leftarg = character,
@@ -22972,9 +22963,9 @@ create operator pg_catalog.~>~ (
 
 -- matches LIKE expression
 create operator pg_catalog.~~ (
-  leftarg = name,
-  rightarg = text,
-  function = pg_catalog.namelike
+  leftarg = bytea,
+  rightarg = bytea,
+  function = pg_catalog.bytealike
 );
 
 -- matches LIKE expression
@@ -22986,36 +22977,36 @@ create operator pg_catalog.~~ (
 
 -- matches LIKE expression
 create operator pg_catalog.~~ (
-  leftarg = text,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.textlike
+  function = pg_catalog.namelike
 );
 
 -- matches LIKE expression
 create operator pg_catalog.~~ (
-  leftarg = bytea,
-  rightarg = bytea,
-  function = pg_catalog.bytealike
+  leftarg = text,
+  rightarg = text,
+  function = pg_catalog.textlike
 );
 
 -- matches LIKE expression, case-insensitive
 create operator pg_catalog.~~* (
-  leftarg = name,
+  leftarg = character,
   rightarg = text,
-  function = pg_catalog.nameiclike
+  function = pg_catalog.bpchariclike
 );
 
 -- matches LIKE expression, case-insensitive
 create operator pg_catalog.~~* (
-  leftarg = text,
+  leftarg = name,
   rightarg = text,
-  function = pg_catalog.texticlike
+  function = pg_catalog.nameiclike
 );
 
 -- matches LIKE expression, case-insensitive
 create operator pg_catalog.~~* (
-  leftarg = character,
+  leftarg = text,
   rightarg = text,
-  function = pg_catalog.bpchariclike
+  function = pg_catalog.texticlike
 );
 
diff --git a/crates/squawk_ide/src/extensions/bloom.sql b/crates/squawk_ide/src/extensions/bloom.sql
new file mode 100644
index 00000000..0e439edc
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/bloom.sql
@@ -0,0 +1,8 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+create function public.blhandler(internal) returns index_am_handler
+  language c;
+
diff --git a/crates/squawk_ide/src/extensions/citext.sql b/crates/squawk_ide/src/extensions/citext.sql
new file mode 100644
index 00000000..ae652668
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/citext.sql
@@ -0,0 +1,311 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: -1, align: 4
+create type public.citext;
+
+create function public.citext(boolean) returns citext
+  language internal;
+
+create function public.citext(character) returns citext
+  language internal;
+
+create function public.citext(inet) returns citext
+  language internal;
+
+create function public.citext_cmp(citext, citext) returns integer
+  language c;
+
+create function public.citext_eq(citext, citext) returns boolean
+  language c;
+
+create function public.citext_ge(citext, citext) returns boolean
+  language c;
+
+create function public.citext_gt(citext, citext) returns boolean
+  language c;
+
+create function public.citext_hash(citext) returns integer
+  language c;
+
+create function public.citext_hash_extended(citext, bigint) returns bigint
+  language c;
+
+create function public.citext_larger(citext, citext) returns citext
+  language c;
+
+create function public.citext_le(citext, citext) returns boolean
+  language c;
+
+create function public.citext_lt(citext, citext) returns boolean
+  language c;
+
+create function public.citext_ne(citext, citext) returns boolean
+  language c;
+
+create function public.citext_pattern_cmp(citext, citext) returns integer
+  language c;
+
+create function public.citext_pattern_ge(citext, citext) returns boolean
+  language c;
+
+create function public.citext_pattern_gt(citext, citext) returns boolean
+  language c;
+
+create function public.citext_pattern_le(citext, citext) returns boolean
+  language c;
+
+create function public.citext_pattern_lt(citext, citext) returns boolean
+  language c;
+
+create function public.citext_smaller(citext, citext) returns citext
+  language c;
+
+create function public.citextin(cstring) returns citext
+  language internal;
+
+create function public.citextout(citext) returns cstring
+  language internal;
+
+create function public.citextrecv(internal) returns citext
+  language internal;
+
+create function public.citextsend(citext) returns bytea
+  language internal;
+
+create aggregate public.max(citext) (
+  sfunc = citext_larger,
+  stype = citext,
+  combinefunc = citext_larger
+);
+
+create aggregate public.min(citext) (
+  sfunc = citext_smaller,
+  stype = citext,
+  combinefunc = citext_smaller
+);
+
+create function public.regexp_match(string citext, pattern citext) returns text[]
+  language sql;
+
+create function public.regexp_match(string citext, pattern citext, flags text) returns text[]
+  language sql;
+
+create function public.regexp_matches(string citext, pattern citext) returns SETOF text[]
+  language sql;
+
+create function public.regexp_matches(string citext, pattern citext, flags text) returns SETOF text[]
+  language sql;
+
+create function public.regexp_replace(string citext, pattern citext, replacement text) returns text
+  language sql;
+
+create function public.regexp_replace(string citext, pattern citext, replacement text, flags text) returns text
+  language sql;
+
+create function public.regexp_split_to_array(string citext, pattern citext) returns text[]
+  language sql;
+
+create function public.regexp_split_to_array(string citext, pattern citext, flags text) returns text[]
+  language sql;
+
+create function public.regexp_split_to_table(string citext, pattern citext) returns SETOF text
+  language sql;
+
+create function public.regexp_split_to_table(string citext, pattern citext, flags text) returns SETOF text
+  language sql;
+
+create function public.replace(citext, citext, citext) returns text
+  language sql;
+
+create function public.split_part(citext, citext, integer) returns text
+  language sql;
+
+create function public.strpos(citext, citext) returns integer
+  language sql;
+
+create function public.texticlike(citext, citext) returns boolean
+  language internal;
+
+create function public.texticlike(citext, text) returns boolean
+  language internal;
+
+create function public.texticnlike(citext, citext) returns boolean
+  language internal;
+
+create function public.texticnlike(citext, text) returns boolean
+  language internal;
+
+create function public.texticregexeq(citext, citext) returns boolean
+  language internal;
+
+create function public.texticregexeq(citext, text) returns boolean
+  language internal;
+
+create function public.texticregexne(citext, citext) returns boolean
+  language internal;
+
+create function public.texticregexne(citext, text) returns boolean
+  language internal;
+
+create function public.translate(citext, citext, text) returns text
+  language sql;
+
+create operator public.!~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticregexne
+);
+
+create operator public.!~ (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticregexne
+);
+
+create operator public.!~* (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticregexne
+);
+
+create operator public.!~* (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticregexne
+);
+
+create operator public.!~~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticnlike
+);
+
+create operator public.!~~ (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticnlike
+);
+
+create operator public.!~~* (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticnlike
+);
+
+create operator public.!~~* (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticnlike
+);
+
+create operator public.< (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_lt
+);
+
+create operator public.<= (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_le
+);
+
+create operator public.<> (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_ne
+);
+
+create operator public.= (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_eq
+);
+
+create operator public.> (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_gt
+);
+
+create operator public.>= (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_ge
+);
+
+create operator public.~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticregexeq
+);
+
+create operator public.~ (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticregexeq
+);
+
+create operator public.~* (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticregexeq
+);
+
+create operator public.~* (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticregexeq
+);
+
+create operator public.~<=~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_pattern_le
+);
+
+create operator public.~<~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_pattern_lt
+);
+
+create operator public.~>=~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_pattern_ge
+);
+
+create operator public.~>~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.citext_pattern_gt
+);
+
+create operator public.~~ (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticlike
+);
+
+create operator public.~~ (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticlike
+);
+
+create operator public.~~* (
+  leftarg = citext,
+  rightarg = citext,
+  function = public.texticlike
+);
+
+create operator public.~~* (
+  leftarg = citext,
+  rightarg = text,
+  function = public.texticlike
+);
+
diff --git a/crates/squawk_ide/src/extensions/cube.sql b/crates/squawk_ide/src/extensions/cube.sql
new file mode 100644
index 00000000..f987aab5
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/cube.sql
@@ -0,0 +1,223 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- multi-dimensional cube '(FLOAT-1, FLOAT-2, ..., FLOAT-N), (FLOAT-1, FLOAT-2, ..., FLOAT-N)'
+-- size: -1, align: 8
+create type public.cube;
+
+create function public.cube(cube, double precision) returns cube
+  language c;
+
+create function public.cube(cube, double precision, double precision) returns cube
+  language c;
+
+create function public.cube(double precision) returns cube
+  language c;
+
+create function public.cube(double precision, double precision) returns cube
+  language c;
+
+create function public.cube(double precision[]) returns cube
+  language c;
+
+create function public.cube(double precision[], double precision[]) returns cube
+  language c;
+
+-- btree comparison function
+create function public.cube_cmp(cube, cube) returns integer
+  language c;
+
+-- contained in
+create function public.cube_contained(cube, cube) returns boolean
+  language c;
+
+-- contains
+create function public.cube_contains(cube, cube) returns boolean
+  language c;
+
+create function public.cube_coord(cube, integer) returns double precision
+  language c;
+
+create function public.cube_coord_llur(cube, integer) returns double precision
+  language c;
+
+create function public.cube_dim(cube) returns integer
+  language c;
+
+create function public.cube_distance(cube, cube) returns double precision
+  language c;
+
+create function public.cube_enlarge(cube, double precision, integer) returns cube
+  language c;
+
+-- same as
+create function public.cube_eq(cube, cube) returns boolean
+  language c;
+
+-- greater than or equal to
+create function public.cube_ge(cube, cube) returns boolean
+  language c;
+
+-- greater than
+create function public.cube_gt(cube, cube) returns boolean
+  language c;
+
+create function public.cube_in(cstring) returns cube
+  language c;
+
+create function public.cube_inter(cube, cube) returns cube
+  language c;
+
+create function public.cube_is_point(cube) returns boolean
+  language c;
+
+-- lower than or equal to
+create function public.cube_le(cube, cube) returns boolean
+  language c;
+
+create function public.cube_ll_coord(cube, integer) returns double precision
+  language c;
+
+-- lower than
+create function public.cube_lt(cube, cube) returns boolean
+  language c;
+
+-- different
+create function public.cube_ne(cube, cube) returns boolean
+  language c;
+
+create function public.cube_out(cube) returns cstring
+  language c;
+
+-- overlaps
+create function public.cube_overlap(cube, cube) returns boolean
+  language c;
+
+create function public.cube_recv(internal) returns cube
+  language c;
+
+create function public.cube_send(cube) returns bytea
+  language c;
+
+create function public.cube_size(cube) returns double precision
+  language c;
+
+create function public.cube_subset(cube, integer[]) returns cube
+  language c;
+
+create function public.cube_union(cube, cube) returns cube
+  language c;
+
+create function public.cube_ur_coord(cube, integer) returns double precision
+  language c;
+
+create function public.distance_chebyshev(cube, cube) returns double precision
+  language c;
+
+create function public.distance_taxicab(cube, cube) returns double precision
+  language c;
+
+create function public.g_cube_consistent(internal, cube, smallint, oid, internal) returns boolean
+  language c;
+
+create function public.g_cube_distance(internal, cube, smallint, oid, internal) returns double precision
+  language c;
+
+create function public.g_cube_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public.g_cube_picksplit(internal, internal) returns internal
+  language c;
+
+create function public.g_cube_same(cube, cube, internal) returns internal
+  language c;
+
+create function public.g_cube_union(internal, internal) returns cube
+  language c;
+
+create operator public.&& (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_overlap
+);
+
+create operator public.-> (
+  leftarg = cube,
+  rightarg = integer,
+  function = public.cube_coord
+);
+
+create operator public.< (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_lt
+);
+
+create operator public.<#> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.distance_taxicab
+);
+
+create operator public.<-> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_distance
+);
+
+create operator public.<= (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_le
+);
+
+create operator public.<=> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.distance_chebyshev
+);
+
+create operator public.<> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_ne
+);
+
+create operator public.<@ (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_contained
+);
+
+create operator public.= (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_eq
+);
+
+create operator public.> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_gt
+);
+
+create operator public.>= (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_ge
+);
+
+create operator public.@> (
+  leftarg = cube,
+  rightarg = cube,
+  function = public.cube_contains
+);
+
+create operator public.~> (
+  leftarg = cube,
+  rightarg = integer,
+  function = public.cube_coord_llur
+);
+
diff --git a/crates/squawk_ide/src/extensions/hstore.sql b/crates/squawk_ide/src/extensions/hstore.sql
new file mode 100644
index 00000000..3503d8f4
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/hstore.sql
@@ -0,0 +1,309 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: -1, align: 4
+create type public.ghstore;
+
+-- size: -1, align: 4
+create type public.hstore;
+
+create function public.akeys(hstore) returns text[]
+  language c;
+
+create function public.avals(hstore) returns text[]
+  language c;
+
+create function public.defined(hstore, text) returns boolean
+  language c;
+
+create function public.delete(hstore, hstore) returns hstore
+  language c;
+
+create function public.delete(hstore, text) returns hstore
+  language c;
+
+create function public.delete(hstore, text[]) returns hstore
+  language c;
+
+create function public.each(hs hstore, OUT key text, OUT value text) returns SETOF record
+  language c;
+
+create function public.exist(hstore, text) returns boolean
+  language c;
+
+create function public.exists_all(hstore, text[]) returns boolean
+  language c;
+
+create function public.exists_any(hstore, text[]) returns boolean
+  language c;
+
+create function public.fetchval(hstore, text) returns text
+  language c;
+
+create function public.ghstore_compress(internal) returns internal
+  language c;
+
+create function public.ghstore_consistent(internal, hstore, smallint, oid, internal) returns boolean
+  language c;
+
+create function public.ghstore_decompress(internal) returns internal
+  language c;
+
+create function public.ghstore_in(cstring) returns ghstore
+  language c;
+
+create function public.ghstore_options(internal) returns void
+  language c;
+
+create function public.ghstore_out(ghstore) returns cstring
+  language c;
+
+create function public.ghstore_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public.ghstore_picksplit(internal, internal) returns internal
+  language c;
+
+create function public.ghstore_same(ghstore, ghstore, internal) returns internal
+  language c;
+
+create function public.ghstore_union(internal, internal) returns ghstore
+  language c;
+
+create function public.gin_consistent_hstore(internal, smallint, hstore, integer, internal, internal) returns boolean
+  language c;
+
+create function public.gin_extract_hstore(hstore, internal) returns internal
+  language c;
+
+create function public.gin_extract_hstore_query(hstore, internal, smallint, internal, internal) returns internal
+  language c;
+
+create function public.hs_concat(hstore, hstore) returns hstore
+  language c;
+
+create function public.hs_contained(hstore, hstore) returns boolean
+  language c;
+
+create function public.hs_contains(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore(record) returns hstore
+  language c;
+
+create function public.hstore(text, text) returns hstore
+  language c;
+
+create function public.hstore(text[]) returns hstore
+  language c;
+
+create function public.hstore(text[], text[]) returns hstore
+  language c;
+
+create function public.hstore_cmp(hstore, hstore) returns integer
+  language c;
+
+create function public.hstore_eq(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_ge(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_gt(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_hash(hstore) returns integer
+  language c;
+
+create function public.hstore_hash_extended(hstore, bigint) returns bigint
+  language c;
+
+create function public.hstore_in(cstring) returns hstore
+  language c;
+
+create function public.hstore_le(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_lt(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_ne(hstore, hstore) returns boolean
+  language c;
+
+create function public.hstore_out(hstore) returns cstring
+  language c;
+
+create function public.hstore_recv(internal) returns hstore
+  language c;
+
+create function public.hstore_send(hstore) returns bytea
+  language c;
+
+create function public.hstore_subscript_handler(internal) returns internal
+  language c;
+
+create function public.hstore_to_array(hstore) returns text[]
+  language c;
+
+create function public.hstore_to_json(hstore) returns json
+  language c;
+
+create function public.hstore_to_json_loose(hstore) returns json
+  language c;
+
+create function public.hstore_to_jsonb(hstore) returns jsonb
+  language c;
+
+create function public.hstore_to_jsonb_loose(hstore) returns jsonb
+  language c;
+
+create function public.hstore_to_matrix(hstore) returns text[]
+  language c;
+
+create function public.hstore_version_diag(hstore) returns integer
+  language c;
+
+create function public.isdefined(hstore, text) returns boolean
+  language c;
+
+create function public.isexists(hstore, text) returns boolean
+  language c;
+
+create function public.populate_record(anyelement, hstore) returns anyelement
+  language c;
+
+create function public.skeys(hstore) returns SETOF text
+  language c;
+
+create function public.slice(hstore, text[]) returns hstore
+  language c;
+
+create function public.slice_array(hstore, text[]) returns text[]
+  language c;
+
+create function public.svals(hstore) returns SETOF text
+  language c;
+
+create function public.tconvert(text, text) returns hstore
+  language c;
+
+create operator public.#<# (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_lt
+);
+
+create operator public.#<=# (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_le
+);
+
+create operator public.#= (
+  leftarg = anyelement,
+  rightarg = hstore,
+  function = public.populate_record
+);
+
+create operator public.#># (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_gt
+);
+
+create operator public.#>=# (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_ge
+);
+
+create operator public.%# (
+  rightarg = hstore,
+  function = public.hstore_to_matrix
+);
+
+create operator public.%% (
+  rightarg = hstore,
+  function = public.hstore_to_array
+);
+
+create operator public.- (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.delete
+);
+
+create operator public.- (
+  leftarg = hstore,
+  rightarg = text,
+  function = public.delete
+);
+
+create operator public.- (
+  leftarg = hstore,
+  rightarg = text[],
+  function = public.delete
+);
+
+create operator public.-> (
+  leftarg = hstore,
+  rightarg = text,
+  function = public.fetchval
+);
+
+create operator public.-> (
+  leftarg = hstore,
+  rightarg = text[],
+  function = public.slice_array
+);
+
+create operator public.<> (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_ne
+);
+
+create operator public.<@ (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hs_contained
+);
+
+create operator public.= (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hstore_eq
+);
+
+create operator public.? (
+  leftarg = hstore,
+  rightarg = text,
+  function = public.exist
+);
+
+create operator public.?& (
+  leftarg = hstore,
+  rightarg = text[],
+  function = public.exists_all
+);
+
+create operator public.?| (
+  leftarg = hstore,
+  rightarg = text[],
+  function = public.exists_any
+);
+
+create operator public.@> (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hs_contains
+);
+
+create operator public.|| (
+  leftarg = hstore,
+  rightarg = hstore,
+  function = public.hs_concat
+);
+
diff --git a/crates/squawk_ide/src/extensions/isn.sql b/crates/squawk_ide/src/extensions/isn.sql
new file mode 100644
index 00000000..7e0ca1e0
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/isn.sql
@@ -0,0 +1,1780 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- International European Article Number (EAN13)
+-- size: 8, align: 8
+create type public.ean13;
+
+-- International Standard Book Number (ISBN)
+-- size: 8, align: 8
+create type public.isbn;
+
+-- International Standard Book Number 13 (ISBN13)
+-- size: 8, align: 8
+create type public.isbn13;
+
+-- International Standard Music Number (ISMN)
+-- size: 8, align: 8
+create type public.ismn;
+
+-- International Standard Music Number 13 (ISMN13)
+-- size: 8, align: 8
+create type public.ismn13;
+
+-- International Standard Serial Number (ISSN)
+-- size: 8, align: 8
+create type public.issn;
+
+-- International Standard Serial Number 13 (ISSN13)
+-- size: 8, align: 8
+create type public.issn13;
+
+-- Universal Product Code (UPC)
+-- size: 8, align: 8
+create type public.upc;
+
+create function public.btean13cmp(ean13, ean13) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, isbn) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, isbn13) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, ismn) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, ismn13) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, issn) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, issn13) returns integer
+  language internal;
+
+create function public.btean13cmp(ean13, upc) returns integer
+  language internal;
+
+create function public.btisbn13cmp(isbn13, ean13) returns integer
+  language internal;
+
+create function public.btisbn13cmp(isbn13, isbn) returns integer
+  language internal;
+
+create function public.btisbn13cmp(isbn13, isbn13) returns integer
+  language internal;
+
+create function public.btisbncmp(isbn, ean13) returns integer
+  language internal;
+
+create function public.btisbncmp(isbn, isbn) returns integer
+  language internal;
+
+create function public.btisbncmp(isbn, isbn13) returns integer
+  language internal;
+
+create function public.btismn13cmp(ismn13, ean13) returns integer
+  language internal;
+
+create function public.btismn13cmp(ismn13, ismn) returns integer
+  language internal;
+
+create function public.btismn13cmp(ismn13, ismn13) returns integer
+  language internal;
+
+create function public.btismncmp(ismn, ean13) returns integer
+  language internal;
+
+create function public.btismncmp(ismn, ismn) returns integer
+  language internal;
+
+create function public.btismncmp(ismn, ismn13) returns integer
+  language internal;
+
+create function public.btissn13cmp(issn13, ean13) returns integer
+  language internal;
+
+create function public.btissn13cmp(issn13, issn) returns integer
+  language internal;
+
+create function public.btissn13cmp(issn13, issn13) returns integer
+  language internal;
+
+create function public.btissncmp(issn, ean13) returns integer
+  language internal;
+
+create function public.btissncmp(issn, issn) returns integer
+  language internal;
+
+create function public.btissncmp(issn, issn13) returns integer
+  language internal;
+
+create function public.btupccmp(upc, ean13) returns integer
+  language internal;
+
+create function public.btupccmp(upc, upc) returns integer
+  language internal;
+
+create function public.ean13_in(cstring) returns ean13
+  language c;
+
+create function public.ean13_out(ean13) returns cstring
+  language c;
+
+create function public.ean13_out(isbn13) returns cstring
+  language c;
+
+create function public.ean13_out(ismn13) returns cstring
+  language c;
+
+create function public.ean13_out(issn13) returns cstring
+  language c;
+
+create function public.hashean13(ean13) returns integer
+  language internal;
+
+create function public.hashisbn(isbn) returns integer
+  language internal;
+
+create function public.hashisbn13(isbn13) returns integer
+  language internal;
+
+create function public.hashismn(ismn) returns integer
+  language internal;
+
+create function public.hashismn13(ismn13) returns integer
+  language internal;
+
+create function public.hashissn(issn) returns integer
+  language internal;
+
+create function public.hashissn13(issn13) returns integer
+  language internal;
+
+create function public.hashupc(upc) returns integer
+  language internal;
+
+create function public.is_valid(ean13) returns boolean
+  language c;
+
+create function public.is_valid(isbn) returns boolean
+  language c;
+
+create function public.is_valid(isbn13) returns boolean
+  language c;
+
+create function public.is_valid(ismn) returns boolean
+  language c;
+
+create function public.is_valid(ismn13) returns boolean
+  language c;
+
+create function public.is_valid(issn) returns boolean
+  language c;
+
+create function public.is_valid(issn13) returns boolean
+  language c;
+
+create function public.is_valid(upc) returns boolean
+  language c;
+
+create function public.isbn(ean13) returns isbn
+  language c;
+
+create function public.isbn13(ean13) returns isbn13
+  language c;
+
+create function public.isbn13_in(cstring) returns isbn13
+  language c;
+
+create function public.isbn_in(cstring) returns isbn
+  language c;
+
+create function public.ismn(ean13) returns ismn
+  language c;
+
+create function public.ismn13(ean13) returns ismn13
+  language c;
+
+create function public.ismn13_in(cstring) returns ismn13
+  language c;
+
+create function public.ismn_in(cstring) returns ismn
+  language c;
+
+create function public.isn_out(isbn) returns cstring
+  language c;
+
+create function public.isn_out(ismn) returns cstring
+  language c;
+
+create function public.isn_out(issn) returns cstring
+  language c;
+
+create function public.isn_out(upc) returns cstring
+  language c;
+
+create function public.isn_weak() returns boolean
+  language c;
+
+create function public.isn_weak(boolean) returns boolean
+  language c;
+
+create function public.isneq(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isneq(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isneq(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isneq(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isneq(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isneq(ean13, issn) returns boolean
+  language internal;
+
+create function public.isneq(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isneq(ean13, upc) returns boolean
+  language internal;
+
+create function public.isneq(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isneq(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isneq(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isneq(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isneq(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isneq(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isneq(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isneq(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isneq(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isneq(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isneq(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isneq(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isneq(issn, ean13) returns boolean
+  language internal;
+
+create function public.isneq(issn, issn) returns boolean
+  language internal;
+
+create function public.isneq(issn, issn13) returns boolean
+  language internal;
+
+create function public.isneq(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isneq(issn13, issn) returns boolean
+  language internal;
+
+create function public.isneq(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isneq(upc, ean13) returns boolean
+  language internal;
+
+create function public.isneq(upc, upc) returns boolean
+  language internal;
+
+create function public.isnge(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isnge(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isnge(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isnge(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isnge(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isnge(ean13, issn) returns boolean
+  language internal;
+
+create function public.isnge(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isnge(ean13, upc) returns boolean
+  language internal;
+
+create function public.isnge(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isnge(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isnge(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isnge(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isnge(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isnge(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isnge(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isnge(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isnge(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isnge(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isnge(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isnge(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isnge(issn, ean13) returns boolean
+  language internal;
+
+create function public.isnge(issn, issn) returns boolean
+  language internal;
+
+create function public.isnge(issn, issn13) returns boolean
+  language internal;
+
+create function public.isnge(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isnge(issn13, issn) returns boolean
+  language internal;
+
+create function public.isnge(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isnge(upc, ean13) returns boolean
+  language internal;
+
+create function public.isnge(upc, upc) returns boolean
+  language internal;
+
+create function public.isngt(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isngt(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isngt(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isngt(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isngt(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isngt(ean13, issn) returns boolean
+  language internal;
+
+create function public.isngt(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isngt(ean13, upc) returns boolean
+  language internal;
+
+create function public.isngt(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isngt(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isngt(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isngt(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isngt(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isngt(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isngt(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isngt(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isngt(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isngt(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isngt(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isngt(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isngt(issn, ean13) returns boolean
+  language internal;
+
+create function public.isngt(issn, issn) returns boolean
+  language internal;
+
+create function public.isngt(issn, issn13) returns boolean
+  language internal;
+
+create function public.isngt(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isngt(issn13, issn) returns boolean
+  language internal;
+
+create function public.isngt(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isngt(upc, ean13) returns boolean
+  language internal;
+
+create function public.isngt(upc, upc) returns boolean
+  language internal;
+
+create function public.isnle(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isnle(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isnle(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isnle(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isnle(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isnle(ean13, issn) returns boolean
+  language internal;
+
+create function public.isnle(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isnle(ean13, upc) returns boolean
+  language internal;
+
+create function public.isnle(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isnle(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isnle(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isnle(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isnle(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isnle(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isnle(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isnle(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isnle(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isnle(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isnle(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isnle(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isnle(issn, ean13) returns boolean
+  language internal;
+
+create function public.isnle(issn, issn) returns boolean
+  language internal;
+
+create function public.isnle(issn, issn13) returns boolean
+  language internal;
+
+create function public.isnle(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isnle(issn13, issn) returns boolean
+  language internal;
+
+create function public.isnle(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isnle(upc, ean13) returns boolean
+  language internal;
+
+create function public.isnle(upc, upc) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, issn) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isnlt(ean13, upc) returns boolean
+  language internal;
+
+create function public.isnlt(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isnlt(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isnlt(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isnlt(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isnlt(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isnlt(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isnlt(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isnlt(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isnlt(issn, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(issn, issn) returns boolean
+  language internal;
+
+create function public.isnlt(issn, issn13) returns boolean
+  language internal;
+
+create function public.isnlt(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(issn13, issn) returns boolean
+  language internal;
+
+create function public.isnlt(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isnlt(upc, ean13) returns boolean
+  language internal;
+
+create function public.isnlt(upc, upc) returns boolean
+  language internal;
+
+create function public.isnne(ean13, ean13) returns boolean
+  language internal;
+
+create function public.isnne(ean13, isbn) returns boolean
+  language internal;
+
+create function public.isnne(ean13, isbn13) returns boolean
+  language internal;
+
+create function public.isnne(ean13, ismn) returns boolean
+  language internal;
+
+create function public.isnne(ean13, ismn13) returns boolean
+  language internal;
+
+create function public.isnne(ean13, issn) returns boolean
+  language internal;
+
+create function public.isnne(ean13, issn13) returns boolean
+  language internal;
+
+create function public.isnne(ean13, upc) returns boolean
+  language internal;
+
+create function public.isnne(isbn, ean13) returns boolean
+  language internal;
+
+create function public.isnne(isbn, isbn) returns boolean
+  language internal;
+
+create function public.isnne(isbn, isbn13) returns boolean
+  language internal;
+
+create function public.isnne(isbn13, ean13) returns boolean
+  language internal;
+
+create function public.isnne(isbn13, isbn) returns boolean
+  language internal;
+
+create function public.isnne(isbn13, isbn13) returns boolean
+  language internal;
+
+create function public.isnne(ismn, ean13) returns boolean
+  language internal;
+
+create function public.isnne(ismn, ismn) returns boolean
+  language internal;
+
+create function public.isnne(ismn, ismn13) returns boolean
+  language internal;
+
+create function public.isnne(ismn13, ean13) returns boolean
+  language internal;
+
+create function public.isnne(ismn13, ismn) returns boolean
+  language internal;
+
+create function public.isnne(ismn13, ismn13) returns boolean
+  language internal;
+
+create function public.isnne(issn, ean13) returns boolean
+  language internal;
+
+create function public.isnne(issn, issn) returns boolean
+  language internal;
+
+create function public.isnne(issn, issn13) returns boolean
+  language internal;
+
+create function public.isnne(issn13, ean13) returns boolean
+  language internal;
+
+create function public.isnne(issn13, issn) returns boolean
+  language internal;
+
+create function public.isnne(issn13, issn13) returns boolean
+  language internal;
+
+create function public.isnne(upc, ean13) returns boolean
+  language internal;
+
+create function public.isnne(upc, upc) returns boolean
+  language internal;
+
+create function public.issn(ean13) returns issn
+  language c;
+
+create function public.issn13(ean13) returns issn13
+  language c;
+
+create function public.issn13_in(cstring) returns issn13
+  language c;
+
+create function public.issn_in(cstring) returns issn
+  language c;
+
+create function public.make_valid(ean13) returns ean13
+  language c;
+
+create function public.make_valid(isbn) returns isbn
+  language c;
+
+create function public.make_valid(isbn13) returns isbn13
+  language c;
+
+create function public.make_valid(ismn) returns ismn
+  language c;
+
+create function public.make_valid(ismn13) returns ismn13
+  language c;
+
+create function public.make_valid(issn) returns issn
+  language c;
+
+create function public.make_valid(issn13) returns issn13
+  language c;
+
+create function public.make_valid(upc) returns upc
+  language c;
+
+create function public.upc(ean13) returns upc
+  language c;
+
+create function public.upc_in(cstring) returns upc
+  language c;
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isnlt
+);
+
+create operator public.< (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isnlt
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isnle
+);
+
+create operator public.<= (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isnle
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isnne
+);
+
+create operator public.<> (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isnne
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isneq
+);
+
+create operator public.= (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isneq
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isngt
+);
+
+create operator public.> (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isngt
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = isbn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = isbn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = ismn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = ismn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = issn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = issn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ean13,
+  rightarg = upc,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn,
+  rightarg = isbn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn,
+  rightarg = isbn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn13,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn13,
+  rightarg = isbn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = isbn13,
+  rightarg = isbn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn,
+  rightarg = ismn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn,
+  rightarg = ismn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn13,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn13,
+  rightarg = ismn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = ismn13,
+  rightarg = ismn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn,
+  rightarg = issn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn,
+  rightarg = issn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn13,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn13,
+  rightarg = issn,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = issn13,
+  rightarg = issn13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = upc,
+  rightarg = ean13,
+  function = public.isnge
+);
+
+create operator public.>= (
+  leftarg = upc,
+  rightarg = upc,
+  function = public.isnge
+);
+
diff --git a/crates/squawk_ide/src/extensions/ltree.sql b/crates/squawk_ide/src/extensions/ltree.sql
new file mode 100644
index 00000000..ce40cd65
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/ltree.sql
@@ -0,0 +1,551 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: -1, align: 4
+create type public.lquery;
+
+-- size: -1, align: 4
+create type public.ltree;
+
+-- size: -1, align: 4
+create type public.ltree_gist;
+
+-- size: -1, align: 4
+create type public.ltxtquery;
+
+create function public._lt_q_regex(ltree[], lquery[]) returns boolean
+  language c;
+
+create function public._lt_q_rregex(lquery[], ltree[]) returns boolean
+  language c;
+
+create function public._ltq_extract_regex(ltree[], lquery) returns ltree
+  language c;
+
+create function public._ltq_regex(ltree[], lquery) returns boolean
+  language c;
+
+create function public._ltq_rregex(lquery, ltree[]) returns boolean
+  language c;
+
+create function public._ltree_compress(internal) returns internal
+  language c;
+
+create function public._ltree_consistent(internal, ltree[], smallint, oid, internal) returns boolean
+  language c;
+
+create function public._ltree_extract_isparent(ltree[], ltree) returns ltree
+  language c;
+
+create function public._ltree_extract_risparent(ltree[], ltree) returns ltree
+  language c;
+
+create function public._ltree_gist_options(internal) returns void
+  language c;
+
+create function public._ltree_isparent(ltree[], ltree) returns boolean
+  language c;
+
+create function public._ltree_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public._ltree_picksplit(internal, internal) returns internal
+  language c;
+
+create function public._ltree_r_isparent(ltree, ltree[]) returns boolean
+  language c;
+
+create function public._ltree_r_risparent(ltree, ltree[]) returns boolean
+  language c;
+
+create function public._ltree_risparent(ltree[], ltree) returns boolean
+  language c;
+
+create function public._ltree_same(ltree_gist, ltree_gist, internal) returns internal
+  language c;
+
+create function public._ltree_union(internal, internal) returns ltree_gist
+  language c;
+
+create function public._ltxtq_exec(ltree[], ltxtquery) returns boolean
+  language c;
+
+create function public._ltxtq_extract_exec(ltree[], ltxtquery) returns ltree
+  language c;
+
+create function public._ltxtq_rexec(ltxtquery, ltree[]) returns boolean
+  language c;
+
+create function public.hash_ltree(ltree) returns integer
+  language c;
+
+create function public.hash_ltree_extended(ltree, bigint) returns bigint
+  language c;
+
+create function public.index(ltree, ltree) returns integer
+  language c;
+
+create function public.index(ltree, ltree, integer) returns integer
+  language c;
+
+create function public.lca(ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree, ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree, ltree, ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree, ltree, ltree, ltree, ltree, ltree, ltree, ltree) returns ltree
+  language c;
+
+create function public.lca(ltree[]) returns ltree
+  language c;
+
+create function public.lquery_in(cstring) returns lquery
+  language c;
+
+create function public.lquery_out(lquery) returns cstring
+  language c;
+
+create function public.lquery_recv(internal) returns lquery
+  language c;
+
+create function public.lquery_send(lquery) returns bytea
+  language c;
+
+create function public.lt_q_regex(ltree, lquery[]) returns boolean
+  language c;
+
+create function public.lt_q_rregex(lquery[], ltree) returns boolean
+  language c;
+
+create function public.ltq_regex(ltree, lquery) returns boolean
+  language c;
+
+create function public.ltq_rregex(lquery, ltree) returns boolean
+  language c;
+
+create function public.ltree2text(ltree) returns text
+  language c;
+
+create function public.ltree_addltree(ltree, ltree) returns ltree
+  language c;
+
+create function public.ltree_addtext(ltree, text) returns ltree
+  language c;
+
+create function public.ltree_cmp(ltree, ltree) returns integer
+  language c;
+
+create function public.ltree_compress(internal) returns internal
+  language c;
+
+create function public.ltree_consistent(internal, ltree, smallint, oid, internal) returns boolean
+  language c;
+
+create function public.ltree_decompress(internal) returns internal
+  language c;
+
+create function public.ltree_eq(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_ge(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_gist_in(cstring) returns ltree_gist
+  language c;
+
+create function public.ltree_gist_options(internal) returns void
+  language c;
+
+create function public.ltree_gist_out(ltree_gist) returns cstring
+  language c;
+
+create function public.ltree_gt(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_in(cstring) returns ltree
+  language c;
+
+create function public.ltree_isparent(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_le(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_lt(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_ne(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_out(ltree) returns cstring
+  language c;
+
+create function public.ltree_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public.ltree_picksplit(internal, internal) returns internal
+  language c;
+
+create function public.ltree_recv(internal) returns ltree
+  language c;
+
+create function public.ltree_risparent(ltree, ltree) returns boolean
+  language c;
+
+create function public.ltree_same(ltree_gist, ltree_gist, internal) returns internal
+  language c;
+
+create function public.ltree_send(ltree) returns bytea
+  language c;
+
+create function public.ltree_textadd(text, ltree) returns ltree
+  language c;
+
+create function public.ltree_union(internal, internal) returns ltree_gist
+  language c;
+
+create function public.ltreeparentsel(internal, oid, internal, integer) returns double precision
+  language c;
+
+create function public.ltxtq_exec(ltree, ltxtquery) returns boolean
+  language c;
+
+create function public.ltxtq_in(cstring) returns ltxtquery
+  language c;
+
+create function public.ltxtq_out(ltxtquery) returns cstring
+  language c;
+
+create function public.ltxtq_recv(internal) returns ltxtquery
+  language c;
+
+create function public.ltxtq_rexec(ltxtquery, ltree) returns boolean
+  language c;
+
+create function public.ltxtq_send(ltxtquery) returns bytea
+  language c;
+
+create function public.nlevel(ltree) returns integer
+  language c;
+
+create function public.subltree(ltree, integer, integer) returns ltree
+  language c;
+
+create function public.subpath(ltree, integer) returns ltree
+  language c;
+
+create function public.subpath(ltree, integer, integer) returns ltree
+  language c;
+
+create function public.text2ltree(text) returns ltree
+  language c;
+
+create operator public.< (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_lt
+);
+
+create operator public.<= (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_le
+);
+
+create operator public.<> (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_ne
+);
+
+create operator public.<@ (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_risparent
+);
+
+create operator public.<@ (
+  leftarg = ltree,
+  rightarg = ltree[],
+  function = public._ltree_r_isparent
+);
+
+create operator public.<@ (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_risparent
+);
+
+create operator public.= (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_eq
+);
+
+create operator public.> (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_gt
+);
+
+create operator public.>= (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_ge
+);
+
+create operator public.? (
+  leftarg = lquery[],
+  rightarg = ltree,
+  function = public.lt_q_rregex
+);
+
+create operator public.? (
+  leftarg = lquery[],
+  rightarg = ltree[],
+  function = public._lt_q_rregex
+);
+
+create operator public.? (
+  leftarg = ltree,
+  rightarg = lquery[],
+  function = public.lt_q_regex
+);
+
+create operator public.? (
+  leftarg = ltree[],
+  rightarg = lquery[],
+  function = public._lt_q_regex
+);
+
+create operator public.?<@ (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_extract_risparent
+);
+
+create operator public.?@ (
+  leftarg = ltree[],
+  rightarg = ltxtquery,
+  function = public._ltxtq_extract_exec
+);
+
+create operator public.?@> (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_extract_isparent
+);
+
+create operator public.?~ (
+  leftarg = ltree[],
+  rightarg = lquery,
+  function = public._ltq_extract_regex
+);
+
+create operator public.@ (
+  leftarg = ltree,
+  rightarg = ltxtquery,
+  function = public.ltxtq_exec
+);
+
+create operator public.@ (
+  leftarg = ltree[],
+  rightarg = ltxtquery,
+  function = public._ltxtq_exec
+);
+
+create operator public.@ (
+  leftarg = ltxtquery,
+  rightarg = ltree,
+  function = public.ltxtq_rexec
+);
+
+create operator public.@ (
+  leftarg = ltxtquery,
+  rightarg = ltree[],
+  function = public._ltxtq_rexec
+);
+
+create operator public.@> (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_isparent
+);
+
+create operator public.@> (
+  leftarg = ltree,
+  rightarg = ltree[],
+  function = public._ltree_r_risparent
+);
+
+create operator public.@> (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_isparent
+);
+
+create operator public.^<@ (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_risparent
+);
+
+create operator public.^<@ (
+  leftarg = ltree,
+  rightarg = ltree[],
+  function = public._ltree_r_isparent
+);
+
+create operator public.^<@ (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_risparent
+);
+
+create operator public.^? (
+  leftarg = lquery[],
+  rightarg = ltree,
+  function = public.lt_q_rregex
+);
+
+create operator public.^? (
+  leftarg = lquery[],
+  rightarg = ltree[],
+  function = public._lt_q_rregex
+);
+
+create operator public.^? (
+  leftarg = ltree,
+  rightarg = lquery[],
+  function = public.lt_q_regex
+);
+
+create operator public.^? (
+  leftarg = ltree[],
+  rightarg = lquery[],
+  function = public._lt_q_regex
+);
+
+create operator public.^@ (
+  leftarg = ltree,
+  rightarg = ltxtquery,
+  function = public.ltxtq_exec
+);
+
+create operator public.^@ (
+  leftarg = ltree[],
+  rightarg = ltxtquery,
+  function = public._ltxtq_exec
+);
+
+create operator public.^@ (
+  leftarg = ltxtquery,
+  rightarg = ltree,
+  function = public.ltxtq_rexec
+);
+
+create operator public.^@ (
+  leftarg = ltxtquery,
+  rightarg = ltree[],
+  function = public._ltxtq_rexec
+);
+
+create operator public.^@> (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_isparent
+);
+
+create operator public.^@> (
+  leftarg = ltree,
+  rightarg = ltree[],
+  function = public._ltree_r_risparent
+);
+
+create operator public.^@> (
+  leftarg = ltree[],
+  rightarg = ltree,
+  function = public._ltree_isparent
+);
+
+create operator public.^~ (
+  leftarg = lquery,
+  rightarg = ltree,
+  function = public.ltq_rregex
+);
+
+create operator public.^~ (
+  leftarg = lquery,
+  rightarg = ltree[],
+  function = public._ltq_rregex
+);
+
+create operator public.^~ (
+  leftarg = ltree,
+  rightarg = lquery,
+  function = public.ltq_regex
+);
+
+create operator public.^~ (
+  leftarg = ltree[],
+  rightarg = lquery,
+  function = public._ltq_regex
+);
+
+create operator public.|| (
+  leftarg = ltree,
+  rightarg = ltree,
+  function = public.ltree_addltree
+);
+
+create operator public.|| (
+  leftarg = ltree,
+  rightarg = text,
+  function = public.ltree_addtext
+);
+
+create operator public.|| (
+  leftarg = text,
+  rightarg = ltree,
+  function = public.ltree_textadd
+);
+
+create operator public.~ (
+  leftarg = lquery,
+  rightarg = ltree,
+  function = public.ltq_rregex
+);
+
+create operator public.~ (
+  leftarg = lquery,
+  rightarg = ltree[],
+  function = public._ltq_rregex
+);
+
+create operator public.~ (
+  leftarg = ltree,
+  rightarg = lquery,
+  function = public.ltq_regex
+);
+
+create operator public.~ (
+  leftarg = ltree[],
+  rightarg = lquery,
+  function = public._ltq_regex
+);
+
diff --git a/crates/squawk_ide/src/extensions/pg_stat_statements.sql b/crates/squawk_ide/src/extensions/pg_stat_statements.sql
new file mode 100644
index 00000000..77a44e83
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/pg_stat_statements.sql
@@ -0,0 +1,76 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+create view public.pg_stat_statements(userid, dbid, toplevel, queryid, query, plans, total_plan_time, min_plan_time, max_plan_time, mean_plan_time, stddev_plan_time, calls, total_exec_time, min_exec_time, max_exec_time, mean_exec_time, stddev_exec_time, rows, shared_blks_hit, shared_blks_read, shared_blks_dirtied, shared_blks_written, local_blks_hit, local_blks_read, local_blks_dirtied, local_blks_written, temp_blks_read, temp_blks_written, shared_blk_read_time, shared_blk_write_time, local_blk_read_time, local_blk_write_time, temp_blk_read_time, temp_blk_write_time, wal_records, wal_fpi, wal_bytes, wal_buffers_full, jit_functions, jit_generation_time, jit_inlining_count, jit_inlining_time, jit_optimization_count, jit_optimization_time, jit_emission_count, jit_emission_time, jit_deform_count, jit_deform_time, parallel_workers_to_launch, parallel_workers_launched, stats_since, minmax_stats_since) as
+  select
+    null::oid,
+    null::oid,
+    null::boolean,
+    null::bigint,
+    null::text,
+    null::bigint,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::bigint,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::bigint,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::double precision,
+    null::bigint,
+    null::bigint,
+    null::numeric,
+    null::bigint,
+    null::bigint,
+    null::double precision,
+    null::bigint,
+    null::double precision,
+    null::bigint,
+    null::double precision,
+    null::bigint,
+    null::double precision,
+    null::bigint,
+    null::double precision,
+    null::bigint,
+    null::bigint,
+    null::timestamp with time zone,
+    null::timestamp with time zone
+;
+
+create view public.pg_stat_statements_info(dealloc, stats_reset) as
+  select
+    null::bigint,
+    null::timestamp with time zone
+;
+
+create function public.pg_stat_statements(showtext boolean, OUT userid oid, OUT dbid oid, OUT toplevel boolean, OUT queryid bigint, OUT query text, OUT plans bigint, OUT total_plan_time double precision, OUT min_plan_time double precision, OUT max_plan_time double precision, OUT mean_plan_time double precision, OUT stddev_plan_time double precision, OUT calls bigint, OUT total_exec_time double precision, OUT min_exec_time double precision, OUT max_exec_time double precision, OUT mean_exec_time double precision, OUT stddev_exec_time double precision, OUT rows bigint, OUT shared_blks_hit bigint, OUT shared_blks_read bigint, OUT shared_blks_dirtied bigint, OUT shared_blks_written bigint, OUT local_blks_hit bigint, OUT local_blks_read bigint, OUT local_blks_dirtied bigint, OUT local_blks_written bigint, OUT temp_blks_read bigint, OUT temp_blks_written bigint, OUT shared_blk_read_time double precision, OUT shared_blk_write_time double precision, OUT local_blk_read_time double precision, OUT local_blk_write_time double precision, OUT temp_blk_read_time double precision, OUT temp_blk_write_time double precision, OUT wal_records bigint, OUT wal_fpi bigint, OUT wal_bytes numeric, OUT wal_buffers_full bigint, OUT jit_functions bigint, OUT jit_generation_time double precision, OUT jit_inlining_count bigint, OUT jit_inlining_time double precision, OUT jit_optimization_count bigint, OUT jit_optimization_time double precision, OUT jit_emission_count bigint, OUT jit_emission_time double precision, OUT jit_deform_count bigint, OUT jit_deform_time double precision, OUT parallel_workers_to_launch bigint, OUT parallel_workers_launched bigint, OUT stats_since timestamp with time zone, OUT minmax_stats_since timestamp with time zone) returns SETOF record
+  language c;
+
+create function public.pg_stat_statements_info(OUT dealloc bigint, OUT stats_reset timestamp with time zone) returns record
+  language c;
+
+create function public.pg_stat_statements_reset(userid oid DEFAULT 0, dbid oid DEFAULT 0, queryid bigint DEFAULT 0, minmax_only boolean DEFAULT false) returns timestamp with time zone
+  language c;
+
diff --git a/crates/squawk_ide/src/extensions/pg_trgm.sql b/crates/squawk_ide/src/extensions/pg_trgm.sql
new file mode 100644
index 00000000..32911d60
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/pg_trgm.sql
@@ -0,0 +1,161 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: -1, align: 4
+create type public.gtrgm;
+
+create function public.gin_extract_query_trgm(text, internal, smallint, internal, internal, internal, internal) returns internal
+  language c;
+
+create function public.gin_extract_value_trgm(text, internal) returns internal
+  language c;
+
+create function public.gin_trgm_consistent(internal, smallint, text, integer, internal, internal, internal, internal) returns boolean
+  language c;
+
+create function public.gin_trgm_triconsistent(internal, smallint, text, integer, internal, internal, internal) returns "char"
+  language c;
+
+create function public.gtrgm_compress(internal) returns internal
+  language c;
+
+create function public.gtrgm_consistent(internal, text, smallint, oid, internal) returns boolean
+  language c;
+
+create function public.gtrgm_decompress(internal) returns internal
+  language c;
+
+create function public.gtrgm_distance(internal, text, smallint, oid, internal) returns double precision
+  language c;
+
+create function public.gtrgm_in(cstring) returns gtrgm
+  language c;
+
+create function public.gtrgm_options(internal) returns void
+  language c;
+
+create function public.gtrgm_out(gtrgm) returns cstring
+  language c;
+
+create function public.gtrgm_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public.gtrgm_picksplit(internal, internal) returns internal
+  language c;
+
+create function public.gtrgm_same(gtrgm, gtrgm, internal) returns internal
+  language c;
+
+create function public.gtrgm_union(internal, internal) returns gtrgm
+  language c;
+
+create function public.set_limit(real) returns real
+  language c;
+
+create function public.show_limit() returns real
+  language c;
+
+create function public.show_trgm(text) returns text[]
+  language c;
+
+create function public.similarity(text, text) returns real
+  language c;
+
+create function public.similarity_dist(text, text) returns real
+  language c;
+
+create function public.similarity_op(text, text) returns boolean
+  language c;
+
+create function public.strict_word_similarity(text, text) returns real
+  language c;
+
+create function public.strict_word_similarity_commutator_op(text, text) returns boolean
+  language c;
+
+create function public.strict_word_similarity_dist_commutator_op(text, text) returns real
+  language c;
+
+create function public.strict_word_similarity_dist_op(text, text) returns real
+  language c;
+
+create function public.strict_word_similarity_op(text, text) returns boolean
+  language c;
+
+create function public.word_similarity(text, text) returns real
+  language c;
+
+create function public.word_similarity_commutator_op(text, text) returns boolean
+  language c;
+
+create function public.word_similarity_dist_commutator_op(text, text) returns real
+  language c;
+
+create function public.word_similarity_dist_op(text, text) returns real
+  language c;
+
+create function public.word_similarity_op(text, text) returns boolean
+  language c;
+
+create operator public.% (
+  leftarg = text,
+  rightarg = text,
+  function = public.similarity_op
+);
+
+create operator public.%> (
+  leftarg = text,
+  rightarg = text,
+  function = public.word_similarity_commutator_op
+);
+
+create operator public.%>> (
+  leftarg = text,
+  rightarg = text,
+  function = public.strict_word_similarity_commutator_op
+);
+
+create operator public.<% (
+  leftarg = text,
+  rightarg = text,
+  function = public.word_similarity_op
+);
+
+create operator public.<-> (
+  leftarg = text,
+  rightarg = text,
+  function = public.similarity_dist
+);
+
+create operator public.<->> (
+  leftarg = text,
+  rightarg = text,
+  function = public.word_similarity_dist_commutator_op
+);
+
+create operator public.<->>> (
+  leftarg = text,
+  rightarg = text,
+  function = public.strict_word_similarity_dist_commutator_op
+);
+
+create operator public.<<% (
+  leftarg = text,
+  rightarg = text,
+  function = public.strict_word_similarity_op
+);
+
+create operator public.<<-> (
+  leftarg = text,
+  rightarg = text,
+  function = public.word_similarity_dist_op
+);
+
+create operator public.<<<-> (
+  leftarg = text,
+  rightarg = text,
+  function = public.strict_word_similarity_dist_op
+);
+
diff --git a/crates/squawk_ide/src/extensions/pgcrypto.sql b/crates/squawk_ide/src/extensions/pgcrypto.sql
new file mode 100644
index 00000000..5c9b2e97
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/pgcrypto.sql
@@ -0,0 +1,116 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+create function public.armor(bytea) returns text
+  language c;
+
+create function public.armor(bytea, text[], text[]) returns text
+  language c;
+
+create function public.crypt(text, text) returns text
+  language c;
+
+create function public.dearmor(text) returns bytea
+  language c;
+
+create function public.decrypt(bytea, bytea, text) returns bytea
+  language c;
+
+create function public.decrypt_iv(bytea, bytea, bytea, text) returns bytea
+  language c;
+
+create function public.digest(bytea, text) returns bytea
+  language c;
+
+create function public.digest(text, text) returns bytea
+  language c;
+
+create function public.encrypt(bytea, bytea, text) returns bytea
+  language c;
+
+create function public.encrypt_iv(bytea, bytea, bytea, text) returns bytea
+  language c;
+
+create function public.fips_mode() returns boolean
+  language c;
+
+create function public.gen_random_bytes(integer) returns bytea
+  language c;
+
+create function public.gen_random_uuid() returns uuid
+  language c;
+
+create function public.gen_salt(text) returns text
+  language c;
+
+create function public.gen_salt(text, integer) returns text
+  language c;
+
+create function public.hmac(bytea, bytea, text) returns bytea
+  language c;
+
+create function public.hmac(text, text, text) returns bytea
+  language c;
+
+create function public.pgp_armor_headers(text, OUT key text, OUT value text) returns SETOF record
+  language c;
+
+create function public.pgp_key_id(bytea) returns text
+  language c;
+
+create function public.pgp_pub_decrypt(bytea, bytea) returns text
+  language c;
+
+create function public.pgp_pub_decrypt(bytea, bytea, text) returns text
+  language c;
+
+create function public.pgp_pub_decrypt(bytea, bytea, text, text) returns text
+  language c;
+
+create function public.pgp_pub_decrypt_bytea(bytea, bytea) returns bytea
+  language c;
+
+create function public.pgp_pub_decrypt_bytea(bytea, bytea, text) returns bytea
+  language c;
+
+create function public.pgp_pub_decrypt_bytea(bytea, bytea, text, text) returns bytea
+  language c;
+
+create function public.pgp_pub_encrypt(text, bytea) returns bytea
+  language c;
+
+create function public.pgp_pub_encrypt(text, bytea, text) returns bytea
+  language c;
+
+create function public.pgp_pub_encrypt_bytea(bytea, bytea) returns bytea
+  language c;
+
+create function public.pgp_pub_encrypt_bytea(bytea, bytea, text) returns bytea
+  language c;
+
+create function public.pgp_sym_decrypt(bytea, text) returns text
+  language c;
+
+create function public.pgp_sym_decrypt(bytea, text, text) returns text
+  language c;
+
+create function public.pgp_sym_decrypt_bytea(bytea, text) returns bytea
+  language c;
+
+create function public.pgp_sym_decrypt_bytea(bytea, text, text) returns bytea
+  language c;
+
+create function public.pgp_sym_encrypt(text, text) returns bytea
+  language c;
+
+create function public.pgp_sym_encrypt(text, text, text) returns bytea
+  language c;
+
+create function public.pgp_sym_encrypt_bytea(bytea, text) returns bytea
+  language c;
+
+create function public.pgp_sym_encrypt_bytea(bytea, text, text) returns bytea
+  language c;
+
diff --git a/crates/squawk_ide/src/extensions/plpgsql.sql b/crates/squawk_ide/src/extensions/plpgsql.sql
new file mode 100644
index 00000000..6f03e6e5
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/plpgsql.sql
@@ -0,0 +1,14 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+create function pg_catalog.plpgsql_call_handler() returns language_handler
+  language c;
+
+create function pg_catalog.plpgsql_inline_handler(internal) returns void
+  language c;
+
+create function pg_catalog.plpgsql_validator(oid) returns void
+  language c;
+
diff --git a/crates/squawk_ide/src/extensions/postgis.sql b/crates/squawk_ide/src/extensions/postgis.sql
new file mode 100644
index 00000000..3f44032a
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/postgis.sql
@@ -0,0 +1,2770 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: 65, align: 4
+create type public.box2d;
+
+-- size: 16, align: 8
+create type public.box2df;
+
+-- size: 52, align: 8
+create type public.box3d;
+
+-- size: -1, align: 8
+create type public.geography;
+
+-- size: -1, align: 8
+create type public.geometry;
+
+-- size: -1, align: 8
+create type public.gidx;
+
+-- size: 65, align: 8
+create type public.spheroid;
+
+create table public.spatial_ref_sys (
+  srid integer,
+  auth_name character varying(256),
+  auth_srid integer,
+  srtext character varying(2048),
+  proj4text character varying(2048)
+);
+
+create view public.geography_columns(f_table_catalog, f_table_schema, f_table_name, f_geography_column, coord_dimension, srid, type) as
+  select
+    null::name,
+    null::name,
+    null::name,
+    null::name,
+    null::integer,
+    null::integer,
+    null::text
+;
+
+create view public.geometry_columns(f_table_catalog, f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, type) as
+  select
+    null::character varying(256),
+    null::name,
+    null::name,
+    null::name,
+    null::integer,
+    null::integer,
+    null::character varying(30)
+;
+
+create function public._postgis_deprecate(oldname text, newname text, version text) returns void
+  language plpgsql;
+
+create function public._postgis_index_extent(tbl regclass, col text) returns box2d
+  language c;
+
+create function public._postgis_join_selectivity(regclass, text, regclass, text, text DEFAULT '2'::text) returns double precision
+  language c;
+
+create function public._postgis_pgsql_version() returns text
+  language sql;
+
+create function public._postgis_scripts_pgsql_version() returns text
+  language sql;
+
+create function public._postgis_selectivity(tbl regclass, att_name text, geom geometry, mode text DEFAULT '2'::text) returns double precision
+  language c;
+
+create function public._postgis_stats(tbl regclass, att_name text, text DEFAULT '2'::text) returns text
+  language c;
+
+create function public._st_3ddfullywithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public._st_3ddwithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public._st_3dintersects(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_asgml(integer, geometry, integer, integer, text, text) returns text
+  language c;
+
+create function public._st_asx3d(integer, geometry, integer, integer, text) returns text
+  language c;
+
+create function public._st_bestsrid(geography) returns integer
+  language c;
+
+create function public._st_bestsrid(geography, geography) returns integer
+  language c;
+
+create function public._st_contains(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_containsproperly(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_coveredby(geog1 geography, geog2 geography) returns boolean
+  language c;
+
+create function public._st_coveredby(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_covers(geog1 geography, geog2 geography) returns boolean
+  language c;
+
+create function public._st_covers(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_crosses(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_dfullywithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public._st_distancetree(geography, geography) returns double precision
+  language sql;
+
+create function public._st_distancetree(geography, geography, double precision, boolean) returns double precision
+  language c;
+
+create function public._st_distanceuncached(geography, geography) returns double precision
+  language sql;
+
+create function public._st_distanceuncached(geography, geography, boolean) returns double precision
+  language sql;
+
+create function public._st_distanceuncached(geography, geography, double precision, boolean) returns double precision
+  language c;
+
+create function public._st_dwithin(geog1 geography, geog2 geography, tolerance double precision, use_spheroid boolean DEFAULT true) returns boolean
+  language c;
+
+create function public._st_dwithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public._st_dwithinuncached(geography, geography, double precision) returns boolean
+  language sql;
+
+create function public._st_dwithinuncached(geography, geography, double precision, boolean) returns boolean
+  language c;
+
+create function public._st_equals(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_expand(geography, double precision) returns geography
+  language c;
+
+create function public._st_geomfromgml(text, integer) returns geometry
+  language c;
+
+create function public._st_intersects(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_linecrossingdirection(line1 geometry, line2 geometry) returns integer
+  language c;
+
+create function public._st_longestline(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public._st_maxdistance(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public._st_orderingequals(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_overlaps(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_pointoutside(geography) returns geography
+  language c;
+
+create function public._st_sortablehash(geom geometry) returns bigint
+  language c;
+
+create function public._st_touches(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public._st_voronoi(g1 geometry, clip geometry DEFAULT NULL::geometry, tolerance double precision DEFAULT 0.0, return_polygons boolean DEFAULT true) returns geometry
+  language c;
+
+create function public._st_within(geom1 geometry, geom2 geometry) returns boolean
+  language sql;
+
+create function public.addgeometrycolumn(catalog_name character varying, schema_name character varying, table_name character varying, column_name character varying, new_srid_in integer, new_type character varying, new_dim integer, use_typmod boolean DEFAULT true) returns text
+  language plpgsql;
+
+create function public.addgeometrycolumn(schema_name character varying, table_name character varying, column_name character varying, new_srid integer, new_type character varying, new_dim integer, use_typmod boolean DEFAULT true) returns text
+  language plpgsql;
+
+create function public.addgeometrycolumn(table_name character varying, column_name character varying, new_srid integer, new_type character varying, new_dim integer, use_typmod boolean DEFAULT true) returns text
+  language plpgsql;
+
+create function public.box(box3d) returns box
+  language c;
+
+create function public.box(geometry) returns box
+  language c;
+
+create function public.box2d(box3d) returns box2d
+  language c;
+
+create function public.box2d(geometry) returns box2d
+  language c;
+
+create function public.box2d_in(cstring) returns box2d
+  language c;
+
+create function public.box2d_out(box2d) returns cstring
+  language c;
+
+create function public.box2df_in(cstring) returns box2df
+  language c;
+
+create function public.box2df_out(box2df) returns cstring
+  language c;
+
+create function public.box3d(box2d) returns box3d
+  language c;
+
+create function public.box3d(geometry) returns box3d
+  language c;
+
+create function public.box3d_in(cstring) returns box3d
+  language c;
+
+create function public.box3d_out(box3d) returns cstring
+  language c;
+
+create function public.box3dtobox(box3d) returns box
+  language c;
+
+create function public.bytea(geography) returns bytea
+  language c;
+
+create function public.bytea(geometry) returns bytea
+  language c;
+
+create function public.contains_2d(box2df, box2df) returns boolean
+  language c;
+
+create function public.contains_2d(box2df, geometry) returns boolean
+  language c;
+
+create function public.contains_2d(geometry, box2df) returns boolean
+  language sql;
+
+create function public.dropgeometrycolumn(catalog_name character varying, schema_name character varying, table_name character varying, column_name character varying) returns text
+  language plpgsql;
+
+create function public.dropgeometrycolumn(schema_name character varying, table_name character varying, column_name character varying) returns text
+  language plpgsql;
+
+create function public.dropgeometrycolumn(table_name character varying, column_name character varying) returns text
+  language plpgsql;
+
+create function public.dropgeometrytable(catalog_name character varying, schema_name character varying, table_name character varying) returns text
+  language plpgsql;
+
+create function public.dropgeometrytable(schema_name character varying, table_name character varying) returns text
+  language sql;
+
+create function public.dropgeometrytable(table_name character varying) returns text
+  language sql;
+
+create function public.equals(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.find_srid(character varying, character varying, character varying) returns integer
+  language plpgsql;
+
+create function public.geog_brin_inclusion_add_value(internal, internal, internal, internal) returns boolean
+  language c;
+
+create function public.geog_brin_inclusion_merge(internal, internal) returns internal
+  language c;
+
+create function public.geography(bytea) returns geography
+  language c;
+
+create function public.geography(geography, integer, boolean) returns geography
+  language c;
+
+create function public.geography(geometry) returns geography
+  language c;
+
+create function public.geography_analyze(internal) returns boolean
+  language c;
+
+create function public.geography_cmp(geography, geography) returns integer
+  language c;
+
+create function public.geography_distance_knn(geography, geography) returns double precision
+  language c;
+
+create function public.geography_eq(geography, geography) returns boolean
+  language c;
+
+create function public.geography_ge(geography, geography) returns boolean
+  language c;
+
+create function public.geography_gist_compress(internal) returns internal
+  language c;
+
+create function public.geography_gist_consistent(internal, geography, integer) returns boolean
+  language c;
+
+create function public.geography_gist_decompress(internal) returns internal
+  language c;
+
+create function public.geography_gist_distance(internal, geography, integer) returns double precision
+  language c;
+
+create function public.geography_gist_penalty(internal, internal, internal) returns internal
+  language c;
+
+create function public.geography_gist_picksplit(internal, internal) returns internal
+  language c;
+
+create function public.geography_gist_same(box2d, box2d, internal) returns internal
+  language c;
+
+create function public.geography_gist_union(bytea, internal) returns internal
+  language c;
+
+create function public.geography_gt(geography, geography) returns boolean
+  language c;
+
+create function public.geography_in(cstring, oid, integer) returns geography
+  language c;
+
+create function public.geography_le(geography, geography) returns boolean
+  language c;
+
+create function public.geography_lt(geography, geography) returns boolean
+  language c;
+
+create function public.geography_out(geography) returns cstring
+  language c;
+
+create function public.geography_overlaps(geography, geography) returns boolean
+  language c;
+
+create function public.geography_recv(internal, oid, integer) returns geography
+  language c;
+
+create function public.geography_send(geography) returns bytea
+  language c;
+
+create function public.geography_spgist_choose_nd(internal, internal) returns void
+  language c;
+
+create function public.geography_spgist_compress_nd(internal) returns internal
+  language c;
+
+create function public.geography_spgist_config_nd(internal, internal) returns void
+  language c;
+
+create function public.geography_spgist_inner_consistent_nd(internal, internal) returns void
+  language c;
+
+create function public.geography_spgist_leaf_consistent_nd(internal, internal) returns boolean
+  language c;
+
+create function public.geography_spgist_picksplit_nd(internal, internal) returns void
+  language c;
+
+create function public.geography_typmod_in(cstring[]) returns integer
+  language c;
+
+create function public.geography_typmod_out(integer) returns cstring
+  language c;
+
+create function public.geom2d_brin_inclusion_add_value(internal, internal, internal, internal) returns boolean
+  language c;
+
+create function public.geom2d_brin_inclusion_merge(internal, internal) returns internal
+  language c;
+
+create function public.geom3d_brin_inclusion_add_value(internal, internal, internal, internal) returns boolean
+  language c;
+
+create function public.geom3d_brin_inclusion_merge(internal, internal) returns internal
+  language c;
+
+create function public.geom4d_brin_inclusion_add_value(internal, internal, internal, internal) returns boolean
+  language c;
+
+create function public.geom4d_brin_inclusion_merge(internal, internal) returns internal
+  language c;
+
+create function public.geometry(box2d) returns geometry
+  language c;
+
+create function public.geometry(box3d) returns geometry
+  language c;
+
+create function public.geometry(bytea) returns geometry
+  language c;
+
+create function public.geometry(geography) returns geometry
+  language c;
+
+create function public.geometry(geometry, integer, boolean) returns geometry
+  language c;
+
+create function public.geometry(path) returns geometry
+  language c;
+
+create function public.geometry(point) returns geometry
+  language c;
+
+create function public.geometry(polygon) returns geometry
+  language c;
+
+create function public.geometry(text) returns geometry
+  language c;
+
+create function public.geometry_above(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_analyze(internal) returns boolean
+  language c;
+
+create function public.geometry_below(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_cmp(geom1 geometry, geom2 geometry) returns integer
+  language c;
+
+create function public.geometry_contained_3d(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_contains(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_contains_3d(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_contains_nd(geometry, geometry) returns boolean
+  language c;
+
+create function public.geometry_distance_box(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.geometry_distance_centroid(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.geometry_distance_centroid_nd(geometry, geometry) returns double precision
+  language c;
+
+create function public.geometry_distance_cpa(geometry, geometry) returns double precision
+  language c;
+
+create function public.geometry_eq(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_ge(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_gist_compress_2d(internal) returns internal
+  language c;
+
+create function public.geometry_gist_compress_nd(internal) returns internal
+  language c;
+
+create function public.geometry_gist_consistent_2d(internal, geometry, integer) returns boolean
+  language c;
+
+create function public.geometry_gist_consistent_nd(internal, geometry, integer) returns boolean
+  language c;
+
+create function public.geometry_gist_decompress_2d(internal) returns internal
+  language c;
+
+create function public.geometry_gist_decompress_nd(internal) returns internal
+  language c;
+
+create function public.geometry_gist_distance_2d(internal, geometry, integer) returns double precision
+  language c;
+
+create function public.geometry_gist_distance_nd(internal, geometry, integer) returns double precision
+  language c;
+
+create function public.geometry_gist_penalty_2d(internal, internal, internal) returns internal
+  language c;
+
+create function public.geometry_gist_penalty_nd(internal, internal, internal) returns internal
+  language c;
+
+create function public.geometry_gist_picksplit_2d(internal, internal) returns internal
+  language c;
+
+create function public.geometry_gist_picksplit_nd(internal, internal) returns internal
+  language c;
+
+create function public.geometry_gist_same_2d(geom1 geometry, geom2 geometry, internal) returns internal
+  language c;
+
+create function public.geometry_gist_same_nd(geometry, geometry, internal) returns internal
+  language c;
+
+create function public.geometry_gist_sortsupport_2d(internal) returns void
+  language c;
+
+create function public.geometry_gist_union_2d(bytea, internal) returns internal
+  language c;
+
+create function public.geometry_gist_union_nd(bytea, internal) returns internal
+  language c;
+
+create function public.geometry_gt(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_hash(geometry) returns integer
+  language c;
+
+create function public.geometry_in(cstring) returns geometry
+  language c;
+
+create function public.geometry_le(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_left(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_lt(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_neq(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_out(geometry) returns cstring
+  language c;
+
+create function public.geometry_overabove(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_overbelow(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_overlaps(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_overlaps_3d(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_overlaps_nd(geometry, geometry) returns boolean
+  language c;
+
+create function public.geometry_overleft(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_overright(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_recv(internal) returns geometry
+  language c;
+
+create function public.geometry_right(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_same(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_same_3d(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_same_nd(geometry, geometry) returns boolean
+  language c;
+
+create function public.geometry_send(geometry) returns bytea
+  language c;
+
+create function public.geometry_sortsupport(internal) returns void
+  language c;
+
+create function public.geometry_spgist_choose_2d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_choose_3d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_choose_nd(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_compress_2d(internal) returns internal
+  language c;
+
+create function public.geometry_spgist_compress_3d(internal) returns internal
+  language c;
+
+create function public.geometry_spgist_compress_nd(internal) returns internal
+  language c;
+
+create function public.geometry_spgist_config_2d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_config_3d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_config_nd(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_inner_consistent_2d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_inner_consistent_3d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_inner_consistent_nd(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_leaf_consistent_2d(internal, internal) returns boolean
+  language c;
+
+create function public.geometry_spgist_leaf_consistent_3d(internal, internal) returns boolean
+  language c;
+
+create function public.geometry_spgist_leaf_consistent_nd(internal, internal) returns boolean
+  language c;
+
+create function public.geometry_spgist_picksplit_2d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_picksplit_3d(internal, internal) returns void
+  language c;
+
+create function public.geometry_spgist_picksplit_nd(internal, internal) returns void
+  language c;
+
+create function public.geometry_typmod_in(cstring[]) returns integer
+  language c;
+
+create function public.geometry_typmod_out(integer) returns cstring
+  language c;
+
+create function public.geometry_within(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.geometry_within_nd(geometry, geometry) returns boolean
+  language c;
+
+create function public.geometrytype(geography) returns text
+  language c;
+
+create function public.geometrytype(geometry) returns text
+  language c;
+
+create function public.geomfromewkb(bytea) returns geometry
+  language c;
+
+create function public.geomfromewkt(text) returns geometry
+  language c;
+
+create function public.get_proj4_from_srid(integer) returns text
+  language plpgsql;
+
+create function public.gidx_in(cstring) returns gidx
+  language c;
+
+create function public.gidx_out(gidx) returns cstring
+  language c;
+
+create function public.gserialized_gist_joinsel_2d(internal, oid, internal, smallint) returns double precision
+  language c;
+
+create function public.gserialized_gist_joinsel_nd(internal, oid, internal, smallint) returns double precision
+  language c;
+
+create function public.gserialized_gist_sel_2d(internal, oid, internal, integer) returns double precision
+  language c;
+
+create function public.gserialized_gist_sel_nd(internal, oid, internal, integer) returns double precision
+  language c;
+
+create function public.is_contained_2d(box2df, box2df) returns boolean
+  language c;
+
+create function public.is_contained_2d(box2df, geometry) returns boolean
+  language c;
+
+create function public.is_contained_2d(geometry, box2df) returns boolean
+  language sql;
+
+create function public.json(geometry) returns json
+  language c;
+
+create function public.jsonb(geometry) returns jsonb
+  language c;
+
+create function public.overlaps_2d(box2df, box2df) returns boolean
+  language c;
+
+create function public.overlaps_2d(box2df, geometry) returns boolean
+  language c;
+
+create function public.overlaps_2d(geometry, box2df) returns boolean
+  language sql;
+
+create function public.overlaps_geog(geography, gidx) returns boolean
+  language sql;
+
+create function public.overlaps_geog(gidx, geography) returns boolean
+  language c;
+
+create function public.overlaps_geog(gidx, gidx) returns boolean
+  language c;
+
+create function public.overlaps_nd(geometry, gidx) returns boolean
+  language sql;
+
+create function public.overlaps_nd(gidx, geometry) returns boolean
+  language c;
+
+create function public.overlaps_nd(gidx, gidx) returns boolean
+  language c;
+
+create function public.path(geometry) returns path
+  language c;
+
+create function public.pgis_asflatgeobuf_finalfn(internal) returns bytea
+  language c;
+
+create function public.pgis_asflatgeobuf_transfn(internal, anyelement) returns internal
+  language c;
+
+create function public.pgis_asflatgeobuf_transfn(internal, anyelement, boolean) returns internal
+  language c;
+
+create function public.pgis_asflatgeobuf_transfn(internal, anyelement, boolean, text) returns internal
+  language c;
+
+create function public.pgis_asgeobuf_finalfn(internal) returns bytea
+  language c;
+
+create function public.pgis_asgeobuf_transfn(internal, anyelement) returns internal
+  language c;
+
+create function public.pgis_asgeobuf_transfn(internal, anyelement, text) returns internal
+  language c;
+
+create function public.pgis_asmvt_combinefn(internal, internal) returns internal
+  language c;
+
+create function public.pgis_asmvt_deserialfn(bytea, internal) returns internal
+  language c;
+
+create function public.pgis_asmvt_finalfn(internal) returns bytea
+  language c;
+
+create function public.pgis_asmvt_serialfn(internal) returns bytea
+  language c;
+
+create function public.pgis_asmvt_transfn(internal, anyelement) returns internal
+  language c;
+
+create function public.pgis_asmvt_transfn(internal, anyelement, text) returns internal
+  language c;
+
+create function public.pgis_asmvt_transfn(internal, anyelement, text, integer) returns internal
+  language c;
+
+create function public.pgis_asmvt_transfn(internal, anyelement, text, integer, text) returns internal
+  language c;
+
+create function public.pgis_asmvt_transfn(internal, anyelement, text, integer, text, text) returns internal
+  language c;
+
+create function public.pgis_geometry_accum_transfn(internal, geometry) returns internal
+  language c;
+
+create function public.pgis_geometry_accum_transfn(internal, geometry, double precision) returns internal
+  language c;
+
+create function public.pgis_geometry_accum_transfn(internal, geometry, double precision, integer) returns internal
+  language c;
+
+create function public.pgis_geometry_clusterintersecting_finalfn(internal) returns geometry[]
+  language c;
+
+create function public.pgis_geometry_clusterwithin_finalfn(internal) returns geometry[]
+  language c;
+
+create function public.pgis_geometry_collect_finalfn(internal) returns geometry
+  language c;
+
+create function public.pgis_geometry_coverageunion_finalfn(internal) returns geometry
+  language c;
+
+create function public.pgis_geometry_makeline_finalfn(internal) returns geometry
+  language c;
+
+create function public.pgis_geometry_polygonize_finalfn(internal) returns geometry
+  language c;
+
+create function public.pgis_geometry_union_parallel_combinefn(internal, internal) returns internal
+  language c;
+
+create function public.pgis_geometry_union_parallel_deserialfn(bytea, internal) returns internal
+  language c;
+
+create function public.pgis_geometry_union_parallel_finalfn(internal) returns geometry
+  language c;
+
+create function public.pgis_geometry_union_parallel_serialfn(internal) returns bytea
+  language c;
+
+create function public.pgis_geometry_union_parallel_transfn(internal, geometry) returns internal
+  language c;
+
+create function public.pgis_geometry_union_parallel_transfn(internal, geometry, double precision) returns internal
+  language c;
+
+create function public.point(geometry) returns point
+  language c;
+
+create function public.polygon(geometry) returns polygon
+  language c;
+
+create function public.populate_geometry_columns(tbl_oid oid, use_typmod boolean DEFAULT true) returns integer
+  language plpgsql;
+
+create function public.populate_geometry_columns(use_typmod boolean DEFAULT true) returns text
+  language plpgsql;
+
+create function public.postgis_addbbox(geometry) returns geometry
+  language c;
+
+create function public.postgis_cache_bbox() returns trigger
+  language c;
+
+create function public.postgis_constraint_dims(geomschema text, geomtable text, geomcolumn text) returns integer
+  language sql;
+
+create function public.postgis_constraint_srid(geomschema text, geomtable text, geomcolumn text) returns integer
+  language sql;
+
+create function public.postgis_constraint_type(geomschema text, geomtable text, geomcolumn text) returns character varying
+  language sql;
+
+create function public.postgis_dropbbox(geometry) returns geometry
+  language c;
+
+create function public.postgis_extensions_upgrade(target_version text DEFAULT NULL::text) returns text
+  language plpgsql;
+
+create function public.postgis_full_version() returns text
+  language plpgsql;
+
+create function public.postgis_geos_compiled_version() returns text
+  language c;
+
+create function public.postgis_geos_noop(geometry) returns geometry
+  language c;
+
+create function public.postgis_geos_version() returns text
+  language c;
+
+create function public.postgis_getbbox(geometry) returns box2d
+  language c;
+
+create function public.postgis_hasbbox(geometry) returns boolean
+  language c;
+
+create function public.postgis_index_supportfn(internal) returns internal
+  language c;
+
+create function public.postgis_lib_build_date() returns text
+  language c;
+
+create function public.postgis_lib_revision() returns text
+  language c;
+
+create function public.postgis_lib_version() returns text
+  language c;
+
+create function public.postgis_libjson_version() returns text
+  language c;
+
+create function public.postgis_liblwgeom_version() returns text
+  language c;
+
+create function public.postgis_libprotobuf_version() returns text
+  language c;
+
+create function public.postgis_libxml_version() returns text
+  language c;
+
+create function public.postgis_noop(geometry) returns geometry
+  language c;
+
+create function public.postgis_proj_compiled_version() returns text
+  language c;
+
+create function public.postgis_proj_version() returns text
+  language c;
+
+create function public.postgis_scripts_build_date() returns text
+  language sql;
+
+create function public.postgis_scripts_installed() returns text
+  language sql;
+
+create function public.postgis_scripts_released() returns text
+  language c;
+
+create function public.postgis_srs(auth_name text, auth_srid text) returns TABLE(auth_name text, auth_srid text, srname text, srtext text, proj4text text, point_sw geometry, point_ne geometry)
+  language c;
+
+create function public.postgis_srs_all() returns TABLE(auth_name text, auth_srid text, srname text, srtext text, proj4text text, point_sw geometry, point_ne geometry)
+  language c;
+
+create function public.postgis_srs_codes(auth_name text) returns SETOF text
+  language c;
+
+create function public.postgis_srs_search(bounds geometry, authname text DEFAULT 'EPSG'::text) returns TABLE(auth_name text, auth_srid text, srname text, srtext text, proj4text text, point_sw geometry, point_ne geometry)
+  language c;
+
+create function public.postgis_svn_version() returns text
+  language sql;
+
+create function public.postgis_transform_geometry(geom geometry, text, text, integer) returns geometry
+  language c;
+
+create function public.postgis_transform_pipeline_geometry(geom geometry, pipeline text, forward boolean, to_srid integer) returns geometry
+  language c;
+
+create function public.postgis_type_name(geomname character varying, coord_dimension integer, use_new_name boolean DEFAULT true) returns character varying
+  language sql;
+
+create function public.postgis_typmod_dims(integer) returns integer
+  language c;
+
+create function public.postgis_typmod_srid(integer) returns integer
+  language c;
+
+create function public.postgis_typmod_type(integer) returns text
+  language c;
+
+create function public.postgis_version() returns text
+  language c;
+
+create function public.postgis_wagyu_version() returns text
+  language c;
+
+create function public.spheroid_in(cstring) returns spheroid
+  language c;
+
+create function public.spheroid_out(spheroid) returns cstring
+  language c;
+
+create function public.st_3dclosestpoint(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_3ddfullywithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public.st_3ddistance(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_3ddwithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create aggregate public.st_3dextent(geometry) (
+  sfunc = public.st_combinebbox,
+  stype = box3d,
+  combinefunc = public.st_combinebbox
+);
+
+create function public.st_3dintersects(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_3dlength(geometry) returns double precision
+  language c;
+
+create function public.st_3dlineinterpolatepoint(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_3dlongestline(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_3dmakebox(geom1 geometry, geom2 geometry) returns box3d
+  language c;
+
+create function public.st_3dmaxdistance(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_3dperimeter(geometry) returns double precision
+  language c;
+
+create function public.st_3dshortestline(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_addmeasure(geometry, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_addpoint(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_addpoint(geom1 geometry, geom2 geometry, integer) returns geometry
+  language c;
+
+create function public.st_affine(geometry, double precision, double precision, double precision, double precision, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_affine(geometry, double precision, double precision, double precision, double precision, double precision, double precision, double precision, double precision, double precision, double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_angle(line1 geometry, line2 geometry) returns double precision
+  language sql;
+
+create function public.st_angle(pt1 geometry, pt2 geometry, pt3 geometry, pt4 geometry DEFAULT '0101000000000000000000F87F000000000000F87F'::geometry) returns double precision
+  language c;
+
+create function public.st_area(geog geography, use_spheroid boolean DEFAULT true) returns double precision
+  language c;
+
+create function public.st_area(geometry) returns double precision
+  language c;
+
+create function public.st_area(text) returns double precision
+  language sql;
+
+create function public.st_area2d(geometry) returns double precision
+  language c;
+
+create function public.st_asbinary(geography) returns bytea
+  language c;
+
+create function public.st_asbinary(geography, text) returns bytea
+  language c;
+
+create function public.st_asbinary(geometry) returns bytea
+  language c;
+
+create function public.st_asbinary(geometry, text) returns bytea
+  language c;
+
+create function public.st_asencodedpolyline(geom geometry, nprecision integer DEFAULT 5) returns text
+  language c;
+
+create function public.st_asewkb(geometry) returns bytea
+  language c;
+
+create function public.st_asewkb(geometry, text) returns bytea
+  language c;
+
+create function public.st_asewkt(geography) returns text
+  language c;
+
+create function public.st_asewkt(geography, integer) returns text
+  language c;
+
+create function public.st_asewkt(geometry) returns text
+  language c;
+
+create function public.st_asewkt(geometry, integer) returns text
+  language c;
+
+create function public.st_asewkt(text) returns text
+  language sql;
+
+create aggregate public.st_asflatgeobuf(anyelement) (
+  sfunc = public.pgis_asflatgeobuf_transfn,
+  stype = internal,
+  finalfunc = pgis_asflatgeobuf_finalfn
+);
+
+create aggregate public.st_asflatgeobuf(anyelement, boolean) (
+  sfunc = public.pgis_asflatgeobuf_transfn,
+  stype = internal,
+  finalfunc = pgis_asflatgeobuf_finalfn
+);
+
+create aggregate public.st_asflatgeobuf(anyelement, boolean, text) (
+  sfunc = public.pgis_asflatgeobuf_transfn,
+  stype = internal,
+  finalfunc = pgis_asflatgeobuf_finalfn
+);
+
+create aggregate public.st_asgeobuf(anyelement) (
+  sfunc = public.pgis_asgeobuf_transfn,
+  stype = internal,
+  finalfunc = pgis_asgeobuf_finalfn
+);
+
+create aggregate public.st_asgeobuf(anyelement, text) (
+  sfunc = public.pgis_asgeobuf_transfn,
+  stype = internal,
+  finalfunc = pgis_asgeobuf_finalfn
+);
+
+create function public.st_asgeojson(geog geography, maxdecimaldigits integer DEFAULT 9, options integer DEFAULT 0) returns text
+  language c;
+
+create function public.st_asgeojson(geom geometry, maxdecimaldigits integer DEFAULT 9, options integer DEFAULT 8) returns text
+  language c;
+
+create function public.st_asgeojson(r record, geom_column text DEFAULT ''::text, maxdecimaldigits integer DEFAULT 9, pretty_bool boolean DEFAULT false, id_column text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_asgeojson(text) returns text
+  language sql;
+
+create function public.st_asgml(geog geography, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0, nprefix text DEFAULT 'gml'::text, id text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_asgml(geom geometry, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0) returns text
+  language c;
+
+create function public.st_asgml(text) returns text
+  language sql;
+
+create function public.st_asgml(version integer, geog geography, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0, nprefix text DEFAULT 'gml'::text, id text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_asgml(version integer, geom geometry, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0, nprefix text DEFAULT NULL::text, id text DEFAULT NULL::text) returns text
+  language c;
+
+create function public.st_ashexewkb(geometry) returns text
+  language c;
+
+create function public.st_ashexewkb(geometry, text) returns text
+  language c;
+
+create function public.st_askml(geog geography, maxdecimaldigits integer DEFAULT 15, nprefix text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_askml(geom geometry, maxdecimaldigits integer DEFAULT 15, nprefix text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_askml(text) returns text
+  language sql;
+
+create function public.st_aslatlontext(geom geometry, tmpl text DEFAULT ''::text) returns text
+  language c;
+
+create function public.st_asmarc21(geom geometry, format text DEFAULT 'hdddmmss'::text) returns text
+  language c;
+
+create aggregate public.st_asmvt(anyelement) (
+  sfunc = public.pgis_asmvt_transfn,
+  stype = internal,
+  finalfunc = pgis_asmvt_finalfn,
+  combinefunc = pgis_asmvt_combinefn
+);
+
+create aggregate public.st_asmvt(anyelement, text) (
+  sfunc = public.pgis_asmvt_transfn,
+  stype = internal,
+  finalfunc = pgis_asmvt_finalfn,
+  combinefunc = pgis_asmvt_combinefn
+);
+
+create aggregate public.st_asmvt(anyelement, text, integer) (
+  sfunc = public.pgis_asmvt_transfn,
+  stype = internal,
+  finalfunc = pgis_asmvt_finalfn,
+  combinefunc = pgis_asmvt_combinefn
+);
+
+create aggregate public.st_asmvt(anyelement, text, integer, text) (
+  sfunc = public.pgis_asmvt_transfn,
+  stype = internal,
+  finalfunc = pgis_asmvt_finalfn,
+  combinefunc = pgis_asmvt_combinefn
+);
+
+create aggregate public.st_asmvt(anyelement, text, integer, text, text) (
+  sfunc = public.pgis_asmvt_transfn,
+  stype = internal,
+  finalfunc = pgis_asmvt_finalfn,
+  combinefunc = pgis_asmvt_combinefn
+);
+
+create function public.st_asmvtgeom(geom geometry, bounds box2d, extent integer DEFAULT 4096, buffer integer DEFAULT 256, clip_geom boolean DEFAULT true) returns geometry
+  language c;
+
+create function public.st_assvg(geog geography, rel integer DEFAULT 0, maxdecimaldigits integer DEFAULT 15) returns text
+  language c;
+
+create function public.st_assvg(geom geometry, rel integer DEFAULT 0, maxdecimaldigits integer DEFAULT 15) returns text
+  language c;
+
+create function public.st_assvg(text) returns text
+  language sql;
+
+create function public.st_astext(geography) returns text
+  language c;
+
+create function public.st_astext(geography, integer) returns text
+  language c;
+
+create function public.st_astext(geometry) returns text
+  language c;
+
+create function public.st_astext(geometry, integer) returns text
+  language c;
+
+create function public.st_astext(text) returns text
+  language sql;
+
+create function public.st_astwkb(geom geometry, prec integer DEFAULT NULL::integer, prec_z integer DEFAULT NULL::integer, prec_m integer DEFAULT NULL::integer, with_sizes boolean DEFAULT NULL::boolean, with_boxes boolean DEFAULT NULL::boolean) returns bytea
+  language c;
+
+create function public.st_astwkb(geom geometry[], ids bigint[], prec integer DEFAULT NULL::integer, prec_z integer DEFAULT NULL::integer, prec_m integer DEFAULT NULL::integer, with_sizes boolean DEFAULT NULL::boolean, with_boxes boolean DEFAULT NULL::boolean) returns bytea
+  language c;
+
+create function public.st_asx3d(geom geometry, maxdecimaldigits integer DEFAULT 15, options integer DEFAULT 0) returns text
+  language sql;
+
+create function public.st_azimuth(geog1 geography, geog2 geography) returns double precision
+  language c;
+
+create function public.st_azimuth(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_bdmpolyfromtext(text, integer) returns geometry
+  language plpgsql;
+
+create function public.st_bdpolyfromtext(text, integer) returns geometry
+  language plpgsql;
+
+create function public.st_boundary(geometry) returns geometry
+  language c;
+
+create function public.st_boundingdiagonal(geom geometry, fits boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_box2dfromgeohash(text, integer DEFAULT NULL::integer) returns box2d
+  language c;
+
+create function public.st_buffer(geography, double precision) returns geography
+  language sql;
+
+create function public.st_buffer(geography, double precision, integer) returns geography
+  language sql;
+
+create function public.st_buffer(geography, double precision, text) returns geography
+  language sql;
+
+create function public.st_buffer(geom geometry, radius double precision, options text DEFAULT ''::text) returns geometry
+  language c;
+
+create function public.st_buffer(geom geometry, radius double precision, quadsegs integer) returns geometry
+  language sql;
+
+create function public.st_buffer(text, double precision) returns geometry
+  language sql;
+
+create function public.st_buffer(text, double precision, integer) returns geometry
+  language sql;
+
+create function public.st_buffer(text, double precision, text) returns geometry
+  language sql;
+
+create function public.st_buildarea(geometry) returns geometry
+  language c;
+
+create function public.st_centroid(geography, use_spheroid boolean DEFAULT true) returns geography
+  language c;
+
+create function public.st_centroid(geometry) returns geometry
+  language c;
+
+create function public.st_centroid(text) returns geometry
+  language sql;
+
+create function public.st_chaikinsmoothing(geometry, integer DEFAULT 1, boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_cleangeometry(geometry) returns geometry
+  language c;
+
+create function public.st_clipbybox2d(geom geometry, box box2d) returns geometry
+  language c;
+
+create function public.st_closestpoint(geography, geography, use_spheroid boolean DEFAULT true) returns geography
+  language c;
+
+create function public.st_closestpoint(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_closestpoint(text, text) returns geometry
+  language sql;
+
+create function public.st_closestpointofapproach(geometry, geometry) returns double precision
+  language c;
+
+create function public.st_clusterdbscan(geometry, eps double precision, minpoints integer) returns integer
+  language c;
+
+create aggregate public.st_clusterintersecting(geometry) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_clusterintersecting_finalfn
+);
+
+create function public.st_clusterintersecting(geometry[]) returns geometry[]
+  language c;
+
+create function public.st_clusterintersectingwin(geometry) returns integer
+  language c;
+
+create function public.st_clusterkmeans(geom geometry, k integer, max_radius double precision DEFAULT NULL::double precision) returns integer
+  language c;
+
+create aggregate public.st_clusterwithin(geometry, double precision) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_clusterwithin_finalfn
+);
+
+create function public.st_clusterwithin(geometry[], double precision) returns geometry[]
+  language c;
+
+create function public.st_clusterwithinwin(geometry, distance double precision) returns integer
+  language c;
+
+create function public.st_collect(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create aggregate public.st_collect(geometry) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_collect_finalfn
+);
+
+create function public.st_collect(geometry[]) returns geometry
+  language c;
+
+create function public.st_collectionextract(geometry) returns geometry
+  language c;
+
+create function public.st_collectionextract(geometry, integer) returns geometry
+  language c;
+
+create function public.st_collectionhomogenize(geometry) returns geometry
+  language c;
+
+create function public.st_combinebbox(box2d, geometry) returns box2d
+  language c;
+
+create function public.st_combinebbox(box3d, box3d) returns box3d
+  language c;
+
+create function public.st_combinebbox(box3d, geometry) returns box3d
+  language c;
+
+create function public.st_concavehull(param_geom geometry, param_pctconvex double precision, param_allow_holes boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_contains(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_containsproperly(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_convexhull(geometry) returns geometry
+  language c;
+
+create function public.st_coorddim(geometry geometry) returns smallint
+  language c;
+
+create function public.st_coverageclean(geom geometry, gapmaximumwidth double precision DEFAULT 0.0, snappingdistance double precision DEFAULT '-1.0'::numeric, overlapmergestrategy text DEFAULT 'MERGE_LONGEST_BORDER'::text) returns geometry
+  language c;
+
+create function public.st_coverageinvalidedges(geom geometry, tolerance double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_coveragesimplify(geom geometry, tolerance double precision, simplifyboundary boolean DEFAULT true) returns geometry
+  language c;
+
+create aggregate public.st_coverageunion(geometry) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_coverageunion_finalfn
+);
+
+create function public.st_coverageunion(geometry[]) returns geometry
+  language c;
+
+create function public.st_coveredby(geog1 geography, geog2 geography) returns boolean
+  language c;
+
+create function public.st_coveredby(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_coveredby(text, text) returns boolean
+  language sql;
+
+create function public.st_covers(geog1 geography, geog2 geography) returns boolean
+  language c;
+
+create function public.st_covers(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_covers(text, text) returns boolean
+  language sql;
+
+create function public.st_cpawithin(geometry, geometry, double precision) returns boolean
+  language c;
+
+create function public.st_crosses(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_curven(geometry geometry, i integer) returns geometry
+  language c;
+
+create function public.st_curvetoline(geom geometry, tol double precision DEFAULT 32, toltype integer DEFAULT 0, flags integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_delaunaytriangles(g1 geometry, tolerance double precision DEFAULT 0.0, flags integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_dfullywithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public.st_difference(geom1 geometry, geom2 geometry, gridsize double precision DEFAULT '-1.0'::numeric) returns geometry
+  language c;
+
+create function public.st_dimension(geometry) returns integer
+  language c;
+
+create function public.st_disjoint(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_distance(geog1 geography, geog2 geography, use_spheroid boolean DEFAULT true) returns double precision
+  language c;
+
+create function public.st_distance(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_distance(text, text) returns double precision
+  language sql;
+
+create function public.st_distancecpa(geometry, geometry) returns double precision
+  language c;
+
+create function public.st_distancesphere(geom1 geometry, geom2 geometry) returns double precision
+  language sql;
+
+create function public.st_distancesphere(geom1 geometry, geom2 geometry, radius double precision) returns double precision
+  language c;
+
+create function public.st_distancespheroid(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_distancespheroid(geom1 geometry, geom2 geometry, spheroid) returns double precision
+  language c;
+
+create function public.st_dump(geometry) returns SETOF geometry_dump
+  language c;
+
+create function public.st_dumppoints(geometry) returns SETOF geometry_dump
+  language c;
+
+create function public.st_dumprings(geometry) returns SETOF geometry_dump
+  language c;
+
+create function public.st_dumpsegments(geometry) returns SETOF geometry_dump
+  language c;
+
+create function public.st_dwithin(geog1 geography, geog2 geography, tolerance double precision, use_spheroid boolean DEFAULT true) returns boolean
+  language c;
+
+create function public.st_dwithin(geom1 geometry, geom2 geometry, double precision) returns boolean
+  language c;
+
+create function public.st_dwithin(text, text, double precision) returns boolean
+  language sql;
+
+create function public.st_endpoint(geometry) returns geometry
+  language c;
+
+create function public.st_envelope(geometry) returns geometry
+  language c;
+
+create function public.st_equals(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_estimatedextent(text, text) returns box2d
+  language c;
+
+create function public.st_estimatedextent(text, text, text) returns box2d
+  language c;
+
+create function public.st_estimatedextent(text, text, text, boolean) returns box2d
+  language c;
+
+create function public.st_expand(box box2d, dx double precision, dy double precision) returns box2d
+  language c;
+
+create function public.st_expand(box box3d, dx double precision, dy double precision, dz double precision DEFAULT 0) returns box3d
+  language c;
+
+create function public.st_expand(box2d, double precision) returns box2d
+  language c;
+
+create function public.st_expand(box3d, double precision) returns box3d
+  language c;
+
+create function public.st_expand(geom geometry, dx double precision, dy double precision, dz double precision DEFAULT 0, dm double precision DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_expand(geometry, double precision) returns geometry
+  language c;
+
+create aggregate public.st_extent(geometry) (
+  sfunc = public.st_combinebbox,
+  stype = box3d,
+  finalfunc = public.box2d,
+  combinefunc = public.st_combinebbox
+);
+
+create function public.st_exteriorring(geometry) returns geometry
+  language c;
+
+create function public.st_filterbym(geometry, double precision, double precision DEFAULT NULL::double precision, boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_findextent(text, text) returns box2d
+  language plpgsql;
+
+create function public.st_findextent(text, text, text) returns box2d
+  language plpgsql;
+
+create function public.st_flipcoordinates(geometry) returns geometry
+  language c;
+
+create function public.st_force2d(geometry) returns geometry
+  language c;
+
+create function public.st_force3d(geom geometry, zvalue double precision DEFAULT 0.0) returns geometry
+  language sql;
+
+create function public.st_force3dm(geom geometry, mvalue double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_force3dz(geom geometry, zvalue double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_force4d(geom geometry, zvalue double precision DEFAULT 0.0, mvalue double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_forcecollection(geometry) returns geometry
+  language c;
+
+create function public.st_forcecurve(geometry) returns geometry
+  language c;
+
+create function public.st_forcepolygonccw(geometry) returns geometry
+  language sql;
+
+create function public.st_forcepolygoncw(geometry) returns geometry
+  language c;
+
+create function public.st_forcerhr(geometry) returns geometry
+  language c;
+
+create function public.st_forcesfs(geometry) returns geometry
+  language c;
+
+create function public.st_forcesfs(geometry, version text) returns geometry
+  language c;
+
+create function public.st_frechetdistance(geom1 geometry, geom2 geometry, double precision DEFAULT '-1'::integer) returns double precision
+  language c;
+
+create function public.st_fromflatgeobuf(anyelement, bytea) returns SETOF anyelement
+  language c;
+
+create function public.st_fromflatgeobuftotable(text, text, bytea) returns void
+  language c;
+
+create function public.st_generatepoints(area geometry, npoints integer) returns geometry
+  language c;
+
+create function public.st_generatepoints(area geometry, npoints integer, seed integer) returns geometry
+  language c;
+
+create function public.st_geogfromtext(text) returns geography
+  language c;
+
+create function public.st_geogfromwkb(bytea) returns geography
+  language c;
+
+create function public.st_geographyfromtext(text) returns geography
+  language c;
+
+create function public.st_geohash(geog geography, maxchars integer DEFAULT 0) returns text
+  language c;
+
+create function public.st_geohash(geom geometry, maxchars integer DEFAULT 0) returns text
+  language c;
+
+create function public.st_geomcollfromtext(text) returns geometry
+  language sql;
+
+create function public.st_geomcollfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_geomcollfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_geomcollfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_geometricmedian(g geometry, tolerance double precision DEFAULT NULL::double precision, max_iter integer DEFAULT 10000, fail_if_not_converged boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_geometryfromtext(text) returns geometry
+  language c;
+
+create function public.st_geometryfromtext(text, integer) returns geometry
+  language c;
+
+create function public.st_geometryn(geometry, integer) returns geometry
+  language c;
+
+create function public.st_geometrytype(geometry) returns text
+  language c;
+
+create function public.st_geomfromewkb(bytea) returns geometry
+  language c;
+
+create function public.st_geomfromewkt(text) returns geometry
+  language c;
+
+create function public.st_geomfromgeohash(text, integer DEFAULT NULL::integer) returns geometry
+  language sql;
+
+create function public.st_geomfromgeojson(json) returns geometry
+  language sql;
+
+create function public.st_geomfromgeojson(jsonb) returns geometry
+  language sql;
+
+create function public.st_geomfromgeojson(text) returns geometry
+  language c;
+
+create function public.st_geomfromgml(text) returns geometry
+  language sql;
+
+create function public.st_geomfromgml(text, integer) returns geometry
+  language c;
+
+create function public.st_geomfromkml(text) returns geometry
+  language c;
+
+create function public.st_geomfrommarc21(marc21xml text) returns geometry
+  language c;
+
+create function public.st_geomfromtext(text) returns geometry
+  language c;
+
+create function public.st_geomfromtext(text, integer) returns geometry
+  language c;
+
+create function public.st_geomfromtwkb(bytea) returns geometry
+  language c;
+
+create function public.st_geomfromwkb(bytea) returns geometry
+  language c;
+
+create function public.st_geomfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_gmltosql(text) returns geometry
+  language sql;
+
+create function public.st_gmltosql(text, integer) returns geometry
+  language c;
+
+create function public.st_hasarc(geometry geometry) returns boolean
+  language c;
+
+create function public.st_hasm(geometry) returns boolean
+  language c;
+
+create function public.st_hasz(geometry) returns boolean
+  language c;
+
+create function public.st_hausdorffdistance(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_hausdorffdistance(geom1 geometry, geom2 geometry, double precision) returns double precision
+  language c;
+
+create function public.st_hexagon(size double precision, cell_i integer, cell_j integer, origin geometry DEFAULT '010100000000000000000000000000000000000000'::geometry) returns geometry
+  language c;
+
+create function public.st_hexagongrid(size double precision, bounds geometry, OUT geom geometry, OUT i integer, OUT j integer) returns SETOF record
+  language c;
+
+create function public.st_interiorringn(geometry, integer) returns geometry
+  language c;
+
+create function public.st_interpolatepoint(line geometry, point geometry) returns double precision
+  language c;
+
+create function public.st_intersection(geography, geography) returns geography
+  language sql;
+
+create function public.st_intersection(geom1 geometry, geom2 geometry, gridsize double precision DEFAULT '-1'::integer) returns geometry
+  language c;
+
+create function public.st_intersection(text, text) returns geometry
+  language sql;
+
+create function public.st_intersects(geog1 geography, geog2 geography) returns boolean
+  language c;
+
+create function public.st_intersects(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_intersects(text, text) returns boolean
+  language sql;
+
+create function public.st_inversetransformpipeline(geom geometry, pipeline text, to_srid integer DEFAULT 0) returns geometry
+  language sql;
+
+create function public.st_isclosed(geometry) returns boolean
+  language c;
+
+create function public.st_iscollection(geometry) returns boolean
+  language c;
+
+create function public.st_isempty(geometry) returns boolean
+  language c;
+
+create function public.st_ispolygonccw(geometry) returns boolean
+  language c;
+
+create function public.st_ispolygoncw(geometry) returns boolean
+  language c;
+
+create function public.st_isring(geometry) returns boolean
+  language c;
+
+create function public.st_issimple(geometry) returns boolean
+  language c;
+
+create function public.st_isvalid(geometry) returns boolean
+  language c;
+
+create function public.st_isvalid(geometry, integer) returns boolean
+  language sql;
+
+create function public.st_isvaliddetail(geom geometry, flags integer DEFAULT 0) returns valid_detail
+  language c;
+
+create function public.st_isvalidreason(geometry) returns text
+  language c;
+
+create function public.st_isvalidreason(geometry, integer) returns text
+  language sql;
+
+create function public.st_isvalidtrajectory(geometry) returns boolean
+  language c;
+
+create function public.st_largestemptycircle(geom geometry, tolerance double precision DEFAULT 0.0, boundary geometry DEFAULT '0101000000000000000000F87F000000000000F87F'::geometry, OUT center geometry, OUT nearest geometry, OUT radius double precision) returns record
+  language c;
+
+create function public.st_length(geog geography, use_spheroid boolean DEFAULT true) returns double precision
+  language c;
+
+create function public.st_length(geometry) returns double precision
+  language c;
+
+create function public.st_length(text) returns double precision
+  language sql;
+
+create function public.st_length2d(geometry) returns double precision
+  language c;
+
+create function public.st_length2dspheroid(geometry, spheroid) returns double precision
+  language c;
+
+create function public.st_lengthspheroid(geometry, spheroid) returns double precision
+  language c;
+
+create function public.st_letters(letters text, font json DEFAULT NULL::json) returns geometry
+  language plpgsql;
+
+create function public.st_linecrossingdirection(line1 geometry, line2 geometry) returns integer
+  language c;
+
+create function public.st_lineextend(geom geometry, distance_forward double precision, distance_backward double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_linefromencodedpolyline(txtin text, nprecision integer DEFAULT 5) returns geometry
+  language c;
+
+create function public.st_linefrommultipoint(geometry) returns geometry
+  language c;
+
+create function public.st_linefromtext(text) returns geometry
+  language sql;
+
+create function public.st_linefromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_linefromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_linefromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_lineinterpolatepoint(geography, double precision, use_spheroid boolean DEFAULT true) returns geography
+  language c;
+
+create function public.st_lineinterpolatepoint(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_lineinterpolatepoint(text, double precision) returns geometry
+  language sql;
+
+create function public.st_lineinterpolatepoints(geography, double precision, use_spheroid boolean DEFAULT true, repeat boolean DEFAULT true) returns geography
+  language c;
+
+create function public.st_lineinterpolatepoints(geometry, double precision, repeat boolean DEFAULT true) returns geometry
+  language c;
+
+create function public.st_lineinterpolatepoints(text, double precision) returns geometry
+  language sql;
+
+create function public.st_linelocatepoint(geography, geography, use_spheroid boolean DEFAULT true) returns double precision
+  language c;
+
+create function public.st_linelocatepoint(geom1 geometry, geom2 geometry) returns double precision
+  language c;
+
+create function public.st_linelocatepoint(text, text) returns double precision
+  language sql;
+
+create function public.st_linemerge(geometry) returns geometry
+  language c;
+
+create function public.st_linemerge(geometry, boolean) returns geometry
+  language c;
+
+create function public.st_linestringfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_linestringfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_linesubstring(geography, double precision, double precision) returns geography
+  language c;
+
+create function public.st_linesubstring(geometry, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_linesubstring(text, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_linetocurve(geometry geometry) returns geometry
+  language c;
+
+create function public.st_locatealong(geometry geometry, measure double precision, leftrightoffset double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_locatebetween(geometry geometry, frommeasure double precision, tomeasure double precision, leftrightoffset double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_locatebetweenelevations(geometry geometry, fromelevation double precision, toelevation double precision) returns geometry
+  language c;
+
+create function public.st_longestline(geom1 geometry, geom2 geometry) returns geometry
+  language sql;
+
+create function public.st_m(geometry) returns double precision
+  language c;
+
+create function public.st_makebox2d(geom1 geometry, geom2 geometry) returns box2d
+  language c;
+
+create function public.st_makeenvelope(double precision, double precision, double precision, double precision, integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_makeline(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create aggregate public.st_makeline(geometry) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_makeline_finalfn
+);
+
+create function public.st_makeline(geometry[]) returns geometry
+  language c;
+
+create function public.st_makepoint(double precision, double precision) returns geometry
+  language c;
+
+create function public.st_makepoint(double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_makepoint(double precision, double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_makepointm(double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_makepolygon(geometry) returns geometry
+  language c;
+
+create function public.st_makepolygon(geometry, geometry[]) returns geometry
+  language c;
+
+create function public.st_makevalid(geom geometry, params text) returns geometry
+  language c;
+
+create function public.st_makevalid(geometry) returns geometry
+  language c;
+
+create function public.st_maxdistance(geom1 geometry, geom2 geometry) returns double precision
+  language sql;
+
+create function public.st_maximuminscribedcircle(geometry, OUT center geometry, OUT nearest geometry, OUT radius double precision) returns record
+  language c;
+
+create aggregate public.st_memcollect(geometry) (
+  sfunc = public.st_collect,
+  stype = geometry,
+  combinefunc = public.st_collect
+);
+
+create function public.st_memsize(geometry) returns integer
+  language c;
+
+create aggregate public.st_memunion(geometry) (
+  sfunc = public.st_union,
+  stype = geometry,
+  combinefunc = public.st_union
+);
+
+create function public.st_minimumboundingcircle(inputgeom geometry, segs_per_quarter integer DEFAULT 48) returns geometry
+  language c;
+
+create function public.st_minimumboundingradius(geometry, OUT center geometry, OUT radius double precision) returns record
+  language c;
+
+create function public.st_minimumclearance(geometry) returns double precision
+  language c;
+
+create function public.st_minimumclearanceline(geometry) returns geometry
+  language c;
+
+create function public.st_mlinefromtext(text) returns geometry
+  language sql;
+
+create function public.st_mlinefromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_mlinefromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_mlinefromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_mpointfromtext(text) returns geometry
+  language sql;
+
+create function public.st_mpointfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_mpointfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_mpointfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_mpolyfromtext(text) returns geometry
+  language sql;
+
+create function public.st_mpolyfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_mpolyfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_mpolyfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_multi(geometry) returns geometry
+  language c;
+
+create function public.st_multilinefromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_multilinestringfromtext(text) returns geometry
+  language sql;
+
+create function public.st_multilinestringfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_multipointfromtext(text) returns geometry
+  language sql;
+
+create function public.st_multipointfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_multipointfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_multipolyfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_multipolyfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_multipolygonfromtext(text) returns geometry
+  language sql;
+
+create function public.st_multipolygonfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_ndims(geometry) returns smallint
+  language c;
+
+create function public.st_node(g geometry) returns geometry
+  language c;
+
+create function public.st_normalize(geom geometry) returns geometry
+  language c;
+
+create function public.st_npoints(geometry) returns integer
+  language c;
+
+create function public.st_nrings(geometry) returns integer
+  language c;
+
+create function public.st_numcurves(geometry geometry) returns integer
+  language c;
+
+create function public.st_numgeometries(geometry) returns integer
+  language c;
+
+create function public.st_numinteriorring(geometry) returns integer
+  language c;
+
+create function public.st_numinteriorrings(geometry) returns integer
+  language c;
+
+create function public.st_numpatches(geometry) returns integer
+  language c;
+
+create function public.st_numpoints(geometry) returns integer
+  language c;
+
+create function public.st_offsetcurve(line geometry, distance double precision, params text DEFAULT ''::text) returns geometry
+  language c;
+
+create function public.st_orderingequals(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_orientedenvelope(geometry) returns geometry
+  language c;
+
+create function public.st_overlaps(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_patchn(geometry, integer) returns geometry
+  language c;
+
+create function public.st_perimeter(geog geography, use_spheroid boolean DEFAULT true) returns double precision
+  language c;
+
+create function public.st_perimeter(geometry) returns double precision
+  language c;
+
+create function public.st_perimeter2d(geometry) returns double precision
+  language c;
+
+create function public.st_point(double precision, double precision) returns geometry
+  language c;
+
+create function public.st_point(double precision, double precision, srid integer) returns geometry
+  language c;
+
+create function public.st_pointfromgeohash(text, integer DEFAULT NULL::integer) returns geometry
+  language c;
+
+create function public.st_pointfromtext(text) returns geometry
+  language sql;
+
+create function public.st_pointfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_pointfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_pointfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_pointinsidecircle(geometry, double precision, double precision, double precision) returns boolean
+  language c;
+
+create function public.st_pointm(xcoordinate double precision, ycoordinate double precision, mcoordinate double precision, srid integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_pointn(geometry, integer) returns geometry
+  language c;
+
+create function public.st_pointonsurface(geometry) returns geometry
+  language c;
+
+create function public.st_points(geometry) returns geometry
+  language c;
+
+create function public.st_pointz(xcoordinate double precision, ycoordinate double precision, zcoordinate double precision, srid integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_pointzm(xcoordinate double precision, ycoordinate double precision, zcoordinate double precision, mcoordinate double precision, srid integer DEFAULT 0) returns geometry
+  language c;
+
+create function public.st_polyfromtext(text) returns geometry
+  language sql;
+
+create function public.st_polyfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_polyfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_polyfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create function public.st_polygon(geometry, integer) returns geometry
+  language sql;
+
+create function public.st_polygonfromtext(text) returns geometry
+  language sql;
+
+create function public.st_polygonfromtext(text, integer) returns geometry
+  language sql;
+
+create function public.st_polygonfromwkb(bytea) returns geometry
+  language sql;
+
+create function public.st_polygonfromwkb(bytea, integer) returns geometry
+  language sql;
+
+create aggregate public.st_polygonize(geometry) (
+  sfunc = public.pgis_geometry_accum_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_polygonize_finalfn
+);
+
+create function public.st_polygonize(geometry[]) returns geometry
+  language c;
+
+create function public.st_project(geog geography, distance double precision, azimuth double precision) returns geography
+  language c;
+
+create function public.st_project(geog_from geography, geog_to geography, distance double precision) returns geography
+  language c;
+
+create function public.st_project(geom1 geometry, distance double precision, azimuth double precision) returns geometry
+  language c;
+
+create function public.st_project(geom1 geometry, geom2 geometry, distance double precision) returns geometry
+  language c;
+
+create function public.st_quantizecoordinates(g geometry, prec_x integer, prec_y integer DEFAULT NULL::integer, prec_z integer DEFAULT NULL::integer, prec_m integer DEFAULT NULL::integer) returns geometry
+  language c;
+
+create function public.st_reduceprecision(geom geometry, gridsize double precision) returns geometry
+  language c;
+
+create function public.st_relate(geom1 geometry, geom2 geometry) returns text
+  language c;
+
+create function public.st_relate(geom1 geometry, geom2 geometry, integer) returns text
+  language c;
+
+create function public.st_relate(geom1 geometry, geom2 geometry, text) returns boolean
+  language c;
+
+create function public.st_relatematch(text, text) returns boolean
+  language c;
+
+create function public.st_removeirrelevantpointsforview(geometry, box2d, boolean DEFAULT false) returns geometry
+  language c;
+
+create function public.st_removepoint(geometry, integer) returns geometry
+  language c;
+
+create function public.st_removerepeatedpoints(geom geometry, tolerance double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_removesmallparts(geometry, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_reverse(geometry) returns geometry
+  language c;
+
+create function public.st_rotate(geometry, double precision) returns geometry
+  language sql;
+
+create function public.st_rotate(geometry, double precision, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_rotate(geometry, double precision, geometry) returns geometry
+  language sql;
+
+create function public.st_rotatex(geometry, double precision) returns geometry
+  language sql;
+
+create function public.st_rotatey(geometry, double precision) returns geometry
+  language sql;
+
+create function public.st_rotatez(geometry, double precision) returns geometry
+  language sql;
+
+create function public.st_scale(geometry, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_scale(geometry, double precision, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_scale(geometry, geometry) returns geometry
+  language c;
+
+create function public.st_scale(geometry, geometry, origin geometry) returns geometry
+  language c;
+
+create function public.st_scroll(geometry, geometry) returns geometry
+  language c;
+
+create function public.st_segmentize(geog geography, max_segment_length double precision) returns geography
+  language c;
+
+create function public.st_segmentize(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_seteffectivearea(geometry, double precision DEFAULT '-1'::integer, integer DEFAULT 1) returns geometry
+  language c;
+
+create function public.st_setpoint(geometry, integer, geometry) returns geometry
+  language c;
+
+create function public.st_setsrid(geog geography, srid integer) returns geography
+  language c;
+
+create function public.st_setsrid(geom geometry, srid integer) returns geometry
+  language c;
+
+create function public.st_sharedpaths(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_shiftlongitude(geometry) returns geometry
+  language c;
+
+create function public.st_shortestline(geography, geography, use_spheroid boolean DEFAULT true) returns geography
+  language c;
+
+create function public.st_shortestline(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_shortestline(text, text) returns geometry
+  language sql;
+
+create function public.st_simplify(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_simplify(geometry, double precision, boolean) returns geometry
+  language c;
+
+create function public.st_simplifypolygonhull(geom geometry, vertex_fraction double precision, is_outer boolean DEFAULT true) returns geometry
+  language c;
+
+create function public.st_simplifypreservetopology(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_simplifyvw(geometry, double precision) returns geometry
+  language c;
+
+create function public.st_snap(geom1 geometry, geom2 geometry, double precision) returns geometry
+  language c;
+
+create function public.st_snaptogrid(geom1 geometry, geom2 geometry, double precision, double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_snaptogrid(geometry, double precision) returns geometry
+  language sql;
+
+create function public.st_snaptogrid(geometry, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_snaptogrid(geometry, double precision, double precision, double precision, double precision) returns geometry
+  language c;
+
+create function public.st_split(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_square(size double precision, cell_i integer, cell_j integer, origin geometry DEFAULT '010100000000000000000000000000000000000000'::geometry) returns geometry
+  language c;
+
+create function public.st_squaregrid(size double precision, bounds geometry, OUT geom geometry, OUT i integer, OUT j integer) returns SETOF record
+  language c;
+
+create function public.st_srid(geog geography) returns integer
+  language c;
+
+create function public.st_srid(geom geometry) returns integer
+  language c;
+
+create function public.st_startpoint(geometry) returns geometry
+  language c;
+
+create function public.st_subdivide(geom geometry, maxvertices integer DEFAULT 256, gridsize double precision DEFAULT '-1.0'::numeric) returns SETOF geometry
+  language c;
+
+create function public.st_summary(geography) returns text
+  language c;
+
+create function public.st_summary(geometry) returns text
+  language c;
+
+create function public.st_swapordinates(geom geometry, ords cstring) returns geometry
+  language c;
+
+create function public.st_symdifference(geom1 geometry, geom2 geometry, gridsize double precision DEFAULT '-1.0'::numeric) returns geometry
+  language c;
+
+create function public.st_symmetricdifference(geom1 geometry, geom2 geometry) returns geometry
+  language sql;
+
+create function public.st_tileenvelope(zoom integer, x integer, y integer, bounds geometry DEFAULT '0102000020110F00000200000093107C45F81B73C193107C45F81B73C193107C45F81B734193107C45F81B7341'::geometry, margin double precision DEFAULT 0.0) returns geometry
+  language c;
+
+create function public.st_touches(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_transform(geom geometry, from_proj text, to_proj text) returns geometry
+  language sql;
+
+create function public.st_transform(geom geometry, from_proj text, to_srid integer) returns geometry
+  language sql;
+
+create function public.st_transform(geom geometry, to_proj text) returns geometry
+  language sql;
+
+create function public.st_transform(geometry, integer) returns geometry
+  language c;
+
+create function public.st_transformpipeline(geom geometry, pipeline text, to_srid integer DEFAULT 0) returns geometry
+  language sql;
+
+create function public.st_translate(geometry, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_translate(geometry, double precision, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_transscale(geometry, double precision, double precision, double precision, double precision) returns geometry
+  language sql;
+
+create function public.st_triangulatepolygon(g1 geometry) returns geometry
+  language c;
+
+create function public.st_unaryunion(geometry, gridsize double precision DEFAULT '-1.0'::numeric) returns geometry
+  language c;
+
+create function public.st_union(geom1 geometry, geom2 geometry) returns geometry
+  language c;
+
+create function public.st_union(geom1 geometry, geom2 geometry, gridsize double precision) returns geometry
+  language c;
+
+create aggregate public.st_union(geometry) (
+  sfunc = public.pgis_geometry_union_parallel_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_union_parallel_finalfn,
+  combinefunc = pgis_geometry_union_parallel_combinefn
+);
+
+create aggregate public.st_union(geometry, gridsize double precision) (
+  sfunc = public.pgis_geometry_union_parallel_transfn,
+  stype = internal,
+  finalfunc = pgis_geometry_union_parallel_finalfn,
+  combinefunc = pgis_geometry_union_parallel_combinefn
+);
+
+create function public.st_union(geometry[]) returns geometry
+  language c;
+
+create function public.st_voronoilines(g1 geometry, tolerance double precision DEFAULT 0.0, extend_to geometry DEFAULT NULL::geometry) returns geometry
+  language sql;
+
+create function public.st_voronoipolygons(g1 geometry, tolerance double precision DEFAULT 0.0, extend_to geometry DEFAULT NULL::geometry) returns geometry
+  language sql;
+
+create function public.st_within(geom1 geometry, geom2 geometry) returns boolean
+  language c;
+
+create function public.st_wkbtosql(wkb bytea) returns geometry
+  language c;
+
+create function public.st_wkttosql(text) returns geometry
+  language c;
+
+create function public.st_wrapx(geom geometry, wrap double precision, move double precision) returns geometry
+  language c;
+
+create function public.st_x(geometry) returns double precision
+  language c;
+
+create function public.st_xmax(box3d) returns double precision
+  language c;
+
+create function public.st_xmin(box3d) returns double precision
+  language c;
+
+create function public.st_y(geometry) returns double precision
+  language c;
+
+create function public.st_ymax(box3d) returns double precision
+  language c;
+
+create function public.st_ymin(box3d) returns double precision
+  language c;
+
+create function public.st_z(geometry) returns double precision
+  language c;
+
+create function public.st_zmax(box3d) returns double precision
+  language c;
+
+create function public.st_zmflag(geometry) returns smallint
+  language c;
+
+create function public.st_zmin(box3d) returns double precision
+  language c;
+
+create function public.text(geometry) returns text
+  language c;
+
+create function public.updategeometrysrid(catalogn_name character varying, schema_name character varying, table_name character varying, column_name character varying, new_srid_in integer) returns text
+  language plpgsql;
+
+create function public.updategeometrysrid(character varying, character varying, character varying, integer) returns text
+  language plpgsql;
+
+create function public.updategeometrysrid(character varying, character varying, integer) returns text
+  language plpgsql;
+
+create operator public.&& (
+  leftarg = box2df,
+  rightarg = box2df,
+  function = public.overlaps_2d
+);
+
+create operator public.&& (
+  leftarg = box2df,
+  rightarg = geometry,
+  function = public.overlaps_2d
+);
+
+create operator public.&& (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_overlaps
+);
+
+create operator public.&& (
+  leftarg = geography,
+  rightarg = gidx,
+  function = public.overlaps_geog
+);
+
+create operator public.&& (
+  leftarg = geometry,
+  rightarg = box2df,
+  function = public.overlaps_2d
+);
+
+create operator public.&& (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overlaps
+);
+
+create operator public.&& (
+  leftarg = gidx,
+  rightarg = geography,
+  function = public.overlaps_geog
+);
+
+create operator public.&& (
+  leftarg = gidx,
+  rightarg = gidx,
+  function = public.overlaps_geog
+);
+
+create operator public.&&& (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overlaps_nd
+);
+
+create operator public.&&& (
+  leftarg = geometry,
+  rightarg = gidx,
+  function = public.overlaps_nd
+);
+
+create operator public.&&& (
+  leftarg = gidx,
+  rightarg = geometry,
+  function = public.overlaps_nd
+);
+
+create operator public.&&& (
+  leftarg = gidx,
+  rightarg = gidx,
+  function = public.overlaps_nd
+);
+
+create operator public.&/& (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overlaps_3d
+);
+
+create operator public.&< (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overleft
+);
+
+create operator public.&<| (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overbelow
+);
+
+create operator public.&> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overright
+);
+
+create operator public.< (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_lt
+);
+
+create operator public.< (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_lt
+);
+
+create operator public.<#> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_distance_box
+);
+
+create operator public.<-> (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_distance_knn
+);
+
+create operator public.<-> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_distance_centroid
+);
+
+create operator public.<< (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_left
+);
+
+create operator public.<<->> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_distance_centroid_nd
+);
+
+create operator public.<<@ (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_contained_3d
+);
+
+create operator public.<<| (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_below
+);
+
+create operator public.<= (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_le
+);
+
+create operator public.<= (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_le
+);
+
+create operator public.<> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_neq
+);
+
+create operator public.= (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_eq
+);
+
+create operator public.= (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_eq
+);
+
+create operator public.> (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_gt
+);
+
+create operator public.> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_gt
+);
+
+create operator public.>= (
+  leftarg = geography,
+  rightarg = geography,
+  function = public.geography_ge
+);
+
+create operator public.>= (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_ge
+);
+
+create operator public.>> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_right
+);
+
+create operator public.@ (
+  leftarg = box2df,
+  rightarg = box2df,
+  function = public.is_contained_2d
+);
+
+create operator public.@ (
+  leftarg = box2df,
+  rightarg = geometry,
+  function = public.is_contained_2d
+);
+
+create operator public.@ (
+  leftarg = geometry,
+  rightarg = box2df,
+  function = public.is_contained_2d
+);
+
+create operator public.@ (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_within
+);
+
+create operator public.@>> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_contains_3d
+);
+
+create operator public.@@ (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_within_nd
+);
+
+create operator public.|&> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_overabove
+);
+
+create operator public.|=| (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_distance_cpa
+);
+
+create operator public.|>> (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_above
+);
+
+create operator public.~ (
+  leftarg = box2df,
+  rightarg = box2df,
+  function = public.contains_2d
+);
+
+create operator public.~ (
+  leftarg = box2df,
+  rightarg = geometry,
+  function = public.contains_2d
+);
+
+create operator public.~ (
+  leftarg = geometry,
+  rightarg = box2df,
+  function = public.contains_2d
+);
+
+create operator public.~ (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_contains
+);
+
+create operator public.~= (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_same
+);
+
+create operator public.~== (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_same_3d
+);
+
+create operator public.~~ (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_contains_nd
+);
+
+create operator public.~~= (
+  leftarg = geometry,
+  rightarg = geometry,
+  function = public.geometry_same_nd
+);
+
diff --git a/crates/squawk_ide/src/extensions/postgres_fdw.sql b/crates/squawk_ide/src/extensions/postgres_fdw.sql
new file mode 100644
index 00000000..84dbad9f
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/postgres_fdw.sql
@@ -0,0 +1,20 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+create function public.postgres_fdw_disconnect(text) returns boolean
+  language c;
+
+create function public.postgres_fdw_disconnect_all() returns boolean
+  language c;
+
+create function public.postgres_fdw_get_connections(check_conn boolean DEFAULT false, OUT server_name text, OUT user_name text, OUT valid boolean, OUT used_in_xact boolean, OUT closed boolean, OUT remote_backend_pid integer) returns SETOF record
+  language c;
+
+create function public.postgres_fdw_handler() returns fdw_handler
+  language c;
+
+create function public.postgres_fdw_validator(text[], oid) returns void
+  language c;
+
diff --git a/crates/squawk_ide/src/extensions/vector.sql b/crates/squawk_ide/src/extensions/vector.sql
new file mode 100644
index 00000000..4c092a12
--- /dev/null
+++ b/crates/squawk_ide/src/extensions/vector.sql
@@ -0,0 +1,624 @@
+-- squawk-ignore-file
+-- pg version: 18.2
+-- update via:
+--   cargo xtask sync-builtins
+
+-- size: -1, align: 4
+create type public.halfvec;
+
+-- size: -1, align: 4
+create type public.sparsevec;
+
+-- size: -1, align: 4
+create type public.vector;
+
+create function public.array_to_halfvec(double precision[], integer, boolean) returns halfvec
+  language c;
+
+create function public.array_to_halfvec(integer[], integer, boolean) returns halfvec
+  language c;
+
+create function public.array_to_halfvec(numeric[], integer, boolean) returns halfvec
+  language c;
+
+create function public.array_to_halfvec(real[], integer, boolean) returns halfvec
+  language c;
+
+create function public.array_to_sparsevec(double precision[], integer, boolean) returns sparsevec
+  language c;
+
+create function public.array_to_sparsevec(integer[], integer, boolean) returns sparsevec
+  language c;
+
+create function public.array_to_sparsevec(numeric[], integer, boolean) returns sparsevec
+  language c;
+
+create function public.array_to_sparsevec(real[], integer, boolean) returns sparsevec
+  language c;
+
+create function public.array_to_vector(double precision[], integer, boolean) returns vector
+  language c;
+
+create function public.array_to_vector(integer[], integer, boolean) returns vector
+  language c;
+
+create function public.array_to_vector(numeric[], integer, boolean) returns vector
+  language c;
+
+create function public.array_to_vector(real[], integer, boolean) returns vector
+  language c;
+
+create aggregate public.avg(halfvec) (
+  sfunc = halfvec_accum,
+  stype = double precision[],
+  finalfunc = halfvec_avg,
+  combinefunc = halfvec_combine,
+  initcond = '{0}'
+);
+
+create aggregate public.avg(vector) (
+  sfunc = vector_accum,
+  stype = double precision[],
+  finalfunc = vector_avg,
+  combinefunc = vector_combine,
+  initcond = '{0}'
+);
+
+create function public.binary_quantize(halfvec) returns bit
+  language c;
+
+create function public.binary_quantize(vector) returns bit
+  language c;
+
+create function public.cosine_distance(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.cosine_distance(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.cosine_distance(vector, vector) returns double precision
+  language c;
+
+create function public.halfvec(halfvec, integer, boolean) returns halfvec
+  language c;
+
+create function public.halfvec_accum(double precision[], halfvec) returns double precision[]
+  language c;
+
+create function public.halfvec_add(halfvec, halfvec) returns halfvec
+  language c;
+
+create function public.halfvec_avg(double precision[]) returns halfvec
+  language c;
+
+create function public.halfvec_cmp(halfvec, halfvec) returns integer
+  language c;
+
+create function public.halfvec_combine(double precision[], double precision[]) returns double precision[]
+  language c;
+
+create function public.halfvec_concat(halfvec, halfvec) returns halfvec
+  language c;
+
+create function public.halfvec_eq(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_ge(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_gt(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_in(cstring, oid, integer) returns halfvec
+  language c;
+
+create function public.halfvec_l2_squared_distance(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.halfvec_le(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_lt(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_mul(halfvec, halfvec) returns halfvec
+  language c;
+
+create function public.halfvec_ne(halfvec, halfvec) returns boolean
+  language c;
+
+create function public.halfvec_negative_inner_product(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.halfvec_out(halfvec) returns cstring
+  language c;
+
+create function public.halfvec_recv(internal, oid, integer) returns halfvec
+  language c;
+
+create function public.halfvec_send(halfvec) returns bytea
+  language c;
+
+create function public.halfvec_spherical_distance(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.halfvec_sub(halfvec, halfvec) returns halfvec
+  language c;
+
+create function public.halfvec_to_float4(halfvec, integer, boolean) returns real[]
+  language c;
+
+create function public.halfvec_to_sparsevec(halfvec, integer, boolean) returns sparsevec
+  language c;
+
+create function public.halfvec_to_vector(halfvec, integer, boolean) returns vector
+  language c;
+
+create function public.halfvec_typmod_in(cstring[]) returns integer
+  language c;
+
+create function public.hamming_distance(bit, bit) returns double precision
+  language c;
+
+create function public.hnsw_bit_support(internal) returns internal
+  language c;
+
+create function public.hnsw_halfvec_support(internal) returns internal
+  language c;
+
+create function public.hnsw_sparsevec_support(internal) returns internal
+  language c;
+
+create function public.hnswhandler(internal) returns index_am_handler
+  language c;
+
+create function public.inner_product(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.inner_product(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.inner_product(vector, vector) returns double precision
+  language c;
+
+create function public.ivfflat_bit_support(internal) returns internal
+  language c;
+
+create function public.ivfflat_halfvec_support(internal) returns internal
+  language c;
+
+create function public.ivfflathandler(internal) returns index_am_handler
+  language c;
+
+create function public.jaccard_distance(bit, bit) returns double precision
+  language c;
+
+create function public.l1_distance(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.l1_distance(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.l1_distance(vector, vector) returns double precision
+  language c;
+
+create function public.l2_distance(halfvec, halfvec) returns double precision
+  language c;
+
+create function public.l2_distance(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.l2_distance(vector, vector) returns double precision
+  language c;
+
+create function public.l2_norm(halfvec) returns double precision
+  language c;
+
+create function public.l2_norm(sparsevec) returns double precision
+  language c;
+
+create function public.l2_normalize(halfvec) returns halfvec
+  language c;
+
+create function public.l2_normalize(sparsevec) returns sparsevec
+  language c;
+
+create function public.l2_normalize(vector) returns vector
+  language c;
+
+create function public.sparsevec(sparsevec, integer, boolean) returns sparsevec
+  language c;
+
+create function public.sparsevec_cmp(sparsevec, sparsevec) returns integer
+  language c;
+
+create function public.sparsevec_eq(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_ge(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_gt(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_in(cstring, oid, integer) returns sparsevec
+  language c;
+
+create function public.sparsevec_l2_squared_distance(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.sparsevec_le(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_lt(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_ne(sparsevec, sparsevec) returns boolean
+  language c;
+
+create function public.sparsevec_negative_inner_product(sparsevec, sparsevec) returns double precision
+  language c;
+
+create function public.sparsevec_out(sparsevec) returns cstring
+  language c;
+
+create function public.sparsevec_recv(internal, oid, integer) returns sparsevec
+  language c;
+
+create function public.sparsevec_send(sparsevec) returns bytea
+  language c;
+
+create function public.sparsevec_to_halfvec(sparsevec, integer, boolean) returns halfvec
+  language c;
+
+create function public.sparsevec_to_vector(sparsevec, integer, boolean) returns vector
+  language c;
+
+create function public.sparsevec_typmod_in(cstring[]) returns integer
+  language c;
+
+create function public.subvector(halfvec, integer, integer) returns halfvec
+  language c;
+
+create function public.subvector(vector, integer, integer) returns vector
+  language c;
+
+create aggregate public.sum(halfvec) (
+  sfunc = halfvec_add,
+  stype = halfvec,
+  combinefunc = halfvec_add
+);
+
+create aggregate public.sum(vector) (
+  sfunc = vector_add,
+  stype = vector,
+  combinefunc = vector_add
+);
+
+create function public.vector(vector, integer, boolean) returns vector
+  language c;
+
+create function public.vector_accum(double precision[], vector) returns double precision[]
+  language c;
+
+create function public.vector_add(vector, vector) returns vector
+  language c;
+
+create function public.vector_avg(double precision[]) returns vector
+  language c;
+
+create function public.vector_cmp(vector, vector) returns integer
+  language c;
+
+create function public.vector_combine(double precision[], double precision[]) returns double precision[]
+  language c;
+
+create function public.vector_concat(vector, vector) returns vector
+  language c;
+
+create function public.vector_dims(halfvec) returns integer
+  language c;
+
+create function public.vector_dims(vector) returns integer
+  language c;
+
+create function public.vector_eq(vector, vector) returns boolean
+  language c;
+
+create function public.vector_ge(vector, vector) returns boolean
+  language c;
+
+create function public.vector_gt(vector, vector) returns boolean
+  language c;
+
+create function public.vector_in(cstring, oid, integer) returns vector
+  language c;
+
+create function public.vector_l2_squared_distance(vector, vector) returns double precision
+  language c;
+
+create function public.vector_le(vector, vector) returns boolean
+  language c;
+
+create function public.vector_lt(vector, vector) returns boolean
+  language c;
+
+create function public.vector_mul(vector, vector) returns vector
+  language c;
+
+create function public.vector_ne(vector, vector) returns boolean
+  language c;
+
+create function public.vector_negative_inner_product(vector, vector) returns double precision
+  language c;
+
+create function public.vector_norm(vector) returns double precision
+  language c;
+
+create function public.vector_out(vector) returns cstring
+  language c;
+
+create function public.vector_recv(internal, oid, integer) returns vector
+  language c;
+
+create function public.vector_send(vector) returns bytea
+  language c;
+
+create function public.vector_spherical_distance(vector, vector) returns double precision
+  language c;
+
+create function public.vector_sub(vector, vector) returns vector
+  language c;
+
+create function public.vector_to_float4(vector, integer, boolean) returns real[]
+  language c;
+
+create function public.vector_to_halfvec(vector, integer, boolean) returns halfvec
+  language c;
+
+create function public.vector_to_sparsevec(vector, integer, boolean) returns sparsevec
+  language c;
+
+create function public.vector_typmod_in(cstring[]) returns integer
+  language c;
+
+create operator public.* (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_mul
+);
+
+create operator public.* (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_mul
+);
+
+create operator public.+ (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_add
+);
+
+create operator public.+ (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_add
+);
+
+create operator public.- (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_sub
+);
+
+create operator public.- (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_sub
+);
+
+create operator public.< (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_lt
+);
+
+create operator public.< (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_lt
+);
+
+create operator public.< (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_lt
+);
+
+create operator public.<#> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_negative_inner_product
+);
+
+create operator public.<#> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_negative_inner_product
+);
+
+create operator public.<#> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_negative_inner_product
+);
+
+create operator public.<%> (
+  leftarg = bit,
+  rightarg = bit,
+  function = public.jaccard_distance
+);
+
+create operator public.<+> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.l1_distance
+);
+
+create operator public.<+> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.l1_distance
+);
+
+create operator public.<+> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.l1_distance
+);
+
+create operator public.<-> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.l2_distance
+);
+
+create operator public.<-> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.l2_distance
+);
+
+create operator public.<-> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.l2_distance
+);
+
+create operator public.<= (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_le
+);
+
+create operator public.<= (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_le
+);
+
+create operator public.<= (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_le
+);
+
+create operator public.<=> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.cosine_distance
+);
+
+create operator public.<=> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.cosine_distance
+);
+
+create operator public.<=> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.cosine_distance
+);
+
+create operator public.<> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_ne
+);
+
+create operator public.<> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_ne
+);
+
+create operator public.<> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_ne
+);
+
+create operator public.<~> (
+  leftarg = bit,
+  rightarg = bit,
+  function = public.hamming_distance
+);
+
+create operator public.= (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_eq
+);
+
+create operator public.= (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_eq
+);
+
+create operator public.= (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_eq
+);
+
+create operator public.> (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_gt
+);
+
+create operator public.> (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_gt
+);
+
+create operator public.> (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_gt
+);
+
+create operator public.>= (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_ge
+);
+
+create operator public.>= (
+  leftarg = sparsevec,
+  rightarg = sparsevec,
+  function = public.sparsevec_ge
+);
+
+create operator public.>= (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_ge
+);
+
+create operator public.|| (
+  leftarg = halfvec,
+  rightarg = halfvec,
+  function = public.halfvec_concat
+);
+
+create operator public.|| (
+  leftarg = vector,
+  rightarg = vector,
+  function = public.vector_concat
+);
+
diff --git a/crates/squawk_server/src/lib.rs b/crates/squawk_server/src/lib.rs
index 32742a2e..f9673a3f 100644
--- a/crates/squawk_server/src/lib.rs
+++ b/crates/squawk_server/src/lib.rs
@@ -246,22 +246,7 @@ fn handle_goto_definition(
                 !location.range.contains(offset),
                 "Our target destination range must not include the source range otherwise go to def won't work in vscode."
             );
-
-            let uri = match location.file {
-                squawk_ide::goto_definition::FileId::Current => uri.clone(),
-                squawk_ide::goto_definition::FileId::Builtins => builtins_url(db)?,
-            };
-
-            let line_index = match location.file {
-                squawk_ide::goto_definition::FileId::Current => &line_index,
-                squawk_ide::goto_definition::FileId::Builtins => &builtins_line_index(db),
-            };
-            let range = lsp_utils::range(line_index, location.range);
-
-            Some(Location {
-                uri,
-                range,
-            })
+            to_location(db, file_system, &uri, location)
         })
         .collect();
 
@@ -523,6 +508,25 @@ fn handle_selection_range(
     Ok(())
 }
 
+fn to_location(
+    db: &dyn salsa::Database,
+    file_system: &impl FileSystem,
+    uri: &Url,
+    loc: squawk_ide::goto_definition::Location,
+) -> Option<Location> {
+    let file = file_system.file(uri).unwrap();
+    let uri = match loc.file {
+        squawk_ide::goto_definition::FileId::Current => uri.clone(),
+        squawk_ide::goto_definition::FileId::Builtins => builtins_url(db)?,
+    };
+    let line_index = match loc.file {
+        squawk_ide::goto_definition::FileId::Current => &line_index(db, file),
+        squawk_ide::goto_definition::FileId::Builtins => &builtins_line_index(db),
+    };
+    let range = lsp_utils::range(line_index, loc.range);
+    Some(Location { uri, range })
+}
+
 fn handle_references(
     connection: &Connection,
     req: lsp_server::Request,
@@ -543,20 +547,7 @@ fn handle_references(
     let locations: Vec<Location> = refs
         .into_iter()
         .filter(|loc| include_declaration || !loc.range.contains(offset))
-        .filter_map(|loc| {
-            let uri = match loc.file {
-                squawk_ide::goto_definition::FileId::Current => uri.clone(),
-                squawk_ide::goto_definition::FileId::Builtins => builtins_url(db)?,
-            };
-            let line_index = match loc.file {
-                squawk_ide::goto_definition::FileId::Current => &line_index,
-                squawk_ide::goto_definition::FileId::Builtins => &builtins_line_index(db),
-            };
-            Some(Location {
-                uri,
-                range: lsp_utils::range(line_index, loc.range),
-            })
-        })
+        .filter_map(|loc| to_location(db, file_system, &uri, loc))
         .collect();
 
     let resp = Response {
diff --git a/crates/xtask/src/sync_builtins.rs b/crates/xtask/src/sync_builtins.rs
index 53a166d2..a2699c61 100644
--- a/crates/xtask/src/sync_builtins.rs
+++ b/crates/xtask/src/sync_builtins.rs
@@ -1,69 +1,92 @@
+use std::collections::BTreeMap;
+use std::fs::File;
+use std::io::{self, BufWriter, Write};
+use std::path::Path;
 use std::process::{Command, Stdio};
 
 use anyhow::{Context, Result, bail};
+use serde::Deserialize;
 
 use crate::path::project_root;
 
-const BUILTIN_SCHEMAS_QUERY: &str = r"
-select n.nspname, coalesce(d.description, '')
+const PG_TEMP_SCHEMA_SQL: &str = "create schema pg_temp;\n\n";
+
+const SCHEMAS_QUERY: &str = r"
+select
+  n.nspname,
+  coalesce(d.description, ''),
+  coalesce(ext.extname, 'builtins') as extension_name
 from pg_namespace n
   left join pg_description d on d.objoid = n.oid and d.classoid = 'pg_namespace'::regclass
+  left join pg_depend dep on dep.classid = 'pg_namespace'::regclass and dep.objid = n.oid and dep.objsubid = 0 and dep.deptype = 'e'
+  left join pg_extension ext on ext.oid = dep.refobjid
 where n.nspname not like 'pg_temp%'
   and n.nspname not like 'pg_toast%'
-order by n.nspname;
-";
-
-const BUILTIN_TYPES_QUERY: &str = r"
-select n.nspname, t.typname, t.typlen, case t.typalign
-    when 'c' then 1
-    when 's' then 2
-    when 'i' then 4
-    when 'd' then 8
-  end as typalign, coalesce(d.description, '')
-from pg_type t
-  join pg_namespace n on n.oid = t.typnamespace
-  left join pg_description d on d.objoid = t.oid and d.classoid = 'pg_type'::regclass
-where n.nspname not like 'pg_temp%'
-  and n.nspname not like 'pg_toast%'
-  and n.nspname != 'public'
-  and t.typtype in ('b', 'p', 'd', 'e')
-  and t.typname not like '\_%'
-order by n.nspname, t.typname;
+order by n.nspname, ext.extname, n.oid;
 ";
 
-const BUILTIN_RANGE_TYPES_QUERY: &str = r"
-select n.nspname, t.typname, t.typlen, case t.typalign
+const TYPES_QUERY: &str = r"
+select
+  n.nspname,
+  t.typname,
+  t.typlen,
+  case t.typalign
     when 'c' then 1
     when 's' then 2
     when 'i' then 4
     when 'd' then 8
-  end as typalign, format_type(r.rngsubtype, null) as subtype, coalesce(d.description, '')
+  end as typalign,
+  coalesce(format_type(r.rngsubtype, null), '') as subtype,
+  case when r.rngtypid is null then 0 else 1 end as is_range,
+  coalesce(d.description, ''),
+  coalesce(ext.extname, 'builtins') as extension_name
 from pg_type t
   join pg_namespace n on n.oid = t.typnamespace
-  join pg_range r on r.rngtypid = t.oid
+  left join pg_range r on r.rngtypid = t.oid
   left join pg_description d on d.objoid = t.oid and d.classoid = 'pg_type'::regclass
+  left join pg_depend dep on dep.classid = 'pg_type'::regclass and dep.objid = t.oid and dep.objsubid = 0 and dep.deptype = 'e'
+  left join pg_extension ext on ext.oid = dep.refobjid
 where n.nspname not like 'pg_temp%'
   and n.nspname not like 'pg_toast%'
-  and n.nspname != 'public'
-order by n.nspname, t.typname;
+  and (n.nspname != 'public' or ext.extname is not null)
+  and (
+    r.rngtypid is not null
+    or (t.typtype in ('b', 'p', 'd', 'e') and t.typname not like '\_%')
+  )
+order by n.nspname, t.typname, t.oid;
 ";
 
-const BUILTIN_TABLES_QUERY: &str = r"
-select n.nspname, c.relname, c.relkind, a.attname, format_type(a.atttypid, a.atttypmod) as type, coalesce(d.description, '')
+const TABLES_QUERY: &str = r"
+select
+  n.nspname,
+  c.relname,
+  c.relkind,
+  coalesce(d.description, ''),
+  coalesce(ext.extname, 'builtins') as extension_name,
+  json_agg(
+    json_build_object(
+      'name', a.attname,
+      'data_type', format_type(a.atttypid, a.atttypmod)
+    )
+    order by a.attnum
+  ) as columns
 from pg_class c
   join pg_namespace n on n.oid = c.relnamespace
   join pg_attribute a on a.attrelid = c.oid
   left join pg_description d on d.objoid = c.oid and d.classoid = 'pg_class'::regclass and d.objsubid = 0
+  left join pg_depend dep on dep.classid = 'pg_class'::regclass and dep.objid = c.oid and dep.objsubid = 0 and dep.deptype = 'e'
+  left join pg_extension ext on ext.oid = dep.refobjid
 where n.nspname not like 'pg_temp%'
   and n.nspname not like 'pg_toast%'
-  and n.nspname != 'public'
+  and (n.nspname != 'public' or ext.extname is not null)
   and c.relkind in ('r', 'v')
   and a.attnum > 0
   and not a.attisdropped
-order by n.nspname, c.relname, a.attnum;
+group by c.oid, n.nspname, c.relname, c.relkind, coalesce(d.description, ''), coalesce(ext.extname, 'builtins')
+order by n.nspname, c.relname, c.oid;
 ";
 
-const BUILTIN_FUNCTIONS_QUERY: &str = r"
+const FUNCTIONS_QUERY: &str = r"
 select
   n.nspname,
   p.proname,
@@ -76,122 +99,372 @@ select
   format_type(a.aggtranstype, null) as trans_type,
   a.aggfinalfn::regproc::text as final_fn,
   a.aggcombinefn::regproc::text as combine_fn,
-  coalesce(quote_literal(a.agginitval), '') as init_val
+  coalesce(quote_literal(a.agginitval), '') as init_val,
+  coalesce(ext.extname, 'builtins') as extension_name
 from pg_proc p
   join pg_namespace n on n.oid = p.pronamespace
   join pg_language l on l.oid = p.prolang
   left join pg_description d on d.objoid = p.oid and d.classoid = 'pg_proc'::regclass
   left join pg_aggregate a on a.aggfnoid = p.oid
+  left join pg_depend dep on dep.classid = 'pg_proc'::regclass and dep.objid = p.oid and dep.objsubid = 0 and dep.deptype = 'e'
+  left join pg_extension ext on ext.oid = dep.refobjid
 where n.nspname not like 'pg_temp%'
   and n.nspname not like 'pg_toast%'
-  and n.nspname != 'public'
+  and (n.nspname != 'public' or ext.extname is not null)
   and pg_get_function_arguments(p.oid) not like '%ORDER BY%'
-order by 1, 2, 3, 4;
+order by n.nspname, p.proname, pg_get_function_arguments(p.oid), pg_get_function_result(p.oid), p.oid;
 ";
 
-const BUILTIN_OPERATORS_QUERY: &str = r"
-select n.nspname, o.oprname,
+const OPERATORS_QUERY: &str = r"
+select
+  n.nspname,
+  o.oprname,
   format_type(o.oprleft, null) as left_type,
   format_type(o.oprright, null) as right_type,
   pn.nspname as func_schema,
   p.proname as func_name,
-  coalesce(d.description, '')
+  coalesce(d.description, ''),
+  coalesce(ext.extname, 'builtins') as extension_name
 from pg_operator o
   join pg_namespace n on n.oid = o.oprnamespace
   join pg_proc p on p.oid = o.oprcode
   join pg_namespace pn on pn.oid = p.pronamespace
   left join pg_description d on d.objoid = o.oid and d.classoid = 'pg_operator'::regclass
+  left join pg_depend dep on dep.classid = 'pg_operator'::regclass and dep.objid = o.oid and dep.objsubid = 0 and dep.deptype = 'e'
+  left join pg_extension ext on ext.oid = dep.refobjid
 where n.nspname not like 'pg_temp%'
   and n.nspname not like 'pg_toast%'
-  and n.nspname != 'public'
-order by n.nspname, o.oprname;
+  and (n.nspname != 'public' or ext.extname is not null)
+order by n.nspname, o.oprname, format_type(o.oprleft, null), format_type(o.oprright, null), pn.nspname, p.proname, o.oid;
 ";
 
 const PG_VERSION_QUERY: &str = "show server_version;";
 
-fn write_table(
-    sql: &mut String,
-    schema: &str,
-    table_name: &str,
-    description: &str,
-    columns: &[(String, String)],
-) {
+const CREATE_EXTENSIONS_QUERY: &str = r"
+do $$
+declare
+  extension_name text;
+begin
+  foreach extension_name in array array[
+    'bloom',
+    'citext',
+    'cube',
+    'hstore',
+    'isn',
+    'ltree',
+    'pg_stat_statements',
+    'pg_trgm',
+    'pgcrypto',
+    'plpgsql',
+    'postgis',
+    'postgres_fdw',
+    'vector'
+  ] loop
+    execute format('create extension if not exists %I', extension_name);
+  end loop;
+end $$;
+";
+
+fn write_description<W: Write>(f: &mut W, description: &str) -> io::Result<()> {
     if !description.is_empty() {
-        sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
+        writeln!(f, "-- {}", description.replace('\n', "\n-- "))?;
     }
-    sql.push_str(&format!("create table {schema}.{table_name} (\n"));
-    for (i, (col_name, col_type)) in columns.iter().enumerate() {
-        let comma = if i + 1 < columns.len() { "," } else { "" };
-        sql.push_str(&format!("  {col_name} {col_type}{comma}\n"));
+
+    Ok(())
+}
+
+trait WriteSql {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()>;
+}
+
+#[derive(Clone, Deserialize)]
+struct Column {
+    name: String,
+    data_type: String,
+}
+
+struct SchemaDef {
+    schema: String,
+    description: String,
+}
+
+impl WriteSql for SchemaDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(f, "create schema {};", self.schema)?;
+        writeln!(f)?;
+        Ok(())
     }
-    sql.push_str(");\n\n");
 }
 
-fn write_view(
-    sql: &mut String,
-    schema: &str,
-    view_name: &str,
-    description: &str,
-    columns: &[(String, String)],
-) {
-    if !description.is_empty() {
-        sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
+struct TypeDef {
+    schema: String,
+    name: String,
+    size: String,
+    align: String,
+    description: String,
+}
+
+impl WriteSql for TypeDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(f, "-- size: {}, align: {}", self.size, self.align)?;
+        writeln!(f, "create type {}.{};", self.schema, self.name)?;
+        writeln!(f)?;
+        Ok(())
+    }
+}
+
+struct RangeTypeDef {
+    schema: String,
+    name: String,
+    size: String,
+    align: String,
+    subtype: String,
+    description: String,
+}
+
+impl WriteSql for RangeTypeDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(f, "-- size: {}, align: {}", self.size, self.align)?;
+        writeln!(
+            f,
+            "create type {}.{} as range (subtype = {});",
+            self.schema, self.name, self.subtype
+        )?;
+        writeln!(f)?;
+        Ok(())
     }
-    let col_names: Vec<_> = columns.iter().map(|(name, _)| name.as_str()).collect();
-    sql.push_str(&format!(
-        "create view {schema}.{view_name}({}) as\n  select\n",
-        col_names.join(", ")
-    ));
-    for (i, (_, col_type)) in columns.iter().enumerate() {
-        let comma = if i + 1 < columns.len() { "," } else { "" };
-        sql.push_str(&format!("    null::{col_type}{comma}\n"));
+}
+
+struct TableDef {
+    schema: String,
+    name: String,
+    description: String,
+    columns: Vec<Column>,
+}
+
+impl WriteSql for TableDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(f, "create table {}.{} (", self.schema, self.name)?;
+        for (index, column) in self.columns.iter().enumerate() {
+            let comma = if index + 1 < self.columns.len() {
+                ","
+            } else {
+                ""
+            };
+            writeln!(f, "  {} {}{comma}", column.name, column.data_type)?;
+        }
+        writeln!(f, ");")?;
+        writeln!(f)?;
+        Ok(())
     }
-    sql.push_str(";\n\n");
-}
-
-fn write_function(
-    sql: &mut String,
-    schema: &str,
-    func_name: &str,
-    args: &str,
-    result: &str,
-    language: &str,
-) {
-    sql.push_str(&format!(
-        "create function {schema}.{func_name}({args}) returns {result}\n  language {language};\n\n"
-    ));
-}
-
-fn write_aggregate(
-    sql: &mut String,
-    schema: &str,
-    aggregate_name: &str,
-    args: &str,
-    trans_fn: &str,
-    trans_type: &str,
-    final_fn: &str,
-    combine_fn: &str,
-    init_val: &str,
-) {
-    let args = if args.is_empty() { "*" } else { args };
-
-    sql.push_str(&format!(
-        "create aggregate {schema}.{aggregate_name}({args}) (\n  sfunc = {trans_fn},\n  stype = {trans_type}"
-    ));
-
-    if final_fn != "-" {
-        sql.push_str(&format!(",\n  finalfunc = {final_fn}"));
+}
+
+struct ViewDef {
+    schema: String,
+    name: String,
+    description: String,
+    columns: Vec<Column>,
+}
+
+impl WriteSql for ViewDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        let col_names: Vec<_> = self
+            .columns
+            .iter()
+            .map(|column| column.name.as_str())
+            .collect();
+        writeln!(
+            f,
+            "create view {}.{}({}) as",
+            self.schema,
+            self.name,
+            col_names.join(", ")
+        )?;
+        writeln!(f, "  select")?;
+        for (index, column) in self.columns.iter().enumerate() {
+            let comma = if index + 1 < self.columns.len() {
+                ","
+            } else {
+                ""
+            };
+            writeln!(f, "    null::{}{comma}", column.data_type)?;
+        }
+        writeln!(f, ";")?;
+        writeln!(f)?;
+        Ok(())
     }
+}
+
+struct RegularFunctionDef {
+    schema: String,
+    name: String,
+    args: String,
+    result: String,
+    language: String,
+    description: String,
+}
 
-    if combine_fn != "-" {
-        sql.push_str(&format!(",\n  combinefunc = {combine_fn}"));
+impl WriteSql for RegularFunctionDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(
+            f,
+            "create function {}.{}({}) returns {}",
+            self.schema, self.name, self.args, self.result
+        )?;
+        writeln!(f, "  language {};", self.language)?;
+        writeln!(f)?;
+        Ok(())
     }
+}
+
+struct AggregateDef {
+    schema: String,
+    name: String,
+    args: String,
+    trans_fn: String,
+    trans_type: String,
+    final_fn: String,
+    combine_fn: String,
+    init_val: String,
+    description: String,
+}
+
+impl WriteSql for AggregateDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+
+        let args = if self.args.is_empty() {
+            "*"
+        } else {
+            self.args.as_str()
+        };
+
+        writeln!(
+            f,
+            "create aggregate {}.{}({}) (",
+            self.schema, self.name, args
+        )?;
+        writeln!(f, "  sfunc = {},", self.trans_fn)?;
+        write!(f, "  stype = {}", self.trans_type)?;
 
-    if !init_val.is_empty() {
-        sql.push_str(&format!(",\n  initcond = {init_val}"));
+        if self.final_fn != "-" {
+            write!(f, ",\n  finalfunc = {}", self.final_fn)?;
+        }
+
+        if self.combine_fn != "-" {
+            write!(f, ",\n  combinefunc = {}", self.combine_fn)?;
+        }
+
+        if !self.init_val.is_empty() {
+            write!(f, ",\n  initcond = {}", self.init_val)?;
+        }
+
+        write!(f, "\n);\n\n")?;
+
+        Ok(())
     }
+}
+
+enum FunctionDef {
+    Aggregate(AggregateDef),
+    Regular(RegularFunctionDef),
+}
+
+impl WriteSql for FunctionDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        match self {
+            FunctionDef::Aggregate(aggregate) => aggregate.write_sql(f),
+            FunctionDef::Regular(function) => function.write_sql(f),
+        }
+    }
+}
+
+struct OperatorDef {
+    schema: String,
+    name: String,
+    left_type: String,
+    right_type: String,
+    function_schema: String,
+    function_name: String,
+    description: String,
+}
+
+impl WriteSql for OperatorDef {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        write_description(f, &self.description)?;
+        writeln!(f, "create operator {}.{} (", self.schema, self.name)?;
+        let args = match (self.left_type.as_str(), self.right_type.as_str()) {
+            ("-", right_type) => format!("  rightarg = {right_type},"),
+            (left_type, "-") => format!("  leftarg = {left_type},"),
+            (left_type, right_type) => {
+                format!("  leftarg = {left_type},\n  rightarg = {right_type},")
+            }
+        };
+        writeln!(f, "{args}")?;
+        writeln!(
+            f,
+            "  function = {}.{}",
+            self.function_schema, self.function_name
+        )?;
+        writeln!(f, ");")?;
+        writeln!(f)?;
+
+        Ok(())
+    }
+}
 
-    sql.push_str("\n);\n\n");
+// Module / File / Extension
+//
+// General either the builtins or an extension's defs
+#[derive(Default)]
+struct Module {
+    schemas: Vec<SchemaDef>,
+    types: Vec<TypeDef>,
+    range_types: Vec<RangeTypeDef>,
+    tables: Vec<TableDef>,
+    views: Vec<ViewDef>,
+    functions: Vec<FunctionDef>,
+    operators: Vec<OperatorDef>,
+}
+
+impl Module {
+    fn write_sql<W: Write>(&self, f: &mut W) -> io::Result<()> {
+        for schema in &self.schemas {
+            schema.write_sql(f)?;
+        }
+
+        for type_def in &self.types {
+            type_def.write_sql(f)?;
+        }
+
+        for range_type in &self.range_types {
+            range_type.write_sql(f)?;
+        }
+
+        for table in &self.tables {
+            table.write_sql(f)?;
+        }
+
+        for view in &self.views {
+            view.write_sql(f)?;
+        }
+
+        for function in &self.functions {
+            function.write_sql(f)?;
+        }
+
+        for operator in &self.operators {
+            operator.write_sql(f)?;
+        }
+
+        Ok(())
+    }
 }
 
 fn run_sql(query: &str) -> Result<String> {
@@ -217,14 +490,13 @@ fn run_sql(query: &str) -> Result<String> {
     String::from_utf8(output.stdout).context("Invalid utf8")
 }
 
-pub(crate) fn sync_builtins() -> Result<()> {
-    let version = run_sql(PG_VERSION_QUERY)?;
-    let version = version
-        .split_whitespace()
-        .next()
-        .context("version not found")?;
+fn create_extensions_if_missing() -> Result<()> {
+    run_sql(CREATE_EXTENSIONS_QUERY)?;
+    Ok(())
+}
 
-    let mut sql = format!(
+fn header(version: &str) -> String {
+    format!(
         "\
 -- squawk-ignore-file
 -- pg version: {version}
@@ -232,23 +504,48 @@ pub(crate) fn sync_builtins() -> Result<()> {
 --   cargo xtask sync-builtins
 
 "
-    );
+    )
+}
+
+fn write_module(
+    path: impl AsRef<Path>,
+    version: &str,
+    prefix: &str,
+    module: &Module,
+) -> Result<()> {
+    let file = File::create(path)?;
+    let mut writer = BufWriter::new(file);
+    write!(writer, "{}{}", header(version), prefix)?;
+    module.write_sql(&mut writer)?;
+    writer.flush()?;
 
-    for line in run_sql(BUILTIN_SCHEMAS_QUERY)?
+    Ok(())
+}
+
+fn query_schemas(modules: &mut BTreeMap<String, Module>) -> Result<()> {
+    for line in run_sql(SCHEMAS_QUERY)?
         .lines()
         .filter(|line| !line.is_empty())
     {
         let mut parts = line.split('\t');
         let schema = parts.next().context("expected schema name")?;
         let description = parts.next().context("expected schema description")?;
-        if !description.is_empty() {
-            sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
-        }
-        sql.push_str(&format!("create schema {schema};\n\n"));
+        let extension_name = parts.next().context("expected extension name")?;
+
+        modules
+            .entry(extension_name.to_string())
+            .or_default()
+            .schemas
+            .push(SchemaDef {
+                description: description.to_string(),
+                schema: schema.to_string(),
+            });
     }
-    sql.push_str("create schema pg_temp;\n\n");
+    Ok(())
+}
 
-    for line in run_sql(BUILTIN_TYPES_QUERY)?
+fn query_types(modules: &mut BTreeMap<String, Module>) -> Result<()> {
+    for line in run_sql(TYPES_QUERY)?
         .lines()
         .filter(|line| !line.is_empty())
     {
@@ -257,41 +554,40 @@ pub(crate) fn sync_builtins() -> Result<()> {
         let type_name = parts.next().context("expected type name")?;
         let type_size = parts.next().context("expected type size")?;
         let type_align = parts.next().context("expected type alignment")?;
+        let subtype = parts.next().context("expected subtype")?;
+        let is_range = parts.next().context("expected is_range")?;
         let description = parts.next().context("expected type description")?;
+        let extension_name = parts.next().context("expected extension name")?;
         if type_align.is_empty() {
             bail!("unexpected type alignment for {schema}.{type_name}");
         }
-        if !description.is_empty() {
-            sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
-        }
-        sql.push_str(&format!(
-            "-- size: {type_size}, align: {type_align}\ncreate type {schema}.{type_name};\n\n"
-        ));
-    }
 
-    for line in run_sql(BUILTIN_RANGE_TYPES_QUERY)?
-        .lines()
-        .filter(|line| !line.is_empty())
-    {
-        let mut parts = line.split('\t');
-        let schema = parts.next().context("expected schema name")?;
-        let type_name = parts.next().context("expected type name")?;
-        let type_size = parts.next().context("expected type size")?;
-        let type_align = parts.next().context("expected type alignment")?;
-        let subtype = parts.next().context("expected subtype")?;
-        let description = parts.next().context("expected range type description")?;
-        if !description.is_empty() {
-            sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
+        let module = modules.entry(extension_name.to_string()).or_default();
+        if is_range == "1" {
+            module.range_types.push(RangeTypeDef {
+                align: type_align.to_string(),
+                description: description.to_string(),
+                name: type_name.to_string(),
+                schema: schema.to_string(),
+                size: type_size.to_string(),
+                subtype: subtype.to_string(),
+            });
+        } else {
+            module.types.push(TypeDef {
+                align: type_align.to_string(),
+                description: description.to_string(),
+                name: type_name.to_string(),
+                schema: schema.to_string(),
+                size: type_size.to_string(),
+            });
         }
-        sql.push_str(&format!(
-            "-- size: {type_size}, align: {type_align}\ncreate type {schema}.{type_name} as range (subtype = {subtype});\n\n"
-        ));
     }
 
-    let mut current_relation: Option<(String, String, String, String)> = None;
-    let mut columns: Vec<(String, String)> = vec![];
+    Ok(())
+}
 
-    for line in run_sql(BUILTIN_TABLES_QUERY)?
+fn query_relations(modules: &mut BTreeMap<String, Module>) -> Result<()> {
+    for line in run_sql(TABLES_QUERY)?
         .lines()
         .filter(|line| !line.is_empty())
     {
@@ -299,43 +595,36 @@ pub(crate) fn sync_builtins() -> Result<()> {
         let schema = parts.next().context("expected schema name")?;
         let rel_name = parts.next().context("expected relation name")?;
         let relkind = parts.next().context("expected relkind")?;
-        let col_name = parts.next().context("expected column name")?;
-        let col_type = parts.next().context("expected column type")?;
         let description = parts.next().context("expected description")?;
-
-        if current_relation
-            .as_ref()
-            .map(|(s, t, _, _)| (s.as_str(), t.as_str()))
-            != Some((schema, rel_name))
-        {
-            if let Some((prev_schema, prev_rel, prev_kind, prev_desc)) = current_relation.take() {
-                if prev_kind == "v" {
-                    write_view(&mut sql, &prev_schema, &prev_rel, &prev_desc, &columns);
-                } else {
-                    write_table(&mut sql, &prev_schema, &prev_rel, &prev_desc, &columns);
-                }
-                columns.clear();
-            }
-            current_relation = Some((
-                schema.to_string(),
-                rel_name.to_string(),
-                relkind.to_string(),
-                description.to_string(),
-            ));
+        let extension_name = parts.next().context("expected extension name")?;
+        let columns = parts.next().context("expected columns")?;
+
+        let columns: Vec<Column> =
+            serde_json::from_str(columns).context("expected valid column json")?;
+
+        let module = modules.entry(extension_name.to_string()).or_default();
+        match relkind {
+            "r" => module.tables.push(TableDef {
+                columns,
+                description: description.to_string(),
+                name: rel_name.to_string(),
+                schema: schema.to_string(),
+            }),
+            "v" => module.views.push(ViewDef {
+                columns,
+                description: description.to_string(),
+                name: rel_name.to_string(),
+                schema: schema.to_string(),
+            }),
+            _ => bail!("unexpected relation kind: {relkind}"),
         }
-
-        columns.push((col_name.to_string(), col_type.to_string()));
     }
 
-    if let Some((schema, rel_name, relkind, description)) = current_relation {
-        if relkind == "v" {
-            write_view(&mut sql, &schema, &rel_name, &description, &columns);
-        } else {
-            write_table(&mut sql, &schema, &rel_name, &description, &columns);
-        }
-    }
+    Ok(())
+}
 
-    for line in run_sql(BUILTIN_FUNCTIONS_QUERY)?
+fn query_functions(modules: &mut BTreeMap<String, Module>) -> Result<()> {
+    for line in run_sql(FUNCTIONS_QUERY)?
         .lines()
         .filter(|line| !line.is_empty())
     {
@@ -352,22 +641,43 @@ pub(crate) fn sync_builtins() -> Result<()> {
         let final_fn = parts.next().context("expected aggregate final fn")?;
         let combine_fn = parts.next().context("expected aggregate combine fn")?;
         let init_val = parts.next().context("expected aggregate init value")?;
-
-        if !description.is_empty() {
-            sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
-        }
-
-        if prokind == "a" {
-            write_aggregate(
-                &mut sql, schema, func_name, args, trans_fn, trans_type, final_fn, combine_fn,
-                init_val,
-            );
+        let extension_name = parts.next().context("expected extension name")?;
+
+        let function = if prokind == "a" {
+            FunctionDef::Aggregate(AggregateDef {
+                args: args.to_string(),
+                combine_fn: combine_fn.to_string(),
+                description: description.to_string(),
+                final_fn: final_fn.to_string(),
+                init_val: init_val.to_string(),
+                name: func_name.to_string(),
+                schema: schema.to_string(),
+                trans_fn: trans_fn.to_string(),
+                trans_type: trans_type.to_string(),
+            })
         } else {
-            write_function(&mut sql, schema, func_name, args, result, language);
-        }
+            FunctionDef::Regular(RegularFunctionDef {
+                args: args.to_string(),
+                description: description.to_string(),
+                language: language.to_string(),
+                name: func_name.to_string(),
+                result: result.to_string(),
+                schema: schema.to_string(),
+            })
+        };
+
+        modules
+            .entry(extension_name.to_string())
+            .or_default()
+            .functions
+            .push(function);
     }
 
-    for line in run_sql(BUILTIN_OPERATORS_QUERY)?
+    Ok(())
+}
+
+fn query_operators(modules: &mut BTreeMap<String, Module>) -> Result<()> {
+    for line in run_sql(OPERATORS_QUERY)?
         .lines()
         .filter(|line| !line.is_empty())
     {
@@ -379,22 +689,59 @@ pub(crate) fn sync_builtins() -> Result<()> {
         let func_schema = parts.next().context("expected function schema")?;
         let func_name = parts.next().context("expected function name")?;
         let description = parts.next().context("expected operator description")?;
-
-        if !description.is_empty() {
-            sql.push_str(&format!("-- {}\n", description.replace('\n', "\n-- ")));
-        }
-        let args = match (left_type, right_type) {
-            ("-", r) => format!("  rightarg = {r},\n"),
-            (l, "-") => format!("  leftarg = {l},\n"),
-            (l, r) => format!("  leftarg = {l},\n  rightarg = {r},\n"),
-        };
-        sql.push_str(&format!(
-            "create operator {schema}.{op_name} (\n{args}  function = {func_schema}.{func_name}\n);\n\n"
-        ));
+        let extension_name = parts.next().context("expected extension name")?;
+
+        modules
+            .entry(extension_name.to_string())
+            .or_default()
+            .operators
+            .push(OperatorDef {
+                description: description.to_string(),
+                function_name: func_name.to_string(),
+                function_schema: func_schema.to_string(),
+                left_type: left_type.to_string(),
+                name: op_name.to_string(),
+                right_type: right_type.to_string(),
+                schema: schema.to_string(),
+            });
     }
 
+    Ok(())
+}
+
+pub(crate) fn sync_builtins() -> Result<()> {
+    create_extensions_if_missing()?;
+
+    let version = run_sql(PG_VERSION_QUERY)?;
+    let version = version
+        .split_whitespace()
+        .next()
+        .context("version not found")?;
+
+    let mut modules: BTreeMap<String, Module> = BTreeMap::new();
+
+    query_schemas(&mut modules)?;
+    query_types(&mut modules)?;
+    query_relations(&mut modules)?;
+    query_functions(&mut modules)?;
+    query_operators(&mut modules)?;
+
+    let extensions_root = project_root().join("crates/squawk_ide/src/extensions");
     let builtins_path = project_root().join("crates/squawk_ide/src/builtins.sql");
-    std::fs::write(&builtins_path, sql).context("Failed to write builtins.sql")?;
+
+    std::fs::create_dir_all(&extensions_root).context("Failed to create builtins directory")?;
+    if extensions_root.exists() {
+        std::fs::remove_dir_all(&extensions_root)?;
+    }
+    std::fs::create_dir_all(&extensions_root)?;
+
+    let builtins = modules.remove("builtins").unwrap_or_default();
+    write_module(&builtins_path, version, PG_TEMP_SCHEMA_SQL, &builtins)?;
+
+    for (file_name, module) in &modules {
+        let file_path = extensions_root.join(format!("{file_name}.sql"));
+        write_module(&file_path, version, "", module)?;
+    }
 
     Ok(())
 }