From 290ef6cea4385465f78aa460d474a45b8bf9e175 Mon Sep 17 00:00:00 2001 From: Don Strawsburg Date: Fri, 5 Dec 2025 21:57:21 -0500 Subject: [PATCH] removing jpa stuff from old project --- sql/add_timestamp_columns.sql | 159 + sql/ddl.sql | 52265 ++++++++++++++++ .../ballistic/controllers/Dockerfile | 17 - .../ballistic/controllers/PsaController.java | 57 - .../goforward/ballistic/model/Account.java | 34 + .../ballistic/model/AeroPrecision.java | 293 - .../ballistic/model/AffiliateCategoryMap.java | 35 + .../ballistic/model/Authenticator.java | 88 - .../ballistic/model/AuthenticatorId.java | 48 - .../ballistic/model/BalReseller.java | 107 - .../goforward/ballistic/model/BbProduct.java | 393 - .../goforward/ballistic/model/BuildItem.java | 143 + .../goforward/ballistic/model/Category.java | 96 - .../ballistic/model/Compartment.java | 85 - .../model/EmailVerificationCode.java | 71 - .../ballistic/model/Lipseycatalog.java | 909 - .../ballistic/model/Manufacturer.java | 85 - .../ballistic/model/MerchantCategoryMap.java | 174 + .../ballistic/model/PasswordResetToken.java | 47 - .../goforward/ballistic/model/Platform.java | 84 + .../group/goforward/ballistic/model/Post.java | 116 - .../ballistic/model/ProductCategory.java | 93 - .../ballistic/model/ProductFeed.java | 107 - .../group/goforward/ballistic/model/Psa.java | 357 - .../goforward/ballistic/model/PsaOld.java | 23 - .../goforward/ballistic/model/Session.java | 73 - .../ballistic/model/VerificationToken.java | 47 - .../ballistic/repos/PsaRepository.java | 7 - .../ballistic/services/PsaService.java | 17 - .../services/impl/PsaServiceImpl.java | 41 - update.sql | 5 + 31 files changed, 52899 insertions(+), 3177 deletions(-) create mode 100644 sql/add_timestamp_columns.sql create mode 100644 sql/ddl.sql delete mode 100644 src/main/java/group/goforward/ballistic/controllers/Dockerfile delete mode 100644 src/main/java/group/goforward/ballistic/controllers/PsaController.java delete mode 100644 src/main/java/group/goforward/ballistic/model/AeroPrecision.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Authenticator.java delete mode 100644 src/main/java/group/goforward/ballistic/model/AuthenticatorId.java delete mode 100644 src/main/java/group/goforward/ballistic/model/BalReseller.java delete mode 100644 src/main/java/group/goforward/ballistic/model/BbProduct.java create mode 100644 src/main/java/group/goforward/ballistic/model/BuildItem.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Category.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Compartment.java delete mode 100644 src/main/java/group/goforward/ballistic/model/EmailVerificationCode.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Lipseycatalog.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Manufacturer.java create mode 100644 src/main/java/group/goforward/ballistic/model/MerchantCategoryMap.java delete mode 100644 src/main/java/group/goforward/ballistic/model/PasswordResetToken.java create mode 100644 src/main/java/group/goforward/ballistic/model/Platform.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Post.java delete mode 100644 src/main/java/group/goforward/ballistic/model/ProductCategory.java delete mode 100644 src/main/java/group/goforward/ballistic/model/ProductFeed.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Psa.java delete mode 100644 src/main/java/group/goforward/ballistic/model/PsaOld.java delete mode 100644 src/main/java/group/goforward/ballistic/model/Session.java delete mode 100644 src/main/java/group/goforward/ballistic/model/VerificationToken.java delete mode 100644 src/main/java/group/goforward/ballistic/repos/PsaRepository.java delete mode 100644 src/main/java/group/goforward/ballistic/services/PsaService.java delete mode 100644 src/main/java/group/goforward/ballistic/services/impl/PsaServiceImpl.java create mode 100644 update.sql diff --git a/sql/add_timestamp_columns.sql b/sql/add_timestamp_columns.sql new file mode 100644 index 0000000..6d88a14 --- /dev/null +++ b/sql/add_timestamp_columns.sql @@ -0,0 +1,159 @@ +-- Add timestamp columns (created_at, updated_at, deleted_at) to all tables +-- PostgreSQL script for ballistic-builder-spring project + +-- accounts +ALTER TABLE accounts + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_accounts_updated_at BEFORE UPDATE ON accounts FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + +-- affiliate_category_map +ALTER TABLE affiliate_category_map + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_affiliate_category_map_updated_at BEFORE UPDATE ON affiliate_category_map FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + + +-- brands +ALTER TABLE brands + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_brands_updated_at BEFORE UPDATE ON brands FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + +-- builds +ALTER TABLE build_items + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_builds_items_updated_at BEFORE UPDATE ON build_items FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- builds +ALTER TABLE builds + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_builds_updated_at BEFORE UPDATE ON builds FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- category_mappings +ALTER TABLE category_mappings + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_category_mappings_updated_at BEFORE UPDATE ON category_mappings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- feed_imports +ALTER TABLE feed_imports + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_feed_imports_updated_at BEFORE UPDATE ON feed_imports FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- merchants +ALTER TABLE merchants + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_merchants_updated_at BEFORE UPDATE ON merchants FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- merchant_category_mappings (truncated table name in search results) +ALTER TABLE merchant_category_mappings + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_category_mappings_updated_at BEFORE UPDATE ON category_mappings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- merchant_category_mappings (truncated table name in search results) +ALTER TABLE merchant_category_map + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_merchant_category_map_updated_at BEFORE UPDATE ON merchant_category_map FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- part_categories +ALTER TABLE part_categories + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_part_categories_updated_at BEFORE UPDATE ON part_categories FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + +-- part_role_mappings +ALTER TABLE part_role_mappings + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_part_role_mappings_updated_at BEFORE UPDATE ON part_role_mappings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- part_role_mappings +ALTER TABLE platforms + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_platforms_updated_at BEFORE UPDATE ON platforms FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- price_history +ALTER TABLE price_history + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_price_history_updated_at BEFORE UPDATE ON price_history FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- +-- product_offers +ALTER TABLE product_offers + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_product_offers_updated_at BEFORE UPDATE ON product_offers FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- products +ALTER TABLE products + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_products_updated_at BEFORE UPDATE ON products FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + +-- states +ALTER TABLE states + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_states_updated_at BEFORE UPDATE ON states FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +-- users +ALTER TABLE users + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +CREATE TRIGGER update_users_updated_at BEFORE UPDATE ON users FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + + +-- Create function to automatically update updated_at timestamp +CREATE OR REPLACE FUNCTION update_updated_at_column() +RETURNS TRIGGER AS $$ +BEGIN + NEW.updated_at = CURRENT_TIMESTAMP; + RETURN NEW; +END; +$$ language 'plpgsql'; + +-- Create triggers for all tables to auto-update updated_at on row modification +CREATE TRIGGER update_accounts_updated_at BEFORE UPDATE ON accounts FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_affiliate_category_map_updated_at BEFORE UPDATE ON affiliate_category_map FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_brands_updated_at BEFORE UPDATE ON brands FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_builds_updated_at BEFORE UPDATE ON builds FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_builds_items_updated_at BEFORE UPDATE ON build_items FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_merchants_updated_at BEFORE UPDATE ON merchants FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_merchant_category_mappings_updated_at BEFORE UPDATE ON merchant_category_mappings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); + +CREATE TRIGGER update_part_role_mappings_updated_at BEFORE UPDATE ON part_role_mappings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_price_history_updated_at BEFORE UPDATE ON price_history FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_product_offers_updated_at BEFORE UPDATE ON product_offers FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); +CREATE TRIGGER update_products_updated_at BEFORE UPDATE ON products FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); diff --git a/sql/ddl.sql b/sql/ddl.sql new file mode 100644 index 0000000..a996d13 --- /dev/null +++ b/sql/ddl.sql @@ -0,0 +1,52265 @@ +create database ss_builder + with owner postgres; + +-- Unknown how to generate base type type + +comment on type pg_catalog.aclitem is 'access control list'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.bit is 'fixed-length bit string'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.bool is 'boolean, ''true''/''false'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.box is 'geometric box ''(lower left,upper right)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.bpchar is 'char(length), blank-padded string, fixed storage length'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.bytea is 'variable-length string, binary values escaped'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.char is 'single character'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.cid is 'command identifier type, sequence in transaction id'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.cidr is 'network IP address/netmask, network address'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.circle is 'geometric circle ''(center,radius)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.date is 'date'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.float4 is 'single-precision floating point number, 4-byte storage'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.float8 is 'double-precision floating point number, 8-byte storage'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.gtsvector is 'GiST index internal text representation for text search'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.inet is 'IP address/netmask, host address, netmask optional'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.int2 is '-32 thousand to 32 thousand, 2-byte storage'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.int4 is '-2 billion to 2 billion integer, 4-byte storage'; + +create domain information_schema.cardinal_number as integer + constraint cardinal_number_domain_check check (VALUE >= 0); + +-- Unknown how to generate base type type + +comment on type pg_catalog.int8 is '~18 digit integer, 8-byte storage'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.interval is '@ , time interval'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.json is 'JSON stored as text'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.jsonb is 'Binary JSON'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.jsonpath is 'JSON path'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.line is 'geometric line'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.lseg is 'geometric line segment ''(pt1,pt2)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.macaddr is 'XX:XX:XX:XX:XX:XX, MAC address'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.macaddr8 is 'XX:XX:XX:XX:XX:XX:XX:XX, MAC address'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.money is 'monetary amounts, $d,ddd.cc'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.name is '63-byte type for storing system identifiers'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.numeric is 'numeric(precision, decimal), arbitrary precision number'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.oid is 'object identifier(oid), maximum 4 billion'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.path is 'geometric path ''(pt1,...)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_brin_bloom_summary is 'BRIN bloom summary'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_brin_minmax_multi_summary is 'BRIN minmax-multi summary'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_dependencies is 'multivariate dependencies'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_lsn is 'PostgreSQL LSN datatype'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_mcv_list is 'multivariate MCV list'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_ndistinct is 'multivariate ndistinct coefficients'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_node_tree is 'string representing an internal node tree'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.pg_snapshot is 'snapshot'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.point is 'geometric point ''(x, y)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.polygon is 'geometric polygon ''(pt1,...)'''; + +-- Unknown how to generate base type type + +comment on type pg_catalog.refcursor is 'reference to cursor (portal name)'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regclass is 'registered class'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regcollation is 'registered collation'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regconfig is 'registered text search configuration'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regdictionary is 'registered text search dictionary'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regnamespace is 'registered namespace'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regoper is 'registered operator'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regoperator is 'registered operator (with args)'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regproc is 'registered procedure'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regprocedure is 'registered procedure (with args)'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regrole is 'registered role'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.regtype is 'registered type'; + +create domain information_schema.sql_identifier as name; + +-- Unknown how to generate base type type + +comment on type pg_catalog.text is 'variable-length string, no limit specified'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.tid is '(block, offset), physical location of tuple'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.time is 'time of day'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.timestamp is 'date and time'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.timestamptz is 'date and time with time zone'; + +create domain information_schema.time_stamp as timestamp(2) with time zone + default CURRENT_TIMESTAMP(2); + +-- Unknown how to generate base type type + +comment on type pg_catalog.timetz is 'time of day with time zone'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.tsquery is 'query representation for text search'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.tsvector is 'text representation for text search'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.txid_snapshot is 'txid snapshot'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.uuid is 'UUID datatype'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.varbit is 'variable-length bit string'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.varchar is 'varchar(length), non-blank-padded string, variable storage length'; + +create domain information_schema.character_data as varchar; + +-- Unknown how to generate base type type + +comment on type pg_catalog.xid is 'transaction id'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.xid8 is 'full transaction id'; + +-- Unknown how to generate base type type + +comment on type pg_catalog.xml is 'XML content'; + +create domain information_schema.yes_or_no as varchar(3) + constraint yes_or_no_check check ((VALUE)::text = ANY + ((ARRAY ['YES'::character varying, 'NO'::character varying])::text[])); + +create table public.merchants +( + id serial + primary key, + name text not null + unique, + avantlink_mid text not null + unique, + feed_url text not null, + is_active boolean default true not null, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + uuid uuid default gen_random_uuid() not null, + slug text, + website text, + logo_url text, + deleted_at timestamp with time zone, + offer_feed_url text, + last_full_import_at timestamp with time zone, + last_offer_sync_at timestamp with time zone +); + +alter table public.merchants + owner to postgres; + +create index idx_merchants_active + on public.merchants (is_active); + +create unique index idx_merchants_uuid + on public.merchants (uuid); + +create unique index idx_merchants_slug + on public.merchants (slug); + +create table public.part_categories +( + id serial + primary key, + slug text not null + unique, + name text not null, + description text, + uuid uuid default gen_random_uuid() not null, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + group_name text not null, + sort_order integer not null, + deleted_at timestamp with time zone +); + +alter table public.part_categories + owner to postgres; + +create unique index idx_part_categories_uuid + on public.part_categories (uuid); + +create unique index idx_part_categories_name + on public.part_categories (name); + +create table public.brands +( + id serial + primary key, + name text not null + unique, + website text, + created_at timestamp with time zone default now() not null, + uuid uuid default gen_random_uuid() not null, + slug text, + logo_url text, + updated_at timestamp with time zone default now() not null, + deleted_at timestamp with time zone +); + +alter table public.brands + owner to postgres; + +create unique index idx_brands_slug + on public.brands (slug); + +create unique index idx_brands_uuid + on public.brands (uuid); + +create table public.category_mappings +( + id serial + primary key, + merchant_id integer not null + references public.merchants, + raw_category_path text not null, + part_category_id integer + references public.part_categories, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone, + deleted_at timestamp with time zone, + unique (merchant_id, raw_category_path) +); + +alter table public.category_mappings + owner to postgres; + +create index idx_category_mappings_merchant + on public.category_mappings (merchant_id); + +create index idx_category_mappings_part_category + on public.category_mappings (part_category_id); + +create table public.feed_imports +( + id bigserial + primary key, + merchant_id integer not null + references public.merchants, + started_at timestamp with time zone default now() not null, + finished_at timestamp with time zone, + rows_total integer, + rows_processed integer, + rows_new integer, + rows_updated integer, + status text default 'running'::text not null, + error_message text +); + +alter table public.feed_imports + owner to postgres; + +create index idx_feed_imports_merchant + on public.feed_imports (merchant_id); + +create index idx_feed_imports_status + on public.feed_imports (status); + +create index idx_feed_imports_started_at + on public.feed_imports (started_at); + +create table public.products +( + id integer generated always as identity + primary key, + uuid uuid default gen_random_uuid() not null, + brand_id integer not null + references public.brands, + name text not null, + slug text not null, + mpn text, + upc text, + platform text not null, + part_role text not null, + short_description text, + description text, + main_image_url text, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + deleted_at timestamp with time zone, + raw_category_key text, + platform_locked boolean default false not null, + configuration varchar(32) +); + +alter table public.products + owner to postgres; + +create unique index idx_products_uuid + on public.products (uuid); + +create unique index idx_products_slug + on public.products (slug); + +create index idx_products_brand_id + on public.products (brand_id); + +create index idx_products_platform_role + on public.products (platform, part_role); + +create table public.product_offers +( + id integer generated always as identity + primary key, + uuid uuid default gen_random_uuid() not null, + product_id integer not null + constraint product_offers_product_fk + references public.products + on delete cascade, + merchant_id integer not null + constraint product_offers_merchant_fk + references public.merchants + on delete cascade, + avantlink_product_id text not null, + sku text, + upc text, + buy_url text not null, + price numeric(10, 2) not null, + original_price numeric(10, 2), + currency text default 'USD'::text not null, + in_stock boolean default true not null, + last_seen_at timestamp with time zone default now() not null, + first_seen_at timestamp with time zone default now() not null, + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.product_offers + owner to postgres; + +create unique index idx_product_offers_uuid + on public.product_offers (uuid); + +create index idx_product_offers_in_stock + on public.product_offers (in_stock); + +create index idx_product_offers_merchant + on public.product_offers (merchant_id); + +create index idx_product_offers_price + on public.product_offers (price); + +create index idx_product_offers_product + on public.product_offers (product_id); + +create unique index uniq_product_offers_merchant_product + on public.product_offers (merchant_id, avantlink_product_id); + +create table public.users +( + id integer generated always as identity + primary key, + uuid uuid default gen_random_uuid() not null + unique, + email text not null + unique, + password_hash text not null, + display_name text, + role text default 'USER'::text not null, + is_active boolean default true not null, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + deleted_at timestamp with time zone, + email_verified_at timestamp with time zone, + verification_token text, + reset_password_token text, + reset_password_expires_at timestamp with time zone, + last_login_at timestamp with time zone, + login_count integer default 0 not null, + avatar_url text, + preferences jsonb +); + +alter table public.users + owner to postgres; + +create unique index idx_users_uuid + on public.users (uuid); + +create unique index users_email_unique_active + on public.users (lower(email)) + where (deleted_at IS NULL); + +create unique index users_verification_token_unique + on public.users (verification_token) + where (verification_token IS NOT NULL); + +create index users_reset_password_token_idx + on public.users (reset_password_token) + where (reset_password_token IS NOT NULL); + +create table public.builds +( + id integer generated always as identity + primary key, + uuid uuid default gen_random_uuid() not null, + user_id integer + constraint builds_user_fk + references public.users + on delete set null, + title text not null, + description text, + is_public boolean default false not null, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + deleted_at timestamp with time zone +); + +alter table public.builds + owner to postgres; + +create unique index idx_builds_uuid + on public.builds (uuid); + +create index idx_builds_user_id + on public.builds (user_id); + +create table public.build_items +( + id integer generated always as identity + primary key, + uuid uuid default gen_random_uuid() not null, + build_id integer not null + constraint build_items_build_fk + references public.builds + on delete cascade, + product_id integer not null + constraint build_items_product_fk + references public.products + on delete cascade, + slot text not null, + position integer default 0 not null, + quantity integer default 1 not null, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.build_items + owner to postgres; + +create unique index idx_build_items_uuid + on public.build_items (uuid); + +create index idx_build_items_build_id + on public.build_items (build_id); + +create index idx_build_items_product_id + on public.build_items (product_id); + +create index idx_build_items_slot + on public.build_items (slot); + +create table public.price_history +( + id bigint generated always as identity + primary key, + product_offer_id integer not null + constraint price_history_offer_fk + references public.product_offers + on delete cascade, + price numeric(10, 2) not null, + recorded_at timestamp with time zone default now() not null, + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.price_history + owner to postgres; + +create index idx_price_history_offer + on public.price_history (product_offer_id); + +create index idx_price_history_recorded_at + on public.price_history (recorded_at); + +create table public.merchant_category_map +( + id serial + primary key, + merchant_id integer not null + references public.merchants + on delete cascade, + raw_category text not null, + canonical_part_role text, + confidence numeric(5, 2), + notes text, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + canonical_category varchar(255), + enabled boolean default true not null, + platform varchar(100), + part_role varchar(100), + deleted_at timestamp with time zone +); + +alter table public.merchant_category_map + owner to postgres; + +create unique index ux_merchant_category_map_merchant_raw_category + on public.merchant_category_map (merchant_id, raw_category); + +create table public.states +( + id integer not null, + state varchar(50), + abbreviation varchar(50), + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.states + owner to postgres; + +create table public.merchant_category_mappings +( + id serial + primary key, + merchant_id integer not null + references public.merchants + on delete cascade, + raw_category text not null, + mapped_part_role text, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + mapped_configuration varchar(32), + deleted_at timestamp with time zone, + constraint uq_merchant_category + unique (merchant_id, raw_category) +); + +alter table public.merchant_category_mappings + owner to postgres; + +create index idx_mcm_merchant + on public.merchant_category_mappings (merchant_id); + +create table public.platforms +( + id serial + primary key, + key text not null + unique, + label text not null, + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.platforms + owner to postgres; + +create table public.accounts +( + id uuid, + uuid uuid, + user_id uuid, + type varchar, + provider text, + provider_account_id varchar, + refresh_token text, + access_token text, + expires_at integer, + token_type varchar, + id_token text, + session_state varchar, + scope text, + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.accounts + owner to dba; + +create table public.affiliate_category_map +( + id serial + primary key, + source_type varchar(64) not null, + source_value varchar(255) not null, + platform varchar(64), + part_category_id integer not null + references public.part_categories + on delete restrict, + notes text, + created_at timestamp with time zone default CURRENT_TIMESTAMP, + updated_at timestamp with time zone default CURRENT_TIMESTAMP, + deleted_at timestamp with time zone +); + +alter table public.affiliate_category_map + owner to postgres; + +create unique index ux_affiliate_category_map_src_platform + on public.affiliate_category_map (source_type, source_value, COALESCE(platform, 'ALL'::character varying)); + +create table public.part_role_mappings +( + id bigserial + primary key, + platform varchar(50) not null, + part_role varchar(100) not null, + part_category_id bigint + references public.part_categories, + notes text, + created_at timestamp with time zone default now() not null, + updated_at timestamp with time zone default now() not null, + deleted_at timestamp with time zone +); + +alter table public.part_role_mappings + owner to postgres; + +create index idx_part_role_mappings_platform_role + on public.part_role_mappings (platform, part_role); + +create table pg_catalog.pg_aggregate +( + aggfnoid regproc not null + constraint pg_aggregate_fnoid_index + primary key, + aggkind "char" not null, + aggnumdirectargs smallint not null, + aggtransfn regproc not null, + aggfinalfn regproc not null, + aggcombinefn regproc not null, + aggserialfn regproc not null, + aggdeserialfn regproc not null, + aggmtransfn regproc not null, + aggminvtransfn regproc not null, + aggmfinalfn regproc not null, + aggfinalextra boolean not null, + aggmfinalextra boolean not null, + aggfinalmodify "char" not null, + aggmfinalmodify "char" not null, + aggsortop oid not null, + aggtranstype oid not null, + aggtransspace integer not null, + aggmtranstype oid not null, + aggmtransspace integer not null, + agginitval text, + aggminitval text +); + +create table pg_catalog.pg_am +( + oid oid not null + constraint pg_am_oid_index + primary key, + amname information_schema.sql_identifier not null + constraint pg_am_name_index + unique, + amhandler regproc not null, + amtype "char" not null +); + +create table pg_catalog.pg_amop +( + oid oid not null + constraint pg_amop_oid_index + primary key, + amopfamily oid not null, + amoplefttype oid not null, + amoprighttype oid not null, + amopstrategy smallint not null, + amoppurpose "char" not null, + amopopr oid not null, + amopmethod oid not null, + amopsortfamily oid not null, + constraint pg_amop_fam_strat_index + unique (amopfamily, amoplefttype, amoprighttype, amopstrategy), + constraint pg_amop_opr_fam_index + unique (amopopr, amoppurpose, amopfamily) +); + +create table pg_catalog.pg_amproc +( + oid oid not null + constraint pg_amproc_oid_index + primary key, + amprocfamily oid not null, + amproclefttype oid not null, + amprocrighttype oid not null, + amprocnum smallint not null, + amproc regproc not null, + constraint pg_amproc_fam_proc_index + unique (amprocfamily, amproclefttype, amprocrighttype, amprocnum) +); + +create table pg_catalog.pg_attrdef +( + oid oid not null + constraint pg_attrdef_oid_index + primary key, + adrelid oid not null, + adnum smallint not null, + adbin pg_node_tree not null, + constraint pg_attrdef_adrelid_adnum_index + unique (adrelid, adnum) +); + +create table pg_catalog.pg_attribute +( + attrelid oid not null, + attname information_schema.sql_identifier not null, + atttypid oid not null, + attlen smallint not null, + attnum smallint not null, + attcacheoff integer not null, + atttypmod integer not null, + attndims smallint not null, + attbyval boolean not null, + attalign "char" not null, + attstorage "char" not null, + attcompression "char" not null, + attnotnull boolean not null, + atthasdef boolean not null, + atthasmissing boolean not null, + attidentity "char" not null, + attgenerated "char" not null, + attisdropped boolean not null, + attislocal boolean not null, + attinhcount smallint not null, + attstattarget smallint not null, + attcollation oid not null, + attacl aclitem[], + attoptions text[], + attfdwoptions text[], + attmissingval anyarray, + constraint pg_attribute_relid_attnum_index + primary key (attrelid, attnum), + constraint pg_attribute_relid_attnam_index + unique (attrelid, attname) +); + +create table pg_catalog.pg_auth_members +( + oid oid not null + constraint pg_auth_members_oid_index + primary key, + roleid oid not null, + member oid not null, + grantor oid not null, + admin_option boolean not null, + inherit_option boolean not null, + set_option boolean not null, + constraint pg_auth_members_member_role_index + unique (member, roleid, grantor), + constraint pg_auth_members_role_member_index + unique (roleid, member, grantor) +) + tablespace pg_global; + +create index pg_auth_members_grantor_index + on pg_catalog.pg_auth_members (grantor) + tablespace pg_global; + +create table pg_catalog.pg_authid +( + oid oid not null + constraint pg_authid_oid_index + primary key, + rolname information_schema.sql_identifier not null + constraint pg_authid_rolname_index + unique, + rolsuper boolean not null, + rolinherit boolean not null, + rolcreaterole boolean not null, + rolcreatedb boolean not null, + rolcanlogin boolean not null, + rolreplication boolean not null, + rolbypassrls boolean not null, + rolconnlimit integer not null, + rolpassword text, + rolvaliduntil timestamp with time zone +) + tablespace pg_global; + +create table pg_catalog.pg_cast +( + oid oid not null + constraint pg_cast_oid_index + primary key, + castsource oid not null, + casttarget oid not null, + castfunc oid not null, + castcontext "char" not null, + castmethod "char" not null, + constraint pg_cast_source_target_index + unique (castsource, casttarget) +); + +create table pg_catalog.pg_class +( + oid oid not null + constraint pg_class_oid_index + primary key, + relname information_schema.sql_identifier not null, + relnamespace oid not null, + reltype oid not null, + reloftype oid not null, + relowner oid not null, + relam oid not null, + relfilenode oid not null, + reltablespace oid not null, + relpages integer not null, + reltuples real not null, + relallvisible integer not null, + reltoastrelid oid not null, + relhasindex boolean not null, + relisshared boolean not null, + relpersistence "char" not null, + relkind "char" not null, + relnatts smallint not null, + relchecks smallint not null, + relhasrules boolean not null, + relhastriggers boolean not null, + relhassubclass boolean not null, + relrowsecurity boolean not null, + relforcerowsecurity boolean not null, + relispopulated boolean not null, + relreplident "char" not null, + relispartition boolean not null, + relrewrite oid not null, + relfrozenxid xid not null, + relminmxid xid not null, + relacl aclitem[], + reloptions text[], + relpartbound pg_node_tree, + constraint pg_class_relname_nsp_index + unique (relname, relnamespace) +); + +create index pg_class_tblspc_relfilenode_index + on pg_catalog.pg_class (reltablespace, relfilenode); + +create table pg_catalog.pg_collation +( + oid oid not null + constraint pg_collation_oid_index + primary key, + collname information_schema.sql_identifier not null, + collnamespace oid not null, + collowner oid not null, + collprovider "char" not null, + collisdeterministic boolean not null, + collencoding integer not null, + collcollate text, + collctype text, + colliculocale text, + collicurules text, + collversion text, + constraint pg_collation_name_enc_nsp_index + unique (collname, collencoding, collnamespace) +); + +create table pg_catalog.pg_constraint +( + oid oid not null + constraint pg_constraint_oid_index + primary key, + conname information_schema.sql_identifier not null, + connamespace oid not null, + contype "char" not null, + condeferrable boolean not null, + condeferred boolean not null, + convalidated boolean not null, + conrelid oid not null, + contypid oid not null, + conindid oid not null, + conparentid oid not null, + confrelid oid not null, + confupdtype "char" not null, + confdeltype "char" not null, + confmatchtype "char" not null, + conislocal boolean not null, + coninhcount smallint not null, + connoinherit boolean not null, + conkey smallint[], + confkey smallint[], + conpfeqop oid[], + conppeqop oid[], + conffeqop oid[], + confdelsetcols smallint[], + conexclop oid[], + conbin pg_node_tree, + constraint pg_constraint_conrelid_contypid_conname_index + unique (conrelid, contypid, conname) +); + +create index pg_constraint_conname_nsp_index + on pg_catalog.pg_constraint (conname collate "C", connamespace); + +create index pg_constraint_conparentid_index + on pg_catalog.pg_constraint (conparentid); + +create index pg_constraint_contypid_index + on pg_catalog.pg_constraint (contypid); + +create table pg_catalog.pg_conversion +( + oid oid not null + constraint pg_conversion_oid_index + primary key, + conname information_schema.sql_identifier not null, + connamespace oid not null, + conowner oid not null, + conforencoding integer not null, + contoencoding integer not null, + conproc regproc not null, + condefault boolean not null, + constraint pg_conversion_default_index + unique (connamespace, conforencoding, contoencoding, oid), + constraint pg_conversion_name_nsp_index + unique (conname, connamespace) +); + +create table pg_catalog.pg_database +( + oid oid not null + constraint pg_database_oid_index + primary key, + datname information_schema.sql_identifier not null + constraint pg_database_datname_index + unique, + datdba oid not null, + encoding integer not null, + datlocprovider "char" not null, + datistemplate boolean not null, + datallowconn boolean not null, + datconnlimit integer not null, + datfrozenxid xid not null, + datminmxid xid not null, + dattablespace oid not null, + datcollate text not null, + datctype text not null, + daticulocale text, + daticurules text, + datcollversion text, + datacl aclitem[] +) + tablespace pg_global; + +create table pg_catalog.pg_db_role_setting +( + setdatabase oid not null, + setrole oid not null, + setconfig text[], + constraint pg_db_role_setting_databaseid_rol_index + primary key (setdatabase, setrole) +) + tablespace pg_global; + +create table pg_catalog.pg_default_acl +( + oid oid not null + constraint pg_default_acl_oid_index + primary key, + defaclrole oid not null, + defaclnamespace oid not null, + defaclobjtype "char" not null, + defaclacl aclitem[] not null, + constraint pg_default_acl_role_nsp_obj_index + unique (defaclrole, defaclnamespace, defaclobjtype) +); + +create table pg_catalog.pg_depend +( + classid oid not null, + objid oid not null, + objsubid integer not null, + refclassid oid not null, + refobjid oid not null, + refobjsubid integer not null, + deptype "char" not null +); + +create index pg_depend_depender_index + on pg_catalog.pg_depend (classid, objid, objsubid); + +create index pg_depend_reference_index + on pg_catalog.pg_depend (refclassid, refobjid, refobjsubid); + +create table pg_catalog.pg_description +( + objoid oid not null, + classoid oid not null, + objsubid integer not null, + description text not null, + constraint pg_description_o_c_o_index + primary key (objoid, classoid, objsubid) +); + +create table pg_catalog.pg_enum +( + oid oid not null + constraint pg_enum_oid_index + primary key, + enumtypid oid not null, + enumsortorder real not null, + enumlabel information_schema.sql_identifier not null, + constraint pg_enum_typid_label_index + unique (enumtypid, enumlabel), + constraint pg_enum_typid_sortorder_index + unique (enumtypid, enumsortorder) +); + +create table pg_catalog.pg_event_trigger +( + oid oid not null + constraint pg_event_trigger_oid_index + primary key, + evtname information_schema.sql_identifier not null + constraint pg_event_trigger_evtname_index + unique, + evtevent information_schema.sql_identifier not null, + evtowner oid not null, + evtfoid oid not null, + evtenabled "char" not null, + evttags text[] +); + +create table pg_catalog.pg_extension +( + oid oid not null + constraint pg_extension_oid_index + primary key, + extname information_schema.sql_identifier not null + constraint pg_extension_name_index + unique, + extowner oid not null, + extnamespace oid not null, + extrelocatable boolean not null, + extversion text not null, + extconfig oid[], + extcondition text[] +); + +create table pg_catalog.pg_foreign_data_wrapper +( + oid oid not null + constraint pg_foreign_data_wrapper_oid_index + primary key, + fdwname information_schema.sql_identifier not null + constraint pg_foreign_data_wrapper_name_index + unique, + fdwowner oid not null, + fdwhandler oid not null, + fdwvalidator oid not null, + fdwacl aclitem[], + fdwoptions text[] +); + +create table pg_catalog.pg_foreign_server +( + oid oid not null + constraint pg_foreign_server_oid_index + primary key, + srvname information_schema.sql_identifier not null + constraint pg_foreign_server_name_index + unique, + srvowner oid not null, + srvfdw oid not null, + srvtype text, + srvversion text, + srvacl aclitem[], + srvoptions text[] +); + +create table pg_catalog.pg_foreign_table +( + ftrelid oid not null + constraint pg_foreign_table_relid_index + primary key, + ftserver oid not null, + ftoptions text[] +); + +create table pg_catalog.pg_index +( + indexrelid oid not null + constraint pg_index_indexrelid_index + primary key, + indrelid oid not null, + indnatts smallint not null, + indnkeyatts smallint not null, + indisunique boolean not null, + indnullsnotdistinct boolean not null, + indisprimary boolean not null, + indisexclusion boolean not null, + indimmediate boolean not null, + indisclustered boolean not null, + indisvalid boolean not null, + indcheckxmin boolean not null, + indisready boolean not null, + indislive boolean not null, + indisreplident boolean not null, + indkey int2vector not null, + indcollation oidvector not null, + indclass oidvector not null, + indoption int2vector not null, + indexprs pg_node_tree, + indpred pg_node_tree +); + +create index pg_index_indrelid_index + on pg_catalog.pg_index (indrelid); + +create table pg_catalog.pg_inherits +( + inhrelid oid not null, + inhparent oid not null, + inhseqno integer not null, + inhdetachpending boolean not null, + constraint pg_inherits_relid_seqno_index + primary key (inhrelid, inhseqno) +); + +create index pg_inherits_parent_index + on pg_catalog.pg_inherits (inhparent); + +create table pg_catalog.pg_init_privs +( + objoid oid not null, + classoid oid not null, + objsubid integer not null, + privtype "char" not null, + initprivs aclitem[] not null, + constraint pg_init_privs_o_c_o_index + primary key (objoid, classoid, objsubid) +); + +create table pg_catalog.pg_language +( + oid oid not null + constraint pg_language_oid_index + primary key, + lanname information_schema.sql_identifier not null + constraint pg_language_name_index + unique, + lanowner oid not null, + lanispl boolean not null, + lanpltrusted boolean not null, + lanplcallfoid oid not null, + laninline oid not null, + lanvalidator oid not null, + lanacl aclitem[] +); + +create table pg_catalog.pg_largeobject +( + loid oid not null, + pageno integer not null, + data bytea not null, + constraint pg_largeobject_loid_pn_index + primary key (loid, pageno) +); + +create table pg_catalog.pg_largeobject_metadata +( + oid oid not null + constraint pg_largeobject_metadata_oid_index + primary key, + lomowner oid not null, + lomacl aclitem[] +); + +create table pg_catalog.pg_namespace +( + oid oid not null + constraint pg_namespace_oid_index + primary key, + nspname information_schema.sql_identifier not null + constraint pg_namespace_nspname_index + unique, + nspowner oid not null, + nspacl aclitem[] +); + +create table pg_catalog.pg_opclass +( + oid oid not null + constraint pg_opclass_oid_index + primary key, + opcmethod oid not null, + opcname information_schema.sql_identifier not null, + opcnamespace oid not null, + opcowner oid not null, + opcfamily oid not null, + opcintype oid not null, + opcdefault boolean not null, + opckeytype oid not null, + constraint pg_opclass_am_name_nsp_index + unique (opcmethod, opcname, opcnamespace) +); + +create table pg_catalog.pg_operator +( + oid oid not null + constraint pg_operator_oid_index + primary key, + oprname information_schema.sql_identifier not null, + oprnamespace oid not null, + oprowner oid not null, + oprkind "char" not null, + oprcanmerge boolean not null, + oprcanhash boolean not null, + oprleft oid not null, + oprright oid not null, + oprresult oid not null, + oprcom oid not null, + oprnegate oid not null, + oprcode regproc not null, + oprrest regproc not null, + oprjoin regproc not null, + constraint pg_operator_oprname_l_r_n_index + unique (oprname, oprleft, oprright, oprnamespace) +); + +create table pg_catalog.pg_opfamily +( + oid oid not null + constraint pg_opfamily_oid_index + primary key, + opfmethod oid not null, + opfname information_schema.sql_identifier not null, + opfnamespace oid not null, + opfowner oid not null, + constraint pg_opfamily_am_name_nsp_index + unique (opfmethod, opfname, opfnamespace) +); + +create table pg_catalog.pg_parameter_acl +( + oid oid not null + constraint pg_parameter_acl_oid_index + primary key, + parname text not null + constraint pg_parameter_acl_parname_index + unique, + paracl aclitem[] +) + tablespace pg_global; + +create table pg_catalog.pg_partitioned_table +( + partrelid oid not null + constraint pg_partitioned_table_partrelid_index + primary key, + partstrat "char" not null, + partnatts smallint not null, + partdefid oid not null, + partattrs int2vector not null, + partclass oidvector not null, + partcollation oidvector not null, + partexprs pg_node_tree +); + +create table pg_catalog.pg_policy +( + oid oid not null + constraint pg_policy_oid_index + primary key, + polname information_schema.sql_identifier not null, + polrelid oid not null, + polcmd "char" not null, + polpermissive boolean not null, + polroles oid[] not null, + polqual pg_node_tree, + polwithcheck pg_node_tree, + constraint pg_policy_polrelid_polname_index + unique (polrelid, polname) +); + +create table pg_catalog.pg_proc +( + oid oid not null + constraint pg_proc_oid_index + primary key, + proname information_schema.sql_identifier not null, + pronamespace oid not null, + proowner oid not null, + prolang oid not null, + procost real not null, + prorows real not null, + provariadic oid not null, + prosupport regproc not null, + prokind "char" not null, + prosecdef boolean not null, + proleakproof boolean not null, + proisstrict boolean not null, + proretset boolean not null, + provolatile "char" not null, + proparallel "char" not null, + pronargs smallint not null, + pronargdefaults smallint not null, + prorettype oid not null, + proargtypes oidvector not null, + proallargtypes oid[], + proargmodes "char"[], + proargnames text[], + proargdefaults pg_node_tree, + protrftypes oid[], + prosrc text not null, + probin text, + prosqlbody pg_node_tree, + proconfig text[], + proacl aclitem[], + constraint pg_proc_proname_args_nsp_index + unique (proname, proargtypes, pronamespace) +); + +create table pg_catalog.pg_publication +( + oid oid not null + constraint pg_publication_oid_index + primary key, + pubname information_schema.sql_identifier not null + constraint pg_publication_pubname_index + unique, + pubowner oid not null, + puballtables boolean not null, + pubinsert boolean not null, + pubupdate boolean not null, + pubdelete boolean not null, + pubtruncate boolean not null, + pubviaroot boolean not null +); + +create table pg_catalog.pg_publication_namespace +( + oid oid not null + constraint pg_publication_namespace_oid_index + primary key, + pnpubid oid not null, + pnnspid oid not null, + constraint pg_publication_namespace_pnnspid_pnpubid_index + unique (pnnspid, pnpubid) +); + +create table pg_catalog.pg_publication_rel +( + oid oid not null + constraint pg_publication_rel_oid_index + primary key, + prpubid oid not null, + prrelid oid not null, + prqual pg_node_tree, + prattrs int2vector, + constraint pg_publication_rel_prrelid_prpubid_index + unique (prrelid, prpubid) +); + +create index pg_publication_rel_prpubid_index + on pg_catalog.pg_publication_rel (prpubid); + +create table pg_catalog.pg_range +( + rngtypid oid not null + constraint pg_range_rngtypid_index + primary key, + rngsubtype oid not null, + rngmultitypid oid not null + constraint pg_range_rngmultitypid_index + unique, + rngcollation oid not null, + rngsubopc oid not null, + rngcanonical regproc not null, + rngsubdiff regproc not null +); + +create table pg_catalog.pg_replication_origin +( + roident oid not null + constraint pg_replication_origin_roiident_index + primary key, + roname text not null + constraint pg_replication_origin_roname_index + unique +) + tablespace pg_global; + +create table pg_catalog.pg_rewrite +( + oid oid not null + constraint pg_rewrite_oid_index + primary key, + rulename information_schema.sql_identifier not null, + ev_class oid not null, + ev_type "char" not null, + ev_enabled "char" not null, + is_instead boolean not null, + ev_qual pg_node_tree not null, + ev_action pg_node_tree not null, + constraint pg_rewrite_rel_rulename_index + unique (ev_class, rulename) +); + +create table pg_catalog.pg_seclabel +( + objoid oid not null, + classoid oid not null, + objsubid integer not null, + provider text not null, + label text not null, + constraint pg_seclabel_object_index + primary key (objoid, classoid, objsubid, provider) +); + +create table pg_catalog.pg_sequence +( + seqrelid oid not null + constraint pg_sequence_seqrelid_index + primary key, + seqtypid oid not null, + seqstart bigint not null, + seqincrement bigint not null, + seqmax bigint not null, + seqmin bigint not null, + seqcache bigint not null, + seqcycle boolean not null +); + +create table pg_catalog.pg_shdepend +( + dbid oid not null, + classid oid not null, + objid oid not null, + objsubid integer not null, + refclassid oid not null, + refobjid oid not null, + deptype "char" not null +) + tablespace pg_global; + +create index pg_shdepend_depender_index + on pg_catalog.pg_shdepend (dbid, classid, objid, objsubid) + tablespace pg_global; + +create index pg_shdepend_reference_index + on pg_catalog.pg_shdepend (refclassid, refobjid) + tablespace pg_global; + +create table pg_catalog.pg_shdescription +( + objoid oid not null, + classoid oid not null, + description text not null, + constraint pg_shdescription_o_c_index + primary key (objoid, classoid) +) + tablespace pg_global; + +create table pg_catalog.pg_shseclabel +( + objoid oid not null, + classoid oid not null, + provider text not null, + label text not null, + constraint pg_shseclabel_object_index + primary key (objoid, classoid, provider) +) + tablespace pg_global; + +create table pg_catalog.pg_statistic +( + starelid oid not null, + staattnum smallint not null, + stainherit boolean not null, + stanullfrac real not null, + stawidth integer not null, + stadistinct real not null, + stakind1 smallint not null, + stakind2 smallint not null, + stakind3 smallint not null, + stakind4 smallint not null, + stakind5 smallint not null, + staop1 oid not null, + staop2 oid not null, + staop3 oid not null, + staop4 oid not null, + staop5 oid not null, + stacoll1 oid not null, + stacoll2 oid not null, + stacoll3 oid not null, + stacoll4 oid not null, + stacoll5 oid not null, + stanumbers1 real[], + stanumbers2 real[], + stanumbers3 real[], + stanumbers4 real[], + stanumbers5 real[], + stavalues1 anyarray, + stavalues2 anyarray, + stavalues3 anyarray, + stavalues4 anyarray, + stavalues5 anyarray, + constraint pg_statistic_relid_att_inh_index + primary key (starelid, staattnum, stainherit) +); + +create table pg_catalog.pg_statistic_ext +( + oid oid not null + constraint pg_statistic_ext_oid_index + primary key, + stxrelid oid not null, + stxname information_schema.sql_identifier not null, + stxnamespace oid not null, + stxowner oid not null, + stxstattarget integer not null, + stxkeys int2vector not null, + stxkind "char"[] not null, + stxexprs pg_node_tree, + constraint pg_statistic_ext_name_index + unique (stxname, stxnamespace) +); + +create index pg_statistic_ext_relid_index + on pg_catalog.pg_statistic_ext (stxrelid); + +create table pg_catalog.pg_statistic_ext_data +( + stxoid oid not null, + stxdinherit boolean not null, + stxdndistinct pg_ndistinct, + stxddependencies pg_dependencies, + stxdmcv pg_mcv_list, + stxdexpr pg_statistic[], + constraint pg_statistic_ext_data_stxoid_inh_index + primary key (stxoid, stxdinherit) +); + +create table pg_catalog.pg_subscription +( + oid oid not null + constraint pg_subscription_oid_index + primary key, + subdbid oid not null, + subskiplsn pg_lsn not null, + subname information_schema.sql_identifier not null, + subowner oid not null, + subenabled boolean not null, + subbinary boolean not null, + substream "char" not null, + subtwophasestate "char" not null, + subdisableonerr boolean not null, + subpasswordrequired boolean not null, + subrunasowner boolean not null, + subconninfo text not null, + subslotname information_schema.sql_identifier, + subsynccommit text not null, + subpublications text[] not null, + suborigin text, + constraint pg_subscription_subname_index + unique (subdbid, subname) +) + tablespace pg_global; + +create table pg_catalog.pg_subscription_rel +( + srsubid oid not null, + srrelid oid not null, + srsubstate "char" not null, + srsublsn pg_lsn, + constraint pg_subscription_rel_srrelid_srsubid_index + primary key (srrelid, srsubid) +); + +create table pg_catalog.pg_tablespace +( + oid oid not null + constraint pg_tablespace_oid_index + primary key, + spcname information_schema.sql_identifier not null + constraint pg_tablespace_spcname_index + unique, + spcowner oid not null, + spcacl aclitem[], + spcoptions text[] +) + tablespace pg_global; + +create table pg_catalog.pg_transform +( + oid oid not null + constraint pg_transform_oid_index + primary key, + trftype oid not null, + trflang oid not null, + trffromsql regproc not null, + trftosql regproc not null, + constraint pg_transform_type_lang_index + unique (trftype, trflang) +); + +create table pg_catalog.pg_trigger +( + oid oid not null + constraint pg_trigger_oid_index + primary key, + tgrelid oid not null, + tgparentid oid not null, + tgname information_schema.sql_identifier not null, + tgfoid oid not null, + tgtype smallint not null, + tgenabled "char" not null, + tgisinternal boolean not null, + tgconstrrelid oid not null, + tgconstrindid oid not null, + tgconstraint oid not null, + tgdeferrable boolean not null, + tginitdeferred boolean not null, + tgnargs smallint not null, + tgattr int2vector not null, + tgargs bytea not null, + tgqual pg_node_tree, + tgoldtable information_schema.sql_identifier, + tgnewtable information_schema.sql_identifier, + constraint pg_trigger_tgrelid_tgname_index + unique (tgrelid, tgname) +); + +create index pg_trigger_tgconstraint_index + on pg_catalog.pg_trigger (tgconstraint); + +create table pg_catalog.pg_ts_config +( + oid oid not null + constraint pg_ts_config_oid_index + primary key, + cfgname information_schema.sql_identifier not null, + cfgnamespace oid not null, + cfgowner oid not null, + cfgparser oid not null, + constraint pg_ts_config_cfgname_index + unique (cfgname, cfgnamespace) +); + +create table pg_catalog.pg_ts_config_map +( + mapcfg oid not null, + maptokentype integer not null, + mapseqno integer not null, + mapdict oid not null, + constraint pg_ts_config_map_index + primary key (mapcfg, maptokentype, mapseqno) +); + +create table pg_catalog.pg_ts_dict +( + oid oid not null + constraint pg_ts_dict_oid_index + primary key, + dictname information_schema.sql_identifier not null, + dictnamespace oid not null, + dictowner oid not null, + dicttemplate oid not null, + dictinitoption text, + constraint pg_ts_dict_dictname_index + unique (dictname, dictnamespace) +); + +create table pg_catalog.pg_ts_parser +( + oid oid not null + constraint pg_ts_parser_oid_index + primary key, + prsname information_schema.sql_identifier not null, + prsnamespace oid not null, + prsstart regproc not null, + prstoken regproc not null, + prsend regproc not null, + prsheadline regproc not null, + prslextype regproc not null, + constraint pg_ts_parser_prsname_index + unique (prsname, prsnamespace) +); + +create table pg_catalog.pg_ts_template +( + oid oid not null + constraint pg_ts_template_oid_index + primary key, + tmplname information_schema.sql_identifier not null, + tmplnamespace oid not null, + tmplinit regproc not null, + tmpllexize regproc not null, + constraint pg_ts_template_tmplname_index + unique (tmplname, tmplnamespace) +); + +create table pg_catalog.pg_type +( + oid oid not null + constraint pg_type_oid_index + primary key, + typname information_schema.sql_identifier not null, + typnamespace oid not null, + typowner oid not null, + typlen smallint not null, + typbyval boolean not null, + typtype "char" not null, + typcategory "char" not null, + typispreferred boolean not null, + typisdefined boolean not null, + typdelim "char" not null, + typrelid oid not null, + typsubscript regproc not null, + typelem oid not null, + typarray oid not null, + typinput regproc not null, + typoutput regproc not null, + typreceive regproc not null, + typsend regproc not null, + typmodin regproc not null, + typmodout regproc not null, + typanalyze regproc not null, + typalign "char" not null, + typstorage "char" not null, + typnotnull boolean not null, + typbasetype oid not null, + typtypmod integer not null, + typndims integer not null, + typcollation oid not null, + typdefaultbin pg_node_tree, + typdefault text, + typacl aclitem[], + constraint pg_type_typname_nsp_index + unique (typname, typnamespace) +); + +create table pg_catalog.pg_user_mapping +( + oid oid not null + constraint pg_user_mapping_oid_index + primary key, + umuser oid not null, + umserver oid not null, + umoptions text[], + constraint pg_user_mapping_user_server_index + unique (umuser, umserver) +); + +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._pg_foreign_data_wrappers + (oid, fdwowner, fdwoptions, foreign_data_wrapper_catalog, foreign_data_wrapper_name, + authorization_identifier, foreign_data_wrapper_language) +as +-- missing source code +; + +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 +-- missing source code +; + +create view information_schema._pg_foreign_table_columns(nspname, relname, attname, attfdwoptions) as +-- missing source code +; + +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 +-- missing source code +; + +create view information_schema._pg_user_mappings + (oid, umoptions, umuser, authorization_identifier, foreign_server_catalog, foreign_server_name, srvowner) as +-- missing source code +; + +create view information_schema.administrable_role_authorizations(grantee, role_name, is_grantable) as +-- missing source code +; + +create view information_schema.applicable_roles(grantee, role_name, is_grantable) as +-- missing source code +; + +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 +-- missing source code +; + +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 +-- missing source code +; + +create view information_schema.check_constraint_routine_usage + (constraint_catalog, constraint_schema, constraint_name, specific_catalog, specific_schema, + specific_name) as +-- missing source code +; + +create view information_schema.check_constraints(constraint_catalog, constraint_schema, constraint_name, check_clause) as +-- missing source code +; + +create view information_schema.collation_character_set_applicability + (collation_catalog, collation_schema, collation_name, character_set_catalog, character_set_schema, + character_set_name) as +-- missing source code +; + +create view information_schema.collations(collation_catalog, collation_schema, collation_name, pad_attribute) as +-- missing source code +; + +create view information_schema.column_column_usage + (table_catalog, table_schema, table_name, column_name, dependent_column) as +-- missing source code +; + +create view information_schema.column_domain_usage + (domain_catalog, domain_schema, domain_name, table_catalog, table_schema, table_name, column_name) as +-- missing source code +; + +create view information_schema.column_options + (table_catalog, table_schema, table_name, column_name, option_name, option_value) as +-- missing source code +; + +create view information_schema.column_privileges + (grantor, grantee, table_catalog, table_schema, table_name, column_name, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.column_udt_usage + (udt_catalog, udt_schema, udt_name, table_catalog, table_schema, table_name, column_name) as +-- missing source code +; + +create view information_schema.columns + (table_catalog, table_schema, table_name, column_name, ordinal_position, column_default, is_nullable, + data_type, character_maximum_length, character_octet_length, numeric_precision, numeric_precision_radix, + numeric_scale, datetime_precision, interval_type, interval_precision, character_set_catalog, + character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, + domain_catalog, domain_schema, domain_name, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, + scope_name, maximum_cardinality, dtd_identifier, is_self_referencing, is_identity, identity_generation, + identity_start, identity_increment, identity_maximum, identity_minimum, identity_cycle, is_generated, + generation_expression, is_updatable) +as +-- missing source code +; + +create view information_schema.constraint_column_usage + (table_catalog, table_schema, table_name, column_name, constraint_catalog, constraint_schema, + constraint_name) as +-- missing source code +; + +create view information_schema.constraint_table_usage + (table_catalog, table_schema, table_name, constraint_catalog, constraint_schema, constraint_name) as +-- missing source code +; + +create view information_schema.data_type_privileges + (object_catalog, object_schema, object_name, object_type, dtd_identifier) as +-- missing source code +; + +create view information_schema.domain_constraints + (constraint_catalog, constraint_schema, constraint_name, domain_catalog, domain_schema, domain_name, + is_deferrable, initially_deferred) +as +-- missing source code +; + +create view information_schema.domain_udt_usage + (udt_catalog, udt_schema, udt_name, domain_catalog, domain_schema, domain_name) as +-- missing source code +; + +create view information_schema.domains + (domain_catalog, domain_schema, domain_name, 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, domain_default, udt_catalog, udt_schema, udt_name, scope_catalog, + scope_schema, scope_name, maximum_cardinality, dtd_identifier) +as +-- missing source code +; + +create view information_schema.element_types + (object_catalog, object_schema, object_name, object_type, collection_type_identifier, 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, + domain_default, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, + maximum_cardinality, dtd_identifier) +as +-- missing source code +; + +create view information_schema.enabled_roles(role_name) as +-- missing source code +; + +create view information_schema.foreign_data_wrapper_options + (foreign_data_wrapper_catalog, foreign_data_wrapper_name, option_name, option_value) as +-- missing source code +; + +create view information_schema.foreign_data_wrappers + (foreign_data_wrapper_catalog, foreign_data_wrapper_name, authorization_identifier, library_name, + foreign_data_wrapper_language) +as +-- missing source code +; + +create view information_schema.foreign_server_options + (foreign_server_catalog, foreign_server_name, option_name, option_value) as +-- missing source code +; + +create view information_schema.foreign_servers + (foreign_server_catalog, foreign_server_name, foreign_data_wrapper_catalog, foreign_data_wrapper_name, + foreign_server_type, foreign_server_version, authorization_identifier) +as +-- missing source code +; + +create view information_schema.foreign_table_options + (foreign_table_catalog, foreign_table_schema, foreign_table_name, option_name, option_value) as +-- missing source code +; + +create view information_schema.foreign_tables + (foreign_table_catalog, foreign_table_schema, foreign_table_name, foreign_server_catalog, + foreign_server_name) as +-- missing source code +; + +create view information_schema.information_schema_catalog_name(catalog_name) as +-- missing source code +; + +create view information_schema.key_column_usage + (constraint_catalog, constraint_schema, constraint_name, table_catalog, table_schema, table_name, + column_name, ordinal_position, position_in_unique_constraint) +as +-- missing source code +; + +create view information_schema.parameters + (specific_catalog, specific_schema, specific_name, ordinal_position, parameter_mode, is_result, as_locator, + parameter_name, 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, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, + maximum_cardinality, dtd_identifier, parameter_default) +as +-- missing source code +; + +create view pg_catalog.pg_available_extension_versions + (name, version, installed, superuser, trusted, relocatable, schema, requires, comment) as +-- missing source code +; + +create view pg_catalog.pg_available_extensions(name, default_version, installed_version, comment) as +-- missing source code +; + +create view pg_catalog.pg_backend_memory_contexts + (name, ident, parent, level, total_bytes, total_nblocks, free_bytes, free_chunks, used_bytes) as +-- missing source code +; + +create view pg_catalog.pg_config(name, setting) as +-- missing source code +; + +create view pg_catalog.pg_cursors(name, statement, is_holdable, is_binary, is_scrollable, creation_time) as +-- missing source code +; + +create view pg_catalog.pg_file_settings(sourcefile, sourceline, seqno, name, setting, applied, error) as +-- missing source code +; + +create view pg_catalog.pg_group(groname, grosysid, grolist) as +-- missing source code +; + +create view pg_catalog.pg_hba_file_rules + (rule_number, file_name, line_number, type, database, user_name, address, netmask, auth_method, options, + error) as +-- missing source code +; + +create view pg_catalog.pg_ident_file_mappings + (map_number, file_name, line_number, map_name, sys_name, pg_username, error) as +-- missing source code +; + +create view pg_catalog.pg_indexes(schemaname, tablename, indexname, tablespace, indexdef) as +-- missing source code +; + +create view pg_catalog.pg_locks + (locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, + virtualtransaction, pid, mode, granted, fastpath, waitstart) +as +-- missing source code +; + +create view pg_catalog.pg_matviews + (schemaname, matviewname, matviewowner, tablespace, hasindexes, ispopulated, definition) as +-- missing source code +; + +create view pg_catalog.pg_policies (schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check) as +-- missing source code +; + +create view pg_catalog.pg_prepared_statements + (name, statement, prepare_time, parameter_types, result_types, from_sql, generic_plans, custom_plans) as +-- missing source code +; + +create view pg_catalog.pg_prepared_xacts(transaction, gid, prepared, owner, database) as +-- missing source code +; + +create view pg_catalog.pg_publication_tables(pubname, schemaname, tablename, attnames, rowfilter) as +-- missing source code +; + +create view pg_catalog.pg_replication_origin_status(local_id, external_id, remote_lsn, local_lsn) as +-- missing source code +; + +create view pg_catalog.pg_replication_slots + (slot_name, plugin, slot_type, datoid, database, temporary, active, active_pid, xmin, catalog_xmin, + restart_lsn, confirmed_flush_lsn, wal_status, safe_wal_size, two_phase, conflicting) +as +-- missing source code +; + +create view pg_catalog.pg_roles + (rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolconnlimit, + rolpassword, rolvaliduntil, rolbypassrls, rolconfig, oid) +as +-- missing source code +; + +create view pg_catalog.pg_rules(schemaname, tablename, rulename, definition) as +-- missing source code +; + +create view pg_catalog.pg_seclabels (objoid, classoid, objsubid, objtype, objnamespace, objname, provider, label) as +-- missing source code +; + +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 +-- missing source code +; + +create view pg_catalog.pg_settings + (name, setting, unit, category, short_desc, extra_desc, context, vartype, source, min_val, max_val, + enumvals, boot_val, reset_val, sourcefile, sourceline, pending_restart) +as +-- missing source code +; + +create view pg_catalog.pg_shadow + (usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, passwd, valuntil, useconfig) as +-- missing source code +; + +create view pg_catalog.pg_shmem_allocations(name, "off", size, allocated_size) as +-- missing source code +; + +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 +-- missing source code +; + +create view pg_catalog.pg_stat_all_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, + idx_tup_fetch) as +-- missing source code +; + +create view pg_catalog.pg_stat_all_tables + (relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, + n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, + n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, + vacuum_count, autovacuum_count, analyze_count, autoanalyze_count) +as +-- missing source code +; + +create view pg_catalog.pg_stat_archiver + (archived_count, last_archived_wal, last_archived_time, failed_count, last_failed_wal, last_failed_time, + stats_reset) as +-- missing source code +; + +create view pg_catalog.pg_stat_bgwriter + (checkpoints_timed, checkpoints_req, checkpoint_write_time, checkpoint_sync_time, buffers_checkpoint, + buffers_clean, maxwritten_clean, buffers_backend, buffers_backend_fsync, buffers_alloc, stats_reset) +as +-- missing source code +; + +create view pg_catalog.pg_stat_database + (datid, datname, numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, + tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, checksum_failures, + checksum_last_failure, blk_read_time, blk_write_time, session_time, active_time, idle_in_transaction_time, + sessions, sessions_abandoned, sessions_fatal, sessions_killed, stats_reset) +as +-- missing source code +; + +create view pg_catalog.pg_stat_database_conflicts + (datid, datname, confl_tablespace, confl_lock, confl_snapshot, confl_bufferpin, confl_deadlock, + confl_active_logicalslot) +as +-- missing source code +; + +create view pg_catalog.pg_stat_gssapi(pid, gss_authenticated, principal, encrypted, credentials_delegated) as +-- missing source code +; + +create view pg_catalog.pg_stat_io + (backend_type, object, context, reads, read_time, writes, write_time, writebacks, writeback_time, extends, + extend_time, op_bytes, hits, evictions, reuses, fsyncs, fsync_time, stats_reset) +as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_analyze + (pid, datid, datname, relid, phase, sample_blks_total, sample_blks_scanned, ext_stats_total, + ext_stats_computed, child_tables_total, child_tables_done, current_child_table_relid) +as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_basebackup + (pid, phase, backup_total, backup_streamed, tablespaces_total, tablespaces_streamed) as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_cluster + (pid, datid, datname, relid, command, phase, cluster_index_relid, heap_tuples_scanned, heap_tuples_written, + heap_blks_total, heap_blks_scanned, index_rebuild_count) +as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_copy + (pid, datid, datname, relid, command, type, bytes_processed, bytes_total, tuples_processed, + tuples_excluded) as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_create_index + (pid, datid, datname, relid, index_relid, command, phase, lockers_total, lockers_done, current_locker_pid, + blocks_total, blocks_done, tuples_total, tuples_done, partitions_total, partitions_done) +as +-- missing source code +; + +create view pg_catalog.pg_stat_progress_vacuum + (pid, datid, datname, relid, phase, heap_blks_total, heap_blks_scanned, heap_blks_vacuumed, + index_vacuum_count, max_dead_tuples, num_dead_tuples) +as +-- missing source code +; + +create view pg_catalog.pg_stat_recovery_prefetch + (stats_reset, prefetch, hit, skip_init, skip_new, skip_fpw, skip_rep, wal_distance, block_distance, + io_depth) as +-- missing source code +; + +create view pg_catalog.pg_stat_replication + (pid, usesysid, usename, application_name, client_addr, client_hostname, client_port, backend_start, + backend_xmin, state, sent_lsn, write_lsn, flush_lsn, replay_lsn, write_lag, flush_lag, replay_lag, + sync_priority, sync_state, reply_time) +as +-- missing source code +; + +create view pg_catalog.pg_stat_replication_slots + (slot_name, spill_txns, spill_count, spill_bytes, stream_txns, stream_count, stream_bytes, total_txns, + total_bytes, stats_reset) +as +-- missing source code +; + +create view pg_catalog.pg_stat_slru + (name, blks_zeroed, blks_hit, blks_read, blks_written, blks_exists, flushes, truncates, stats_reset) as +-- missing source code +; + +create view pg_catalog.pg_stat_ssl(pid, ssl, version, cipher, bits, client_dn, client_serial, issuer_dn) as +-- missing source code +; + +create view pg_catalog.pg_stat_subscription + (subid, subname, pid, leader_pid, relid, received_lsn, last_msg_send_time, last_msg_receipt_time, + latest_end_lsn, latest_end_time) +as +-- missing source code +; + +create view pg_catalog.pg_stat_subscription_stats(subid, subname, apply_error_count, sync_error_count, stats_reset) as +-- missing source code +; + +create view pg_catalog.pg_stat_sys_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, + idx_tup_fetch) as +-- missing source code +; + +create view pg_catalog.pg_stat_sys_tables + (relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, + n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, + n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, + vacuum_count, autovacuum_count, analyze_count, autoanalyze_count) +as +-- missing source code +; + +create view pg_catalog.pg_stat_user_functions(funcid, schemaname, funcname, calls, total_time, self_time) as +-- missing source code +; + +create view pg_catalog.pg_stat_user_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, + idx_tup_fetch) as +-- missing source code +; + +create view pg_catalog.pg_stat_user_tables + (relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, + n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, + n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, + vacuum_count, autovacuum_count, analyze_count, autoanalyze_count) +as +-- missing source code +; + +create view pg_catalog.pg_stat_wal + (wal_records, wal_fpi, wal_bytes, wal_buffers_full, wal_write, wal_sync, wal_write_time, wal_sync_time, + stats_reset) as +-- missing source code +; + +create view pg_catalog.pg_stat_wal_receiver + (pid, status, receive_start_lsn, receive_start_tli, written_lsn, flushed_lsn, received_tli, + last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time, slot_name, sender_host, + sender_port, conninfo) +as +-- missing source code +; + +create view pg_catalog.pg_stat_xact_all_tables + (relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, + n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) +as +-- missing source code +; + +create view pg_catalog.pg_stat_xact_sys_tables + (relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, + n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) +as +-- missing source code +; + +create view pg_catalog.pg_stat_xact_user_functions(funcid, schemaname, funcname, calls, total_time, self_time) as +-- missing source code +; + +create view pg_catalog.pg_stat_xact_user_tables + (relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, + n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) +as +-- missing source code +; + +create view pg_catalog.pg_statio_all_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_all_sequences(relid, schemaname, relname, blks_read, blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_all_tables + (relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, + toast_blks_hit, tidx_blks_read, tidx_blks_hit) +as +-- missing source code +; + +create view pg_catalog.pg_statio_sys_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_sys_sequences(relid, schemaname, relname, blks_read, blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_sys_tables + (relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, + toast_blks_hit, tidx_blks_read, tidx_blks_hit) +as +-- missing source code +; + +create view pg_catalog.pg_statio_user_indexes + (relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_user_sequences(relid, schemaname, relname, blks_read, blks_hit) as +-- missing source code +; + +create view pg_catalog.pg_statio_user_tables + (relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, + toast_blks_hit, tidx_blks_read, tidx_blks_hit) +as +-- missing source code +; + +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) +as +-- missing source code +; + +create view pg_catalog.pg_stats_ext + (schemaname, tablename, statistics_schemaname, statistics_name, statistics_owner, attnames, exprs, kinds, + inherited, n_distinct, dependencies, most_common_vals, most_common_val_nulls, most_common_freqs, + most_common_base_freqs) +as +-- missing source code +; + +create view pg_catalog.pg_stats_ext_exprs + (schemaname, tablename, statistics_schemaname, statistics_name, statistics_owner, expr, 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) +as +-- missing source code +; + +create view pg_catalog.pg_tables + (schemaname, tablename, tableowner, tablespace, hasindexes, hasrules, hastriggers, rowsecurity) as +-- missing source code +; + +create view pg_catalog.pg_timezone_abbrevs(abbrev, utc_offset, is_dst) as +-- missing source code +; + +create view pg_catalog.pg_timezone_names(name, abbrev, utc_offset, is_dst) as +-- missing source code +; + +create view pg_catalog.pg_user + (usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, passwd, valuntil, useconfig) as +-- missing source code +; + +create view pg_catalog.pg_user_mappings(umid, srvid, srvname, umuser, usename, umoptions) as +-- missing source code +; + +create view pg_catalog.pg_views(schemaname, viewname, viewowner, definition) as +-- missing source code +; + +create view information_schema.referential_constraints + (constraint_catalog, constraint_schema, constraint_name, unique_constraint_catalog, + unique_constraint_schema, unique_constraint_name, match_option, update_rule, delete_rule) +as +-- missing source code +; + +create view information_schema.role_column_grants + (grantor, grantee, table_catalog, table_schema, table_name, column_name, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.role_routine_grants + (grantor, grantee, specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, + routine_name, privilege_type, is_grantable) +as +-- missing source code +; + +create view information_schema.role_table_grants + (grantor, grantee, table_catalog, table_schema, table_name, privilege_type, is_grantable, with_hierarchy) as +-- missing source code +; + +create view information_schema.role_udt_grants + (grantor, grantee, udt_catalog, udt_schema, udt_name, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.role_usage_grants + (grantor, grantee, object_catalog, object_schema, object_name, object_type, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.routine_column_usage + (specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, + table_catalog, table_schema, table_name, column_name) +as +-- missing source code +; + +create view information_schema.routine_privileges + (grantor, grantee, specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, + routine_name, privilege_type, is_grantable) +as +-- missing source code +; + +create view information_schema.routine_routine_usage + (specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name) as +-- missing source code +; + +create view information_schema.routine_sequence_usage + (specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, + sequence_catalog, sequence_schema, sequence_name) +as +-- missing source code +; + +create view information_schema.routine_table_usage + (specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, + table_catalog, table_schema, table_name) +as +-- missing source code +; + +create view information_schema.routines + (specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, + routine_type, module_catalog, module_schema, module_name, udt_catalog, udt_schema, udt_name, 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, + type_udt_catalog, type_udt_schema, type_udt_name, scope_catalog, scope_schema, scope_name, + maximum_cardinality, dtd_identifier, routine_body, routine_definition, external_name, external_language, + parameter_style, is_deterministic, sql_data_access, is_null_call, sql_path, schema_level_routine, + max_dynamic_result_sets, is_user_defined_cast, is_implicitly_invocable, security_type, + to_sql_specific_catalog, to_sql_specific_schema, to_sql_specific_name, as_locator, created, last_altered, + new_savepoint_level, is_udt_dependent, result_cast_from_data_type, result_cast_as_locator, + result_cast_char_max_length, result_cast_char_octet_length, result_cast_char_set_catalog, + result_cast_char_set_schema, result_cast_char_set_name, result_cast_collation_catalog, + result_cast_collation_schema, result_cast_collation_name, result_cast_numeric_precision, + result_cast_numeric_precision_radix, result_cast_numeric_scale, result_cast_datetime_precision, + result_cast_interval_type, result_cast_interval_precision, result_cast_type_udt_catalog, + result_cast_type_udt_schema, result_cast_type_udt_name, result_cast_scope_catalog, + result_cast_scope_schema, result_cast_scope_name, result_cast_maximum_cardinality, + result_cast_dtd_identifier) +as +-- missing source code +; + +create view information_schema.schemata + (catalog_name, schema_name, schema_owner, default_character_set_catalog, default_character_set_schema, + default_character_set_name, sql_path) +as +-- missing source code +; + +create view information_schema.sequences + (sequence_catalog, sequence_schema, sequence_name, data_type, numeric_precision, numeric_precision_radix, + numeric_scale, start_value, minimum_value, maximum_value, increment, cycle_option) +as +-- missing source code +; + +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 +-- missing source code +; + +create view information_schema.table_privileges + (grantor, grantee, table_catalog, table_schema, table_name, privilege_type, is_grantable, with_hierarchy) as +-- missing source code +; + +create view information_schema.tables + (table_catalog, table_schema, table_name, table_type, self_referencing_column_name, reference_generation, + user_defined_type_catalog, user_defined_type_schema, user_defined_type_name, is_insertable_into, is_typed, + commit_action) +as +-- missing source code +; + +create view information_schema.transforms + (udt_catalog, udt_schema, udt_name, specific_catalog, specific_schema, specific_name, group_name, + transform_type) as +-- missing source code +; + +create view information_schema.triggered_update_columns + (trigger_catalog, trigger_schema, trigger_name, event_object_catalog, event_object_schema, + event_object_table, event_object_column) +as +-- missing source code +; + +create view information_schema.triggers + (trigger_catalog, trigger_schema, trigger_name, event_manipulation, event_object_catalog, + event_object_schema, event_object_table, action_order, action_condition, action_statement, + action_orientation, action_timing, action_reference_old_table, action_reference_new_table, + action_reference_old_row, action_reference_new_row, created) +as +-- missing source code +; + +create view information_schema.udt_privileges + (grantor, grantee, udt_catalog, udt_schema, udt_name, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.usage_privileges + (grantor, grantee, object_catalog, object_schema, object_name, object_type, privilege_type, is_grantable) as +-- missing source code +; + +create view information_schema.user_defined_types + (user_defined_type_catalog, user_defined_type_schema, user_defined_type_name, user_defined_type_category, + is_instantiable, is_final, ordering_form, ordering_category, ordering_routine_catalog, + ordering_routine_schema, ordering_routine_name, reference_type, 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, source_dtd_identifier, ref_dtd_identifier) +as +-- missing source code +; + +create view information_schema.user_mapping_options + (authorization_identifier, foreign_server_catalog, foreign_server_name, option_name, option_value) as +-- missing source code +; + +create view information_schema.user_mappings(authorization_identifier, foreign_server_catalog, foreign_server_name) as +-- missing source code +; + +create view information_schema.view_column_usage + (view_catalog, view_schema, view_name, table_catalog, table_schema, table_name, column_name) as +-- missing source code +; + +create view information_schema.view_routine_usage + (table_catalog, table_schema, table_name, specific_catalog, specific_schema, specific_name) as +-- missing source code +; + +create view information_schema.view_table_usage + (view_catalog, view_schema, view_name, table_catalog, table_schema, table_name) as +-- missing source code +; + +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 +-- missing source code +; + +create function public.digest(text, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.digest(text, text) owner to postgres; + +create function public.digest(bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.digest(bytea, text) owner to postgres; + +create function public.hmac(text, text, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.hmac(text, text, text) owner to postgres; + +create function public.hmac(bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.hmac(bytea, bytea, text) owner to postgres; + +create function public.crypt(text, text) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.crypt(text, text) owner to postgres; + +create function public.gen_salt(text) returns text + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.gen_salt(text) owner to postgres; + +create function public.gen_salt(text, integer) returns text + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.gen_salt(text, integer) owner to postgres; + +create function public.encrypt(bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.encrypt(bytea, bytea, text) owner to postgres; + +create function public.decrypt(bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.decrypt(bytea, bytea, text) owner to postgres; + +create function public.encrypt_iv(bytea, bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.encrypt_iv(bytea, bytea, bytea, text) owner to postgres; + +create function public.decrypt_iv(bytea, bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.decrypt_iv(bytea, bytea, bytea, text) owner to postgres; + +create function public.gen_random_bytes(integer) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.gen_random_bytes(integer) owner to postgres; + +create function public.gen_random_uuid() returns uuid + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.gen_random_uuid() owner to postgres; + +create function public.pgp_sym_encrypt(text, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_encrypt(text, text) owner to postgres; + +create function public.pgp_sym_encrypt_bytea(bytea, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_encrypt_bytea(bytea, text) owner to postgres; + +create function public.pgp_sym_encrypt(text, text, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_encrypt(text, text, text) owner to postgres; + +create function public.pgp_sym_encrypt_bytea(bytea, text, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_encrypt_bytea(bytea, text, text) owner to postgres; + +create function public.pgp_sym_decrypt(bytea, text) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_decrypt(bytea, text) owner to postgres; + +create function public.pgp_sym_decrypt_bytea(bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_decrypt_bytea(bytea, text) owner to postgres; + +create function public.pgp_sym_decrypt(bytea, text, text) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_decrypt(bytea, text, text) owner to postgres; + +create function public.pgp_sym_decrypt_bytea(bytea, text, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_sym_decrypt_bytea(bytea, text, text) owner to postgres; + +create function public.pgp_pub_encrypt(text, bytea) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_encrypt(text, bytea) owner to postgres; + +create function public.pgp_pub_encrypt_bytea(bytea, bytea) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_encrypt_bytea(bytea, bytea) owner to postgres; + +create function public.pgp_pub_encrypt(text, bytea, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_encrypt(text, bytea, text) owner to postgres; + +create function public.pgp_pub_encrypt_bytea(bytea, bytea, text) returns bytea + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_encrypt_bytea(bytea, bytea, text) owner to postgres; + +create function public.pgp_pub_decrypt(bytea, bytea) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt(bytea, bytea) owner to postgres; + +create function public.pgp_pub_decrypt_bytea(bytea, bytea) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt_bytea(bytea, bytea) owner to postgres; + +create function public.pgp_pub_decrypt(bytea, bytea, text) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt(bytea, bytea, text) owner to postgres; + +create function public.pgp_pub_decrypt_bytea(bytea, bytea, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt_bytea(bytea, bytea, text) owner to postgres; + +create function public.pgp_pub_decrypt(bytea, bytea, text, text) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt(bytea, bytea, text, text) owner to postgres; + +create function public.pgp_pub_decrypt_bytea(bytea, bytea, text, text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_pub_decrypt_bytea(bytea, bytea, text, text) owner to postgres; + +create function public.pgp_key_id(bytea) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_key_id(bytea) owner to postgres; + +create function public.armor(bytea) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.armor(bytea) owner to postgres; + +create function public.armor(bytea, text[], text[]) returns text + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.armor(bytea, text[], text[]) owner to postgres; + +create function public.dearmor(text) returns bytea + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.dearmor(text) owner to postgres; + +create function public.pgp_armor_headers(text, out key text, out value text) returns setof record + immutable + strict + parallel safe + language c +as +$$ +begin +-- missing source code +end; +$$; + +alter function public.pgp_armor_headers(text, out text, out text) owner to postgres; + +create function public.update_updated_at_column() returns trigger + language plpgsql +as +$$ +BEGIN + NEW.updated_at = CURRENT_TIMESTAMP; +RETURN NEW; +END; +$$; + +alter function public.update_updated_at_column() owner to postgres; + +create function pg_catalog."RI_FKey_cascade_del"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_cascade_del"() is 'referential integrity ON DELETE CASCADE'; + +create function pg_catalog."RI_FKey_cascade_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_cascade_upd"() is 'referential integrity ON UPDATE CASCADE'; + +create function pg_catalog."RI_FKey_check_ins"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_check_ins"() is 'referential integrity FOREIGN KEY ... REFERENCES'; + +create function pg_catalog."RI_FKey_check_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_check_upd"() is 'referential integrity FOREIGN KEY ... REFERENCES'; + +create function pg_catalog."RI_FKey_noaction_del"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_noaction_del"() is 'referential integrity ON DELETE NO ACTION'; + +create function pg_catalog."RI_FKey_noaction_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_noaction_upd"() is 'referential integrity ON UPDATE NO ACTION'; + +create function pg_catalog."RI_FKey_restrict_del"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_restrict_del"() is 'referential integrity ON DELETE RESTRICT'; + +create function pg_catalog."RI_FKey_restrict_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_restrict_upd"() is 'referential integrity ON UPDATE RESTRICT'; + +create function pg_catalog."RI_FKey_setdefault_del"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_setdefault_del"() is 'referential integrity ON DELETE SET DEFAULT'; + +create function pg_catalog."RI_FKey_setdefault_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_setdefault_upd"() is 'referential integrity ON UPDATE SET DEFAULT'; + +create function pg_catalog."RI_FKey_setnull_del"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_setnull_del"() is 'referential integrity ON DELETE SET NULL'; + +create function pg_catalog."RI_FKey_setnull_upd"() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."RI_FKey_setnull_upd"() is 'referential integrity ON UPDATE SET NULL'; + +create function information_schema._pg_char_max_length(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_char_octet_length(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_datetime_precision(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_expandarray(anyarray, out x anyelement, out n integer) returns setof record + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_index_position(oid, smallint) returns integer + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_interval_type(typid oid, mod integer) returns text + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_numeric_precision(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_numeric_precision_radix(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_numeric_scale(typid oid, typmod integer) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_truetypid(pg_attribute, pg_type) returns oid + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function information_schema._pg_truetypmod(pg_attribute, pg_type) returns integer + immutable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.abbrev(cidr) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abbrev(cidr) is 'abbreviated display of cidr value'; + +create function pg_catalog.abbrev(inet) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abbrev(inet) is 'abbreviated display of inet value'; + +create function pg_catalog.abs(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(bigint) is 'absolute value'; + +create function pg_catalog.abs(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(double precision) is 'absolute value'; + +create function pg_catalog.abs(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(integer) is 'absolute value'; + +create function pg_catalog.abs(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(numeric) is 'absolute value'; + +create function pg_catalog.abs(real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(real) is 'absolute value'; + +create function pg_catalog.abs(smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.abs(smallint) is 'absolute value'; + +create function pg_catalog.aclcontains(aclitem[], aclitem) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclcontains(aclitem[], aclitem) is 'contains'; + +create function pg_catalog.acldefault("char", oid) returns aclitem[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.acldefault("char", oid) is 'show hardwired default privileges, primarily for use by the information schema'; + +create function pg_catalog.aclexplode(acl aclitem[], out grantor oid, out grantee oid, out privilege_type text, out is_grantable boolean) returns setof record + stable + strict + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclexplode(aclitem[], out oid, out oid, out text, out boolean) is 'convert ACL item array to table, primarily for use by information schema'; + +create function pg_catalog.aclinsert(aclitem[], aclitem) returns aclitem[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclinsert(aclitem[], aclitem) is 'add/update ACL item'; + +create function pg_catalog.aclitemeq(aclitem, aclitem) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclitemeq(aclitem, aclitem) is 'implementation of = operator'; + +create function pg_catalog.aclitemin(cstring) returns aclitem + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclitemin(cstring) is 'I/O'; + +create function pg_catalog.aclitemout(aclitem) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclitemout(aclitem) is 'I/O'; + +create function pg_catalog.aclremove(aclitem[], aclitem) returns aclitem[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.aclremove(aclitem[], aclitem) is 'remove ACL item'; + +create function pg_catalog.acos(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.acos(double precision) is 'arccosine'; + +create function pg_catalog.acosd(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.acosd(double precision) is 'arccosine, degrees'; + +create function pg_catalog.acosh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.acosh(double precision) is 'inverse hyperbolic cosine'; + +create function pg_catalog.age(timestamp with time zone) returns interval + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.age(timestamp with time zone) is 'date difference from today preserving months and years'; + +create function pg_catalog.age(timestamp with time zone, timestamp with time zone) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.age(timestamp with time zone, timestamp with time zone) is 'date difference preserving months and years'; + +create function pg_catalog.age(timestamp) returns interval + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.age(timestamp) is 'date difference from today preserving months and years'; + +create function pg_catalog.age(timestamp, timestamp) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.age(timestamp, timestamp) is 'date difference preserving months and years'; + +create function pg_catalog.age(xid) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.age(xid) is 'age of a transaction ID, in transactions before current transaction'; + +create function pg_catalog.amvalidate(oid) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.amvalidate(oid) is 'validate an operator class'; + +create function pg_catalog.any_in(cstring) returns "any" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.any_in(cstring) is 'I/O'; + +create function pg_catalog.any_out("any") returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.any_out("any") is 'I/O'; + +create function pg_catalog.any_value_transfn(anyelement, anyelement) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.any_value_transfn(anyelement, anyelement) is 'aggregate transition function'; + +create function pg_catalog.anyarray_in(cstring) returns anyarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyarray_in(cstring) is 'I/O'; + +create function pg_catalog.anyarray_out(anyarray) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyarray_out(anyarray) is 'I/O'; + +create function pg_catalog.anyarray_recv(internal) returns anyarray + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyarray_recv(internal) is 'I/O'; + +create function pg_catalog.anyarray_send(anyarray) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyarray_send(anyarray) is 'I/O'; + +create function pg_catalog.anycompatible_in(cstring) returns anycompatible + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatible_in(cstring) is 'I/O'; + +create function pg_catalog.anycompatible_out(anycompatible) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatible_out(anycompatible) is 'I/O'; + +create function pg_catalog.anycompatiblearray_in(cstring) returns anycompatiblearray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblearray_in(cstring) is 'I/O'; + +create function pg_catalog.anycompatiblearray_out(anycompatiblearray) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblearray_out(anycompatiblearray) is 'I/O'; + +create function pg_catalog.anycompatiblearray_recv(internal) returns anycompatiblearray + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblearray_recv(internal) is 'I/O'; + +create function pg_catalog.anycompatiblearray_send(anycompatiblearray) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblearray_send(anycompatiblearray) is 'I/O'; + +create function pg_catalog.anycompatiblemultirange_in(cstring, oid, integer) returns anycompatiblemultirange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblemultirange_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.anycompatiblemultirange_out(anycompatiblemultirange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblemultirange_out(anycompatiblemultirange) is 'I/O'; + +create function pg_catalog.anycompatiblenonarray_in(cstring) returns anycompatiblenonarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblenonarray_in(cstring) is 'I/O'; + +create function pg_catalog.anycompatiblenonarray_out(anycompatiblenonarray) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblenonarray_out(anycompatiblenonarray) is 'I/O'; + +create function pg_catalog.anycompatiblerange_in(cstring, oid, integer) returns anycompatiblerange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblerange_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.anycompatiblerange_out(anycompatiblerange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anycompatiblerange_out(anycompatiblerange) is 'I/O'; + +create function pg_catalog.anyelement_in(cstring) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyelement_in(cstring) is 'I/O'; + +create function pg_catalog.anyelement_out(anyelement) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyelement_out(anyelement) is 'I/O'; + +create function pg_catalog.anyenum_in(cstring) returns anyenum + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyenum_in(cstring) is 'I/O'; + +create function pg_catalog.anyenum_out(anyenum) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyenum_out(anyenum) is 'I/O'; + +create function pg_catalog.anymultirange_in(cstring, oid, integer) returns anymultirange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anymultirange_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.anymultirange_out(anymultirange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anymultirange_out(anymultirange) is 'I/O'; + +create function pg_catalog.anynonarray_in(cstring) returns anynonarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anynonarray_in(cstring) is 'I/O'; + +create function pg_catalog.anynonarray_out(anynonarray) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anynonarray_out(anynonarray) is 'I/O'; + +create function pg_catalog.anyrange_in(cstring, oid, integer) returns anyrange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyrange_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.anyrange_out(anyrange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anyrange_out(anyrange) is 'I/O'; + +create function pg_catalog.anytextcat(anynonarray, text) returns text + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.anytextcat(anynonarray, text) is 'implementation of || operator'; + +create function pg_catalog.area(box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.area(box) is 'box area'; + +create function pg_catalog.area(circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.area(circle) is 'area of circle'; + +create function pg_catalog.area(path) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.area(path) is 'area of a closed path'; + +create function pg_catalog.areajoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.areajoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for area-comparison operators'; + +create function pg_catalog.areasel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.areasel(internal, oid, internal, integer) is 'restriction selectivity for area-comparison operators'; + +create function pg_catalog.array_agg_array_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_array_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.array_agg_array_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_array_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.array_agg_array_finalfn(internal, anyarray) returns anyarray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_array_finalfn(internal, anyarray) is 'aggregate final function'; + +create function pg_catalog.array_agg_array_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_array_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.array_agg_array_transfn(internal, anyarray) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_array_transfn(internal, anyarray) is 'aggregate transition function'; + +create function pg_catalog.array_agg_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.array_agg_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.array_agg_finalfn(internal, anynonarray) returns anyarray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_finalfn(internal, anynonarray) is 'aggregate final function'; + +create function pg_catalog.array_agg_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.array_agg_transfn(internal, anynonarray) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_agg_transfn(internal, anynonarray) is 'aggregate transition function'; + +create function pg_catalog.array_append(anycompatiblearray, anycompatible) returns anycompatiblearray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_append(anycompatiblearray, anycompatible) is 'append element onto end of array'; + +create function pg_catalog.array_cat(anycompatiblearray, anycompatiblearray) returns anycompatiblearray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_cat(anycompatiblearray, anycompatiblearray) is 'implementation of || operator'; + +create function pg_catalog.array_dims(anyarray) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_dims(anyarray) is 'array dimensions'; + +create function pg_catalog.array_eq(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_eq(anyarray, anyarray) is 'implementation of = operator'; + +create function pg_catalog.array_fill(anyelement, integer[]) returns anyarray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_fill(anyelement, integer[]) is 'array constructor with value'; + +create function pg_catalog.array_fill(anyelement, integer[], integer[]) returns anyarray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_fill(anyelement, integer[], integer[]) is 'array constructor with value'; + +create function pg_catalog.array_ge(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_ge(anyarray, anyarray) is 'implementation of >= operator'; + +create function pg_catalog.array_gt(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_gt(anyarray, anyarray) is 'implementation of > operator'; + +create function pg_catalog.array_in(cstring, oid, integer) returns anyarray + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.array_larger(anyarray, anyarray) returns anyarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_larger(anyarray, anyarray) is 'larger of two'; + +create function pg_catalog.array_le(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_le(anyarray, anyarray) is 'implementation of <= operator'; + +create function pg_catalog.array_length(anyarray, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_length(anyarray, integer) is 'array length'; + +create function pg_catalog.array_lower(anyarray, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_lower(anyarray, integer) is 'array lower dimension'; + +create function pg_catalog.array_lt(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_lt(anyarray, anyarray) is 'implementation of < operator'; + +create function pg_catalog.array_ndims(anyarray) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_ndims(anyarray) is 'number of array dimensions'; + +create function pg_catalog.array_ne(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_ne(anyarray, anyarray) is 'implementation of <> operator'; + +create function pg_catalog.array_out(anyarray) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_out(anyarray) is 'I/O'; + +create function pg_catalog.array_position(anycompatiblearray, anycompatible) returns integer + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_position(anycompatiblearray, anycompatible) is 'returns an offset of value in array'; + +create function pg_catalog.array_position(anycompatiblearray, anycompatible, integer) returns integer + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_position(anycompatiblearray, anycompatible, integer) is 'returns an offset of value in array with start index'; + +create function pg_catalog.array_positions(anycompatiblearray, anycompatible) returns integer[] + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_positions(anycompatiblearray, anycompatible) is 'returns an array of offsets of some value in array'; + +create function pg_catalog.array_prepend(anycompatible, anycompatiblearray) returns anycompatiblearray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_prepend(anycompatible, anycompatiblearray) is 'prepend element onto front of array'; + +create function pg_catalog.array_recv(internal, oid, integer) returns anyarray + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.array_remove(anycompatiblearray, anycompatible) returns anycompatiblearray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_remove(anycompatiblearray, anycompatible) is 'remove any occurrences of an element from an array'; + +create function pg_catalog.array_replace(anycompatiblearray, anycompatible, anycompatible) returns anycompatiblearray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_replace(anycompatiblearray, anycompatible, anycompatible) is 'replace any occurrences of an element in an array'; + +create function pg_catalog.array_sample(anyarray, integer) returns anyarray + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_sample(anyarray, integer) is 'take samples from array'; + +create function pg_catalog.array_send(anyarray) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_send(anyarray) is 'I/O'; + +create function pg_catalog.array_shuffle(anyarray) returns anyarray + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_shuffle(anyarray) is 'shuffle array'; + +create function pg_catalog.array_smaller(anyarray, anyarray) returns anyarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_smaller(anyarray, anyarray) is 'smaller of two'; + +create function pg_catalog.array_subscript_handler(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_subscript_handler(internal) is 'standard array subscripting support'; + +create function pg_catalog.array_to_json(anyarray) returns json + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_to_json(anyarray) is 'map array to json'; + +create function pg_catalog.array_to_json(anyarray, boolean) returns json + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_to_json(anyarray, boolean) is 'map array to json with optional pretty printing'; + +create function pg_catalog.array_to_string(anyarray, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_to_string(anyarray, text) is 'concatenate array elements, using delimiter, into text'; + +create function pg_catalog.array_to_string(anyarray, text, text) returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_to_string(anyarray, text, text) is 'concatenate array elements, using delimiter and null string, into text'; + +create function pg_catalog.array_to_tsvector(text[]) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_to_tsvector(text[]) is 'build tsvector from array of lexemes'; + +create function pg_catalog.array_typanalyze(internal) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_typanalyze(internal) is 'array typanalyze'; + +create function pg_catalog.array_unnest_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_unnest_support(internal) is 'planner support for array_unnest'; + +create function pg_catalog.array_upper(anyarray, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.array_upper(anyarray, integer) is 'array upper dimension'; + +create function pg_catalog.arraycontained(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.arraycontained(anyarray, anyarray) is 'implementation of <@ operator'; + +create function pg_catalog.arraycontains(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.arraycontains(anyarray, anyarray) is 'implementation of @> operator'; + +create function pg_catalog.arraycontjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.arraycontjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for array-containment operators'; + +create function pg_catalog.arraycontsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.arraycontsel(internal, oid, internal, integer) is 'restriction selectivity for array-containment operators'; + +create function pg_catalog.arrayoverlap(anyarray, anyarray) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.arrayoverlap(anyarray, anyarray) is 'implementation of && operator'; + +create function pg_catalog.ascii(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ascii(text) is 'convert first char to int4'; + +create function pg_catalog.asin(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.asin(double precision) is 'arcsine'; + +create function pg_catalog.asind(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.asind(double precision) is 'arcsine, degrees'; + +create function pg_catalog.asinh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.asinh(double precision) is 'inverse hyperbolic sine'; + +create function pg_catalog.atan(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.atan(double precision) is 'arctangent'; + +create function pg_catalog.atan2(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.atan2(double precision, double precision) is 'arctangent, two arguments'; + +create function pg_catalog.atan2d(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.atan2d(double precision, double precision) is 'arctangent, two arguments, degrees'; + +create function pg_catalog.atand(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.atand(double precision) is 'arctangent, degrees'; + +create function pg_catalog.atanh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.atanh(double precision) is 'inverse hyperbolic tangent'; + +create function pg_catalog.bernoulli(internal) returns tsm_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bernoulli(internal) is 'BERNOULLI tablesample method handler'; + +create function pg_catalog.big5_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.big5_to_euc_tw(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for BIG5 to EUC_TW'; + +create function pg_catalog.big5_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.big5_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for BIG5 to MULE_INTERNAL'; + +create function pg_catalog.big5_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.big5_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for BIG5 to UTF8'; + +create function pg_catalog.binary_upgrade_create_empty_extension(text, text, boolean, text, oid[], text[], text[]) returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_create_empty_extension(text, text, boolean, text, oid[], text[], text[]) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_missing_value(oid, text, text) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_missing_value(oid, text, text) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_array_pg_type_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_array_pg_type_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_heap_pg_class_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_heap_pg_class_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_heap_relfilenode(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_heap_relfilenode(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_index_pg_class_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_index_pg_class_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_index_relfilenode(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_index_relfilenode(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_pg_authid_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_pg_authid_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_pg_enum_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_pg_enum_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_pg_tablespace_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_pg_tablespace_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_pg_type_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_pg_type_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_toast_pg_class_oid(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_toast_pg_class_oid(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_next_toast_relfilenode(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_next_toast_relfilenode(oid) is 'for use by pg_upgrade'; + +create function pg_catalog.binary_upgrade_set_record_init_privs(boolean) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.binary_upgrade_set_record_init_privs(boolean) is 'for use by pg_upgrade'; + +create function pg_catalog.bit(bigint, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit(bigint, integer) is 'convert int8 to bitstring'; + +create function pg_catalog.bit(bit, integer, boolean) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit(bit, integer, boolean) is 'adjust bit() to typmod length'; + +create function pg_catalog.bit(integer, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit(integer, integer) is 'convert int4 to bitstring'; + +create function pg_catalog.bit_count(bit) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_count(bit) is 'number of set bits'; + +create function pg_catalog.bit_count(bytea) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_count(bytea) is 'number of set bits'; + +create function pg_catalog.bit_in(cstring, oid, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.bit_length(bit) returns integer + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_length(bit) is 'length in bits'; + +create function pg_catalog.bit_length(bytea) returns integer + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_length(bytea) is 'length in bits'; + +create function pg_catalog.bit_length(text) returns integer + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_length(text) is 'length in bits'; + +create function pg_catalog.bit_out(bit) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_out(bit) is 'I/O'; + +create function pg_catalog.bit_recv(internal, oid, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.bit_send(bit) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bit_send(bit) is 'I/O'; + +create function pg_catalog.bitand(bit, bit) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitand(bit, bit) is 'implementation of & operator'; + +create function pg_catalog.bitcat(bit varying, bit varying) returns bit varying + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitcat(bit varying, bit varying) is 'implementation of || operator'; + +create function pg_catalog.bitcmp(bit, bit) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitcmp(bit, bit) is 'less-equal-greater'; + +create function pg_catalog.biteq(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.biteq(bit, bit) is 'implementation of = operator'; + +create function pg_catalog.bitge(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitge(bit, bit) is 'implementation of >= operator'; + +create function pg_catalog.bitgt(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitgt(bit, bit) is 'implementation of > operator'; + +create function pg_catalog.bitle(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitle(bit, bit) is 'implementation of <= operator'; + +create function pg_catalog.bitlt(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitlt(bit, bit) is 'implementation of < operator'; + +create function pg_catalog.bitne(bit, bit) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitne(bit, bit) is 'implementation of <> operator'; + +create function pg_catalog.bitnot(bit) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitnot(bit) is 'implementation of ~ operator'; + +create function pg_catalog.bitor(bit, bit) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitor(bit, bit) is 'implementation of | operator'; + +create function pg_catalog.bitshiftleft(bit, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitshiftleft(bit, integer) is 'implementation of << operator'; + +create function pg_catalog.bitshiftright(bit, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitshiftright(bit, integer) is 'implementation of >> operator'; + +create function pg_catalog.bittypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bittypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.bittypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bittypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.bitxor(bit, bit) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bitxor(bit, bit) is 'implementation of # operator'; + +create function pg_catalog.bool(integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool(integer) is 'convert int4 to boolean'; + +create function pg_catalog.bool(jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool(jsonb) is 'convert jsonb to boolean'; + +create function pg_catalog.bool_accum(internal, boolean) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool_accum(internal, boolean) is 'aggregate transition function'; + +create function pg_catalog.bool_accum_inv(internal, boolean) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool_accum_inv(internal, boolean) is 'aggregate transition function'; + +create function pg_catalog.bool_alltrue(internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool_alltrue(internal) is 'aggregate final function'; + +create function pg_catalog.bool_anytrue(internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bool_anytrue(internal) is 'aggregate final function'; + +create function pg_catalog.booland_statefunc(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.booland_statefunc(boolean, boolean) is 'aggregate transition function'; + +create function pg_catalog.booleq(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.booleq(boolean, boolean) is 'implementation of = operator'; + +create function pg_catalog.boolge(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolge(boolean, boolean) is 'implementation of >= operator'; + +create function pg_catalog.boolgt(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolgt(boolean, boolean) is 'implementation of > operator'; + +create function pg_catalog.boolin(cstring) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolin(cstring) is 'I/O'; + +create function pg_catalog.boolle(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolle(boolean, boolean) is 'implementation of <= operator'; + +create function pg_catalog.boollt(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boollt(boolean, boolean) is 'implementation of < operator'; + +create function pg_catalog.boolne(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolne(boolean, boolean) is 'implementation of <> operator'; + +create function pg_catalog.boolor_statefunc(boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolor_statefunc(boolean, boolean) is 'aggregate transition function'; + +create function pg_catalog.boolout(boolean) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolout(boolean) is 'I/O'; + +create function pg_catalog.boolrecv(internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolrecv(internal) is 'I/O'; + +create function pg_catalog.boolsend(boolean) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.boolsend(boolean) is 'I/O'; + +create function pg_catalog.bound_box(box, box) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bound_box(box, box) is 'bounding box of two boxes'; + +create function pg_catalog.box(circle) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box(circle) is 'convert circle to box'; + +create function pg_catalog.box(point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box(point) is 'convert point to empty box'; + +create function pg_catalog.box(point, point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box(point, point) is 'convert points to box'; + +create function pg_catalog.box(polygon) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box(polygon) is 'convert polygon to bounding box'; + +create function pg_catalog.box_above(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_above(box, box) is 'implementation of |>> operator'; + +create function pg_catalog.box_above_eq(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_above_eq(box, box) is 'implementation of >^ operator'; + +create function pg_catalog.box_add(box, point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_add(box, point) is 'implementation of + operator'; + +create function pg_catalog.box_below(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_below(box, box) is 'implementation of <<| operator'; + +create function pg_catalog.box_below_eq(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_below_eq(box, box) is 'implementation of <^ operator'; + +create function pg_catalog.box_center(box) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_center(box) is 'implementation of @@ operator'; + +create function pg_catalog.box_contain(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_contain(box, box) is 'implementation of @> operator'; + +create function pg_catalog.box_contain_pt(box, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_contain_pt(box, point) is 'implementation of @> operator'; + +create function pg_catalog.box_contained(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_contained(box, box) is 'implementation of <@ operator'; + +create function pg_catalog.box_distance(box, box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_distance(box, box) is 'implementation of <-> operator'; + +create function pg_catalog.box_div(box, point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_div(box, point) is 'implementation of / operator'; + +create function pg_catalog.box_eq(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_eq(box, box) is 'implementation of = operator'; + +create function pg_catalog.box_ge(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_ge(box, box) is 'implementation of >= operator'; + +create function pg_catalog.box_gt(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_gt(box, box) is 'implementation of > operator'; + +create function pg_catalog.box_in(cstring) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_in(cstring) is 'I/O'; + +create function pg_catalog.box_intersect(box, box) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_intersect(box, box) is 'implementation of # operator'; + +create function pg_catalog.box_le(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_le(box, box) is 'implementation of <= operator'; + +create function pg_catalog.box_left(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_left(box, box) is 'implementation of << operator'; + +create function pg_catalog.box_lt(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_lt(box, box) is 'implementation of < operator'; + +create function pg_catalog.box_mul(box, point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_mul(box, point) is 'implementation of * operator'; + +create function pg_catalog.box_out(box) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_out(box) is 'I/O'; + +create function pg_catalog.box_overabove(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_overabove(box, box) is 'implementation of |&> operator'; + +create function pg_catalog.box_overbelow(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_overbelow(box, box) is 'implementation of &<| operator'; + +create function pg_catalog.box_overlap(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_overlap(box, box) is 'implementation of && operator'; + +create function pg_catalog.box_overleft(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_overleft(box, box) is 'implementation of &< operator'; + +create function pg_catalog.box_overright(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_overright(box, box) is 'implementation of &> operator'; + +create function pg_catalog.box_recv(internal) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_recv(internal) is 'I/O'; + +create function pg_catalog.box_right(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_right(box, box) is 'implementation of >> operator'; + +create function pg_catalog.box_same(box, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_same(box, box) is 'implementation of ~= operator'; + +create function pg_catalog.box_send(box) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_send(box) is 'I/O'; + +create function pg_catalog.box_sub(box, point) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.box_sub(box, point) is 'implementation of - operator'; + +create function pg_catalog.bpchar("char") returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar("char") is 'convert char to char(n)'; + +create function pg_catalog.bpchar(char, integer, boolean) returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar(char, integer, boolean) is 'adjust char() to typmod length'; + +create function pg_catalog.bpchar(name) returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar(name) is 'convert name to char(n)'; + +create function pg_catalog.bpchar_larger(char, char) returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_larger(char, char) is 'larger of two'; + +create function pg_catalog.bpchar_pattern_ge(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_pattern_ge(char, char) is 'implementation of ~>=~ operator'; + +create function pg_catalog.bpchar_pattern_gt(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_pattern_gt(char, char) is 'implementation of ~>~ operator'; + +create function pg_catalog.bpchar_pattern_le(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_pattern_le(char, char) is 'implementation of ~<=~ operator'; + +create function pg_catalog.bpchar_pattern_lt(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_pattern_lt(char, char) is 'implementation of ~<~ operator'; + +create function pg_catalog.bpchar_smaller(char, char) returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_smaller(char, char) is 'smaller of two'; + +create function pg_catalog.bpchar_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchar_sortsupport(internal) is 'sort support'; + +create function pg_catalog.bpcharcmp(char, char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharcmp(char, char) is 'less-equal-greater'; + +create function pg_catalog.bpchareq(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchareq(char, char) is 'implementation of = operator'; + +create function pg_catalog.bpcharge(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharge(char, char) is 'implementation of >= operator'; + +create function pg_catalog.bpchargt(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchargt(char, char) is 'implementation of > operator'; + +create function pg_catalog.bpchariclike(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchariclike(char, text) is 'implementation of ~~* operator'; + +create function pg_catalog.bpcharicnlike(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharicnlike(char, text) is 'implementation of !~~* operator'; + +create function pg_catalog.bpcharicregexeq(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharicregexeq(char, text) is 'implementation of ~* operator'; + +create function pg_catalog.bpcharicregexne(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharicregexne(char, text) is 'implementation of !~* operator'; + +create function pg_catalog.bpcharin(cstring, oid, integer) returns char + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharin(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.bpcharle(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharle(char, char) is 'implementation of <= operator'; + +create function pg_catalog.bpcharlike(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharlike(char, text) is 'implementation of ~~ operator'; + +create function pg_catalog.bpcharlt(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharlt(char, char) is 'implementation of < operator'; + +create function pg_catalog.bpcharne(char, char) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharne(char, char) is 'implementation of <> operator'; + +create function pg_catalog.bpcharnlike(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharnlike(char, text) is 'implementation of !~~ operator'; + +create function pg_catalog.bpcharout(char) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharout(char) is 'I/O'; + +create function pg_catalog.bpcharrecv(internal, oid, integer) returns char + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharrecv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.bpcharregexeq(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharregexeq(char, text) is 'implementation of ~ operator'; + +create function pg_catalog.bpcharregexne(char, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharregexne(char, text) is 'implementation of !~ operator'; + +create function pg_catalog.bpcharsend(char) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpcharsend(char) is 'I/O'; + +create function pg_catalog.bpchartypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchartypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.bpchartypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bpchartypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.brin_bloom_add_value(internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_add_value(internal, internal, internal, internal) is 'BRIN bloom support'; + +create function pg_catalog.brin_bloom_consistent(internal, internal, internal, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_consistent(internal, internal, internal, integer) is 'BRIN bloom support'; + +create function pg_catalog.brin_bloom_opcinfo(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_opcinfo(internal) is 'BRIN bloom support'; + +create function pg_catalog.brin_bloom_options(internal) returns void + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_options(internal) is 'BRIN bloom support'; + +create function pg_catalog.brin_bloom_summary_in(cstring) returns pg_brin_bloom_summary + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_summary_in(cstring) is 'I/O'; + +create function pg_catalog.brin_bloom_summary_out(pg_brin_bloom_summary) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_summary_out(pg_brin_bloom_summary) is 'I/O'; + +create function pg_catalog.brin_bloom_summary_recv(internal) returns pg_brin_bloom_summary + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_summary_recv(internal) is 'I/O'; + +create function pg_catalog.brin_bloom_summary_send(pg_brin_bloom_summary) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_summary_send(pg_brin_bloom_summary) is 'I/O'; + +create function pg_catalog.brin_bloom_union(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_bloom_union(internal, internal, internal) is 'BRIN bloom support'; + +create function pg_catalog.brin_desummarize_range(regclass, bigint) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_desummarize_range(regclass, bigint) is 'brin: desummarize page range'; + +create function pg_catalog.brin_inclusion_add_value(internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_inclusion_add_value(internal, internal, internal, internal) is 'BRIN inclusion support'; + +create function pg_catalog.brin_inclusion_consistent(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_inclusion_consistent(internal, internal, internal) is 'BRIN inclusion support'; + +create function pg_catalog.brin_inclusion_opcinfo(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_inclusion_opcinfo(internal) is 'BRIN inclusion support'; + +create function pg_catalog.brin_inclusion_union(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_inclusion_union(internal, internal, internal) is 'BRIN inclusion support'; + +create function pg_catalog.brin_minmax_add_value(internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_add_value(internal, internal, internal, internal) is 'BRIN minmax support'; + +create function pg_catalog.brin_minmax_consistent(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_consistent(internal, internal, internal) is 'BRIN minmax support'; + +create function pg_catalog.brin_minmax_multi_add_value(internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_add_value(internal, internal, internal, internal) is 'BRIN multi minmax support'; + +create function pg_catalog.brin_minmax_multi_consistent(internal, internal, internal, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_consistent(internal, internal, internal, integer) is 'BRIN multi minmax support'; + +create function pg_catalog.brin_minmax_multi_distance_date(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_date(internal, internal) is 'BRIN multi minmax date distance'; + +create function pg_catalog.brin_minmax_multi_distance_float4(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_float4(internal, internal) is 'BRIN multi minmax float4 distance'; + +create function pg_catalog.brin_minmax_multi_distance_float8(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_float8(internal, internal) is 'BRIN multi minmax float8 distance'; + +create function pg_catalog.brin_minmax_multi_distance_inet(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_inet(internal, internal) is 'BRIN multi minmax inet distance'; + +create function pg_catalog.brin_minmax_multi_distance_int2(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_int2(internal, internal) is 'BRIN multi minmax int2 distance'; + +create function pg_catalog.brin_minmax_multi_distance_int4(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_int4(internal, internal) is 'BRIN multi minmax int4 distance'; + +create function pg_catalog.brin_minmax_multi_distance_int8(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_int8(internal, internal) is 'BRIN multi minmax int8 distance'; + +create function pg_catalog.brin_minmax_multi_distance_interval(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_interval(internal, internal) is 'BRIN multi minmax interval distance'; + +create function pg_catalog.brin_minmax_multi_distance_macaddr(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_macaddr(internal, internal) is 'BRIN multi minmax macaddr distance'; + +create function pg_catalog.brin_minmax_multi_distance_macaddr8(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_macaddr8(internal, internal) is 'BRIN multi minmax macaddr8 distance'; + +create function pg_catalog.brin_minmax_multi_distance_numeric(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_numeric(internal, internal) is 'BRIN multi minmax numeric distance'; + +create function pg_catalog.brin_minmax_multi_distance_pg_lsn(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_pg_lsn(internal, internal) is 'BRIN multi minmax pg_lsn distance'; + +create function pg_catalog.brin_minmax_multi_distance_tid(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_tid(internal, internal) is 'BRIN multi minmax tid distance'; + +create function pg_catalog.brin_minmax_multi_distance_time(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_time(internal, internal) is 'BRIN multi minmax time distance'; + +create function pg_catalog.brin_minmax_multi_distance_timestamp(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_timestamp(internal, internal) is 'BRIN multi minmax timestamp distance'; + +create function pg_catalog.brin_minmax_multi_distance_timetz(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_timetz(internal, internal) is 'BRIN multi minmax timetz distance'; + +create function pg_catalog.brin_minmax_multi_distance_uuid(internal, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_distance_uuid(internal, internal) is 'BRIN multi minmax uuid distance'; + +create function pg_catalog.brin_minmax_multi_opcinfo(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_opcinfo(internal) is 'BRIN multi minmax support'; + +create function pg_catalog.brin_minmax_multi_options(internal) returns void + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_options(internal) is 'BRIN multi minmax support'; + +create function pg_catalog.brin_minmax_multi_summary_in(cstring) returns pg_brin_minmax_multi_summary + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_summary_in(cstring) is 'I/O'; + +create function pg_catalog.brin_minmax_multi_summary_out(pg_brin_minmax_multi_summary) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_summary_out(pg_brin_minmax_multi_summary) is 'I/O'; + +create function pg_catalog.brin_minmax_multi_summary_recv(internal) returns pg_brin_minmax_multi_summary + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_summary_recv(internal) is 'I/O'; + +create function pg_catalog.brin_minmax_multi_summary_send(pg_brin_minmax_multi_summary) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_summary_send(pg_brin_minmax_multi_summary) is 'I/O'; + +create function pg_catalog.brin_minmax_multi_union(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_multi_union(internal, internal, internal) is 'BRIN multi minmax support'; + +create function pg_catalog.brin_minmax_opcinfo(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_opcinfo(internal) is 'BRIN minmax support'; + +create function pg_catalog.brin_minmax_union(internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_minmax_union(internal, internal, internal) is 'BRIN minmax support'; + +create function pg_catalog.brin_summarize_new_values(regclass) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_summarize_new_values(regclass) is 'brin: standalone scan new table pages'; + +create function pg_catalog.brin_summarize_range(regclass, bigint) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brin_summarize_range(regclass, bigint) is 'brin: standalone scan new table pages'; + +create function pg_catalog.brinhandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.brinhandler(internal) is 'brin index access method handler'; + +create function pg_catalog.broadcast(inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.broadcast(inet) is 'broadcast address of network'; + +create function pg_catalog.btarraycmp(anyarray, anyarray) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btarraycmp(anyarray, anyarray) is 'less-equal-greater'; + +create function pg_catalog.btboolcmp(boolean, boolean) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btboolcmp(boolean, boolean) is 'less-equal-greater'; + +create function pg_catalog.btbpchar_pattern_cmp(char, char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btbpchar_pattern_cmp(char, char) is 'less-equal-greater'; + +create function pg_catalog.btbpchar_pattern_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btbpchar_pattern_sortsupport(internal) is 'sort support'; + +create function pg_catalog.btcharcmp("char", "char") returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btcharcmp("char", "char") is 'less-equal-greater'; + +create function pg_catalog.btequalimage(oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btequalimage(oid) is 'equal image'; + +create function pg_catalog.btfloat48cmp(real, double precision) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat48cmp(real, double precision) is 'less-equal-greater'; + +create function pg_catalog.btfloat4cmp(real, real) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat4cmp(real, real) is 'less-equal-greater'; + +create function pg_catalog.btfloat4sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat4sortsupport(internal) is 'sort support'; + +create function pg_catalog.btfloat84cmp(double precision, real) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat84cmp(double precision, real) is 'less-equal-greater'; + +create function pg_catalog.btfloat8cmp(double precision, double precision) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat8cmp(double precision, double precision) is 'less-equal-greater'; + +create function pg_catalog.btfloat8sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btfloat8sortsupport(internal) is 'sort support'; + +create function pg_catalog.bthandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bthandler(internal) is 'btree index access method handler'; + +create function pg_catalog.btint24cmp(smallint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint24cmp(smallint, integer) is 'less-equal-greater'; + +create function pg_catalog.btint28cmp(smallint, bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint28cmp(smallint, bigint) is 'less-equal-greater'; + +create function pg_catalog.btint2cmp(smallint, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint2cmp(smallint, smallint) is 'less-equal-greater'; + +create function pg_catalog.btint2sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint2sortsupport(internal) is 'sort support'; + +create function pg_catalog.btint42cmp(integer, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint42cmp(integer, smallint) is 'less-equal-greater'; + +create function pg_catalog.btint48cmp(integer, bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint48cmp(integer, bigint) is 'less-equal-greater'; + +create function pg_catalog.btint4cmp(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint4cmp(integer, integer) is 'less-equal-greater'; + +create function pg_catalog.btint4sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint4sortsupport(internal) is 'sort support'; + +create function pg_catalog.btint82cmp(bigint, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint82cmp(bigint, smallint) is 'less-equal-greater'; + +create function pg_catalog.btint84cmp(bigint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint84cmp(bigint, integer) is 'less-equal-greater'; + +create function pg_catalog.btint8cmp(bigint, bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint8cmp(bigint, bigint) is 'less-equal-greater'; + +create function pg_catalog.btint8sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btint8sortsupport(internal) is 'sort support'; + +create function pg_catalog.btnamecmp(name, name) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btnamecmp(name, name) is 'less-equal-greater'; + +create function pg_catalog.btnamesortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btnamesortsupport(internal) is 'sort support'; + +create function pg_catalog.btnametextcmp(name, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btnametextcmp(name, text) is 'less-equal-greater'; + +create function pg_catalog.btoidcmp(oid, oid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btoidcmp(oid, oid) is 'less-equal-greater'; + +create function pg_catalog.btoidsortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btoidsortsupport(internal) is 'sort support'; + +create function pg_catalog.btoidvectorcmp(oidvector, oidvector) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btoidvectorcmp(oidvector, oidvector) is 'less-equal-greater'; + +create function pg_catalog.btrecordcmp(record, record) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btrecordcmp(record, record) is 'less-equal-greater'; + +create function pg_catalog.btrecordimagecmp(record, record) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btrecordimagecmp(record, record) is 'less-equal-greater based on byte images'; + +create function pg_catalog.btrim(bytea, bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btrim(bytea, bytea) is 'trim selected bytes from both ends of string'; + +create function pg_catalog.btrim(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btrim(text) is 'trim spaces from both ends of string'; + +create function pg_catalog.btrim(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btrim(text, text) is 'trim selected characters from both ends of string'; + +create function pg_catalog.bttext_pattern_cmp(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttext_pattern_cmp(text, text) is 'less-equal-greater'; + +create function pg_catalog.bttext_pattern_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttext_pattern_sortsupport(internal) is 'sort support'; + +create function pg_catalog.bttextcmp(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttextcmp(text, text) is 'less-equal-greater'; + +create function pg_catalog.bttextnamecmp(text, name) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttextnamecmp(text, name) is 'less-equal-greater'; + +create function pg_catalog.bttextsortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttextsortsupport(internal) is 'sort support'; + +create function pg_catalog.bttidcmp(tid, tid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bttidcmp(tid, tid) is 'less-equal-greater'; + +create function pg_catalog.btvarstrequalimage(oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.btvarstrequalimage(oid) is 'equal image'; + +create function pg_catalog.bytea_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytea_sortsupport(internal) is 'sort support'; + +create function pg_catalog.bytea_string_agg_finalfn(internal) returns bytea + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytea_string_agg_finalfn(internal) is 'aggregate final function'; + +create function pg_catalog.bytea_string_agg_transfn(internal, bytea, bytea) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytea_string_agg_transfn(internal, bytea, bytea) is 'aggregate transition function'; + +create function pg_catalog.byteacat(bytea, bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteacat(bytea, bytea) is 'implementation of || operator'; + +create function pg_catalog.byteacmp(bytea, bytea) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteacmp(bytea, bytea) is 'less-equal-greater'; + +create function pg_catalog.byteaeq(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteaeq(bytea, bytea) is 'implementation of = operator'; + +create function pg_catalog.byteage(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteage(bytea, bytea) is 'implementation of >= operator'; + +create function pg_catalog.byteagt(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteagt(bytea, bytea) is 'implementation of > operator'; + +create function pg_catalog.byteain(cstring) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteain(cstring) is 'I/O'; + +create function pg_catalog.byteale(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteale(bytea, bytea) is 'implementation of <= operator'; + +create function pg_catalog.bytealike(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytealike(bytea, bytea) is 'implementation of ~~ operator'; + +create function pg_catalog.bytealt(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytealt(bytea, bytea) is 'implementation of < operator'; + +create function pg_catalog.byteane(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteane(bytea, bytea) is 'implementation of <> operator'; + +create function pg_catalog.byteanlike(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteanlike(bytea, bytea) is 'implementation of !~~ operator'; + +create function pg_catalog.byteaout(bytea) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteaout(bytea) is 'I/O'; + +create function pg_catalog.bytearecv(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.bytearecv(internal) is 'I/O'; + +create function pg_catalog.byteasend(bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.byteasend(bytea) is 'I/O'; + +create function pg_catalog.cardinality(anyarray) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cardinality(anyarray) is 'array cardinality'; + +create function pg_catalog.cash_cmp(money, money) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_cmp(money, money) is 'less-equal-greater'; + +create function pg_catalog.cash_div_cash(money, money) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_cash(money, money) is 'implementation of / operator'; + +create function pg_catalog.cash_div_flt4(money, real) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_flt4(money, real) is 'implementation of / operator'; + +create function pg_catalog.cash_div_flt8(money, double precision) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_flt8(money, double precision) is 'implementation of / operator'; + +create function pg_catalog.cash_div_int2(money, smallint) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_int2(money, smallint) is 'implementation of / operator'; + +create function pg_catalog.cash_div_int4(money, integer) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_int4(money, integer) is 'implementation of / operator'; + +create function pg_catalog.cash_div_int8(money, bigint) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_div_int8(money, bigint) is 'implementation of / operator'; + +create function pg_catalog.cash_eq(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_eq(money, money) is 'implementation of = operator'; + +create function pg_catalog.cash_ge(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_ge(money, money) is 'implementation of >= operator'; + +create function pg_catalog.cash_gt(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_gt(money, money) is 'implementation of > operator'; + +create function pg_catalog.cash_in(cstring) returns money + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_in(cstring) is 'I/O'; + +create function pg_catalog.cash_le(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_le(money, money) is 'implementation of <= operator'; + +create function pg_catalog.cash_lt(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_lt(money, money) is 'implementation of < operator'; + +create function pg_catalog.cash_mi(money, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mi(money, money) is 'implementation of - operator'; + +create function pg_catalog.cash_mul_flt4(money, real) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mul_flt4(money, real) is 'implementation of * operator'; + +create function pg_catalog.cash_mul_flt8(money, double precision) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mul_flt8(money, double precision) is 'implementation of * operator'; + +create function pg_catalog.cash_mul_int2(money, smallint) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mul_int2(money, smallint) is 'implementation of * operator'; + +create function pg_catalog.cash_mul_int4(money, integer) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mul_int4(money, integer) is 'implementation of * operator'; + +create function pg_catalog.cash_mul_int8(money, bigint) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_mul_int8(money, bigint) is 'implementation of * operator'; + +create function pg_catalog.cash_ne(money, money) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_ne(money, money) is 'implementation of <> operator'; + +create function pg_catalog.cash_out(money) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_out(money) is 'I/O'; + +create function pg_catalog.cash_pl(money, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_pl(money, money) is 'implementation of + operator'; + +create function pg_catalog.cash_recv(internal) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_recv(internal) is 'I/O'; + +create function pg_catalog.cash_send(money) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_send(money) is 'I/O'; + +create function pg_catalog.cash_words(money) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cash_words(money) is 'output money amount as words'; + +create function pg_catalog.cashlarger(money, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cashlarger(money, money) is 'larger of two'; + +create function pg_catalog.cashsmaller(money, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cashsmaller(money, money) is 'smaller of two'; + +create function pg_catalog.cbrt(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cbrt(double precision) is 'cube root'; + +create function pg_catalog.ceil(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ceil(double precision) is 'nearest integer >= value'; + +create function pg_catalog.ceil(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ceil(numeric) is 'nearest integer >= value'; + +create function pg_catalog.ceiling(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ceiling(double precision) is 'nearest integer >= value'; + +create function pg_catalog.ceiling(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ceiling(numeric) is 'nearest integer >= value'; + +create function pg_catalog.center(box) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.center(box) is 'center of'; + +create function pg_catalog.center(circle) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.center(circle) is 'center of'; + +create function pg_catalog.char(integer) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.char(integer) is 'convert int4 to char'; + +create function pg_catalog.char(text) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.char(text) is 'convert text to char'; + +create function pg_catalog.char_length(char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.char_length(char) is 'character length'; + +create function pg_catalog.char_length(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.char_length(text) is 'character length'; + +create function pg_catalog.character_length(char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.character_length(char) is 'character length'; + +create function pg_catalog.character_length(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.character_length(text) is 'character length'; + +create function pg_catalog.chareq("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.chareq("char", "char") is 'implementation of = operator'; + +create function pg_catalog.charge("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charge("char", "char") is 'implementation of >= operator'; + +create function pg_catalog.chargt("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.chargt("char", "char") is 'implementation of > operator'; + +create function pg_catalog.charin(cstring) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charin(cstring) is 'I/O'; + +create function pg_catalog.charle("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charle("char", "char") is 'implementation of <= operator'; + +create function pg_catalog.charlt("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charlt("char", "char") is 'implementation of < operator'; + +create function pg_catalog.charne("char", "char") returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charne("char", "char") is 'implementation of <> operator'; + +create function pg_catalog.charout("char") returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charout("char") is 'I/O'; + +create function pg_catalog.charrecv(internal) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charrecv(internal) is 'I/O'; + +create function pg_catalog.charsend("char") returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.charsend("char") is 'I/O'; + +create function pg_catalog.chr(integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.chr(integer) is 'convert int4 to char'; + +create function pg_catalog.cideq(cid, cid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cideq(cid, cid) is 'implementation of = operator'; + +create function pg_catalog.cidin(cstring) returns cid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidin(cstring) is 'I/O'; + +create function pg_catalog.cidout(cid) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidout(cid) is 'I/O'; + +create function pg_catalog.cidr(inet) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidr(inet) is 'convert inet to cidr'; + +create function pg_catalog.cidr_in(cstring) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidr_in(cstring) is 'I/O'; + +create function pg_catalog.cidr_out(cidr) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidr_out(cidr) is 'I/O'; + +create function pg_catalog.cidr_recv(internal) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidr_recv(internal) is 'I/O'; + +create function pg_catalog.cidr_send(cidr) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidr_send(cidr) is 'I/O'; + +create function pg_catalog.cidrecv(internal) returns cid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidrecv(internal) is 'I/O'; + +create function pg_catalog.cidsend(cid) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cidsend(cid) is 'I/O'; + +create function pg_catalog.circle(box) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle(box) is 'convert box to circle'; + +create function pg_catalog.circle(point, double precision) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle(point, double precision) is 'convert point and radius to circle'; + +create function pg_catalog.circle(polygon) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle(polygon) is 'convert polygon to circle'; + +create function pg_catalog.circle_above(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_above(circle, circle) is 'implementation of |>> operator'; + +create function pg_catalog.circle_add_pt(circle, point) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_add_pt(circle, point) is 'implementation of + operator'; + +create function pg_catalog.circle_below(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_below(circle, circle) is 'implementation of <<| operator'; + +create function pg_catalog.circle_center(circle) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_center(circle) is 'implementation of @@ operator'; + +create function pg_catalog.circle_contain(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_contain(circle, circle) is 'implementation of @> operator'; + +create function pg_catalog.circle_contain_pt(circle, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_contain_pt(circle, point) is 'implementation of @> operator'; + +create function pg_catalog.circle_contained(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_contained(circle, circle) is 'implementation of <@ operator'; + +create function pg_catalog.circle_distance(circle, circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_distance(circle, circle) is 'implementation of <-> operator'; + +create function pg_catalog.circle_div_pt(circle, point) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_div_pt(circle, point) is 'implementation of / operator'; + +create function pg_catalog.circle_eq(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_eq(circle, circle) is 'implementation of = operator'; + +create function pg_catalog.circle_ge(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_ge(circle, circle) is 'implementation of >= operator'; + +create function pg_catalog.circle_gt(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_gt(circle, circle) is 'implementation of > operator'; + +create function pg_catalog.circle_in(cstring) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_in(cstring) is 'I/O'; + +create function pg_catalog.circle_le(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_le(circle, circle) is 'implementation of <= operator'; + +create function pg_catalog.circle_left(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_left(circle, circle) is 'implementation of << operator'; + +create function pg_catalog.circle_lt(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_lt(circle, circle) is 'implementation of < operator'; + +create function pg_catalog.circle_mul_pt(circle, point) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_mul_pt(circle, point) is 'implementation of * operator'; + +create function pg_catalog.circle_ne(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_ne(circle, circle) is 'implementation of <> operator'; + +create function pg_catalog.circle_out(circle) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_out(circle) is 'I/O'; + +create function pg_catalog.circle_overabove(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_overabove(circle, circle) is 'implementation of |&> operator'; + +create function pg_catalog.circle_overbelow(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_overbelow(circle, circle) is 'implementation of &<| operator'; + +create function pg_catalog.circle_overlap(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_overlap(circle, circle) is 'implementation of && operator'; + +create function pg_catalog.circle_overleft(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_overleft(circle, circle) is 'implementation of &< operator'; + +create function pg_catalog.circle_overright(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_overright(circle, circle) is 'implementation of &> operator'; + +create function pg_catalog.circle_recv(internal) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_recv(internal) is 'I/O'; + +create function pg_catalog.circle_right(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_right(circle, circle) is 'implementation of >> operator'; + +create function pg_catalog.circle_same(circle, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_same(circle, circle) is 'implementation of ~= operator'; + +create function pg_catalog.circle_send(circle) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_send(circle) is 'I/O'; + +create function pg_catalog.circle_sub_pt(circle, point) returns circle + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.circle_sub_pt(circle, point) is 'implementation of - operator'; + +create function pg_catalog.clock_timestamp() returns timestamp with time zone + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.clock_timestamp() is 'current clock time'; + +create function pg_catalog.close_ls(line, lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_ls(line, lseg) is 'implementation of ## operator'; + +create function pg_catalog.close_lseg(lseg, lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_lseg(lseg, lseg) is 'implementation of ## operator'; + +create function pg_catalog.close_pb(point, box) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_pb(point, box) is 'implementation of ## operator'; + +create function pg_catalog.close_pl(point, line) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_pl(point, line) is 'implementation of ## operator'; + +create function pg_catalog.close_ps(point, lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_ps(point, lseg) is 'implementation of ## operator'; + +create function pg_catalog.close_sb(lseg, box) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.close_sb(lseg, box) is 'implementation of ## operator'; + +create function pg_catalog.col_description(oid, integer) returns text + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.col_description(oid, integer) is 'get description for table column'; + +create function pg_catalog.concat("any") returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.concat("any") is 'concatenate values'; + +create function pg_catalog.concat_ws(text, "any") returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.concat_ws(text, "any") is 'concatenate values with separators'; + +create function pg_catalog.contjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.contjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for containment comparison operators'; + +create function pg_catalog.contsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.contsel(internal, oid, internal, integer) is 'restriction selectivity for containment comparison operators'; + +create function pg_catalog.convert(bytea, name, name) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.convert(bytea, name, name) is 'convert string with specified encoding names'; + +create function pg_catalog.convert_from(bytea, name) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.convert_from(bytea, name) is 'convert string with specified source encoding name'; + +create function pg_catalog.convert_to(text, name) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.convert_to(text, name) is 'convert string with specified destination encoding name'; + +create function pg_catalog.cos(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cos(double precision) is 'cosine'; + +create function pg_catalog.cosd(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cosd(double precision) is 'cosine, degrees'; + +create function pg_catalog.cosh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cosh(double precision) is 'hyperbolic cosine'; + +create function pg_catalog.cot(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cot(double precision) is 'cotangent'; + +create function pg_catalog.cotd(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cotd(double precision) is 'cotangent, degrees'; + +create function pg_catalog.cstring_in(cstring) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cstring_in(cstring) is 'I/O'; + +create function pg_catalog.cstring_out(cstring) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cstring_out(cstring) is 'I/O'; + +create function pg_catalog.cstring_recv(internal) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cstring_recv(internal) is 'I/O'; + +create function pg_catalog.cstring_send(cstring) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cstring_send(cstring) is 'I/O'; + +create function pg_catalog.cume_dist() returns double precision + immutable + window + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cume_dist() is 'fractional row number within partition'; + +create function pg_catalog.cume_dist_final(internal, "any") returns double precision + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cume_dist_final(internal, "any") is 'aggregate final function'; + +create function pg_catalog.current_database() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.current_database() is 'name of the current database'; + +create function pg_catalog.current_query() returns text + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.current_query() is 'get the currently executing query'; + +create function pg_catalog."current_schema"() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."current_schema"() is 'current schema name'; + +create function pg_catalog.current_schemas(boolean) returns name[] + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.current_schemas(boolean) is 'current schema search list'; + +create function pg_catalog.current_setting(text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.current_setting(text) is 'SHOW X as a function'; + +create function pg_catalog.current_setting(text, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.current_setting(text, boolean) is 'SHOW X as a function, optionally no error for missing variable'; + +create function pg_catalog."current_user"() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."current_user"() is 'current user name'; + +create function pg_catalog.currtid2(text, tid) returns tid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.currtid2(text, tid) is 'latest tid of a tuple'; + +create function pg_catalog.currval(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.currval(regclass) is 'sequence current value'; + +create function pg_catalog.cursor_to_xml(cursor refcursor, count integer, nulls boolean, tableforest boolean, targetns text) returns xml + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cursor_to_xml(refcursor, integer, boolean, boolean, text) is 'map rows from cursor to XML'; + +create function pg_catalog.cursor_to_xmlschema(cursor refcursor, nulls boolean, tableforest boolean, targetns text) returns xml + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.cursor_to_xmlschema(refcursor, boolean, boolean, text) is 'map cursor structure to XML Schema'; + +create function pg_catalog.database_to_xml(nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.database_to_xml(boolean, boolean, text) is 'map database contents to XML'; + +create function pg_catalog.database_to_xml_and_xmlschema(nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.database_to_xml_and_xmlschema(boolean, boolean, text) is 'map database contents and structure to XML and XML Schema'; + +create function pg_catalog.database_to_xmlschema(nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.database_to_xmlschema(boolean, boolean, text) is 'map database structure to XML Schema'; + +create function pg_catalog.date(timestamp with time zone) returns date + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date(timestamp with time zone) is 'convert timestamp with time zone to date'; + +create function pg_catalog.date(timestamp) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date(timestamp) is 'convert timestamp to date'; + +create function pg_catalog.date_add(timestamp with time zone, interval) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_add(timestamp with time zone, interval) is 'add interval to timestamp with time zone'; + +create function pg_catalog.date_add(timestamp with time zone, interval, text) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_add(timestamp with time zone, interval, text) is 'add interval to timestamp with time zone in specified time zone'; + +create function pg_catalog.date_bin(interval, timestamp with time zone, timestamp with time zone) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_bin(interval, timestamp with time zone, timestamp with time zone) is 'bin timestamp with time zone into specified interval'; + +create function pg_catalog.date_bin(interval, timestamp, timestamp) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_bin(interval, timestamp, timestamp) is 'bin timestamp into specified interval'; + +create function pg_catalog.date_cmp(date, date) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_cmp(date, date) is 'less-equal-greater'; + +create function pg_catalog.date_cmp_timestamp(date, timestamp) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_cmp_timestamp(date, timestamp) is 'less-equal-greater'; + +create function pg_catalog.date_cmp_timestamptz(date, timestamp with time zone) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_cmp_timestamptz(date, timestamp with time zone) is 'less-equal-greater'; + +create function pg_catalog.date_eq(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_eq(date, date) is 'implementation of = operator'; + +create function pg_catalog.date_eq_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_eq_timestamp(date, timestamp) is 'implementation of = operator'; + +create function pg_catalog.date_eq_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_eq_timestamptz(date, timestamp with time zone) is 'implementation of = operator'; + +create function pg_catalog.date_ge(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ge(date, date) is 'implementation of >= operator'; + +create function pg_catalog.date_ge_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ge_timestamp(date, timestamp) is 'implementation of >= operator'; + +create function pg_catalog.date_ge_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ge_timestamptz(date, timestamp with time zone) is 'implementation of >= operator'; + +create function pg_catalog.date_gt(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_gt(date, date) is 'implementation of > operator'; + +create function pg_catalog.date_gt_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_gt_timestamp(date, timestamp) is 'implementation of > operator'; + +create function pg_catalog.date_gt_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_gt_timestamptz(date, timestamp with time zone) is 'implementation of > operator'; + +create function pg_catalog.date_in(cstring) returns date + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_in(cstring) is 'I/O'; + +create function pg_catalog.date_larger(date, date) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_larger(date, date) is 'larger of two'; + +create function pg_catalog.date_le(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_le(date, date) is 'implementation of <= operator'; + +create function pg_catalog.date_le_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_le_timestamp(date, timestamp) is 'implementation of <= operator'; + +create function pg_catalog.date_le_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_le_timestamptz(date, timestamp with time zone) is 'implementation of <= operator'; + +create function pg_catalog.date_lt(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_lt(date, date) is 'implementation of < operator'; + +create function pg_catalog.date_lt_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_lt_timestamp(date, timestamp) is 'implementation of < operator'; + +create function pg_catalog.date_lt_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_lt_timestamptz(date, timestamp with time zone) is 'implementation of < operator'; + +create function pg_catalog.date_mi(date, date) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_mi(date, date) is 'implementation of - operator'; + +create function pg_catalog.date_mi_interval(date, interval) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_mi_interval(date, interval) is 'implementation of - operator'; + +create function pg_catalog.date_mii(date, integer) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_mii(date, integer) is 'implementation of - operator'; + +create function pg_catalog.date_ne(date, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ne(date, date) is 'implementation of <> operator'; + +create function pg_catalog.date_ne_timestamp(date, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ne_timestamp(date, timestamp) is 'implementation of <> operator'; + +create function pg_catalog.date_ne_timestamptz(date, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_ne_timestamptz(date, timestamp with time zone) is 'implementation of <> operator'; + +create function pg_catalog.date_out(date) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_out(date) is 'I/O'; + +create function pg_catalog.date_part(text, date) returns double precision + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, date) is 'extract field from date'; + +create function pg_catalog.date_part(text, interval) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, interval) is 'extract field from interval'; + +create function pg_catalog.date_part(text, time with time zone) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, time with time zone) is 'extract field from time with time zone'; + +create function pg_catalog.date_part(text, time) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, time) is 'extract field from time'; + +create function pg_catalog.date_part(text, timestamp with time zone) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, timestamp with time zone) is 'extract field from timestamp with time zone'; + +create function pg_catalog.date_part(text, timestamp) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_part(text, timestamp) is 'extract field from timestamp'; + +create function pg_catalog.date_pl_interval(date, interval) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_pl_interval(date, interval) is 'implementation of + operator'; + +create function pg_catalog.date_pli(date, integer) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_pli(date, integer) is 'implementation of + operator'; + +create function pg_catalog.date_recv(internal) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_recv(internal) is 'I/O'; + +create function pg_catalog.date_send(date) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_send(date) is 'I/O'; + +create function pg_catalog.date_smaller(date, date) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_smaller(date, date) is 'smaller of two'; + +create function pg_catalog.date_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_sortsupport(internal) is 'sort support'; + +create function pg_catalog.date_subtract(timestamp with time zone, interval) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_subtract(timestamp with time zone, interval) is 'subtract interval from timestamp with time zone'; + +create function pg_catalog.date_subtract(timestamp with time zone, interval, text) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_subtract(timestamp with time zone, interval, text) is 'subtract interval from timestamp with time zone in specified time zone'; + +create function pg_catalog.date_trunc(text, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_trunc(text, interval) is 'truncate interval to specified units'; + +create function pg_catalog.date_trunc(text, timestamp with time zone) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_trunc(text, timestamp with time zone) is 'truncate timestamp with time zone to specified units'; + +create function pg_catalog.date_trunc(text, timestamp with time zone, text) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_trunc(text, timestamp with time zone, text) is 'truncate timestamp with time zone to specified units in specified time zone'; + +create function pg_catalog.date_trunc(text, timestamp) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.date_trunc(text, timestamp) is 'truncate timestamp to specified units'; + +create function pg_catalog.datemultirange() returns datemultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.datemultirange() is 'datemultirange constructor'; + +create function pg_catalog.datemultirange(daterange) returns datemultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.datemultirange(daterange) is 'datemultirange constructor'; + +create function pg_catalog.datemultirange(daterange[]) returns datemultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.datemultirange(daterange[]) is 'datemultirange constructor'; + +create function pg_catalog.daterange(date, date) returns daterange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.daterange(date, date) is 'daterange constructor'; + +create function pg_catalog.daterange(date, date, text) returns daterange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.daterange(date, date, text) is 'daterange constructor'; + +create function pg_catalog.daterange_canonical(daterange) returns daterange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.daterange_canonical(daterange) is 'convert a date range to canonical form'; + +create function pg_catalog.daterange_subdiff(date, date) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.daterange_subdiff(date, date) is 'float8 difference of two date values'; + +create function pg_catalog.datetime_pl(date, time) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.datetime_pl(date, time) is 'implementation of + operator'; + +create function pg_catalog.datetimetz_pl(date, time with time zone) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.datetimetz_pl(date, time with time zone) is 'implementation of + operator'; + +create function pg_catalog.dcbrt(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dcbrt(double precision) is 'implementation of ||/ operator'; + +create function pg_catalog.decode(text, text) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.decode(text, text) is 'convert ascii-encoded text string into bytea value'; + +create function pg_catalog.degrees(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.degrees(double precision) is 'radians to degrees'; + +create function pg_catalog.dense_rank() returns bigint + immutable + window + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dense_rank() is 'integer rank without gaps'; + +create function pg_catalog.dense_rank_final(internal, "any") returns bigint + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dense_rank_final(internal, "any") is 'aggregate final function'; + +create function pg_catalog.dexp(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dexp(double precision) is 'natural exponential (e^x)'; + +create function pg_catalog.diagonal(box) returns lseg + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.diagonal(box) is 'box diagonal'; + +create function pg_catalog.diameter(circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.diameter(circle) is 'diameter of circle'; + +create function pg_catalog.dispell_init(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dispell_init(internal) is '(internal)'; + +create function pg_catalog.dispell_lexize(internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dispell_lexize(internal, internal, internal, internal) is '(internal)'; + +create function pg_catalog.dist_bp(box, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_bp(box, point) is 'implementation of <-> operator'; + +create function pg_catalog.dist_bs(box, lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_bs(box, lseg) is 'implementation of <-> operator'; + +create function pg_catalog.dist_cpoint(circle, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_cpoint(circle, point) is 'implementation of <-> operator'; + +create function pg_catalog.dist_cpoly(circle, polygon) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_cpoly(circle, polygon) is 'implementation of <-> operator'; + +create function pg_catalog.dist_lp(line, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_lp(line, point) is 'implementation of <-> operator'; + +create function pg_catalog.dist_ls(line, lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_ls(line, lseg) is 'implementation of <-> operator'; + +create function pg_catalog.dist_pathp(path, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_pathp(path, point) is 'implementation of <-> operator'; + +create function pg_catalog.dist_pb(point, box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_pb(point, box) is 'implementation of <-> operator'; + +create function pg_catalog.dist_pc(point, circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_pc(point, circle) is 'implementation of <-> operator'; + +create function pg_catalog.dist_pl(point, line) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_pl(point, line) is 'implementation of <-> operator'; + +create function pg_catalog.dist_polyc(polygon, circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_polyc(polygon, circle) is 'implementation of <-> operator'; + +create function pg_catalog.dist_polyp(polygon, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_polyp(polygon, point) is 'implementation of <-> operator'; + +create function pg_catalog.dist_ppath(point, path) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_ppath(point, path) is 'implementation of <-> operator'; + +create function pg_catalog.dist_ppoly(point, polygon) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_ppoly(point, polygon) is 'implementation of <-> operator'; + +create function pg_catalog.dist_ps(point, lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_ps(point, lseg) is 'implementation of <-> operator'; + +create function pg_catalog.dist_sb(lseg, box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_sb(lseg, box) is 'implementation of <-> operator'; + +create function pg_catalog.dist_sl(lseg, line) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_sl(lseg, line) is 'implementation of <-> operator'; + +create function pg_catalog.dist_sp(lseg, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dist_sp(lseg, point) is 'implementation of <-> operator'; + +create function pg_catalog.div(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.div(numeric, numeric) is 'trunc(x/y)'; + +create function pg_catalog.dlog1(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dlog1(double precision) is 'natural logarithm'; + +create function pg_catalog.dlog10(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dlog10(double precision) is 'base 10 logarithm'; + +create function pg_catalog.domain_in(cstring, oid, integer) returns "any" + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.domain_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.domain_recv(internal, oid, integer) returns "any" + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.domain_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.dpow(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dpow(double precision, double precision) is 'implementation of ^ operator'; + +create function pg_catalog.dround(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dround(double precision) is 'round to nearest integer'; + +create function pg_catalog.dsimple_init(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dsimple_init(internal) is '(internal)'; + +create function pg_catalog.dsimple_lexize(internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dsimple_lexize(internal, internal, internal, internal) is '(internal)'; + +create function pg_catalog.dsnowball_init(internal) returns internal + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.dsnowball_lexize(internal, internal, internal, internal) returns internal + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.dsqrt(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dsqrt(double precision) is 'implementation of |/ operator'; + +create function pg_catalog.dsynonym_init(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dsynonym_init(internal) is '(internal)'; + +create function pg_catalog.dsynonym_lexize(internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dsynonym_lexize(internal, internal, internal, internal) is '(internal)'; + +create function pg_catalog.dtrunc(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.dtrunc(double precision) is 'truncate to integer'; + +create function pg_catalog.elem_contained_by_multirange(anyelement, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.elem_contained_by_multirange(anyelement, anymultirange) is 'implementation of <@ operator'; + +create function pg_catalog.elem_contained_by_range(anyelement, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.elem_contained_by_range(anyelement, anyrange) is 'implementation of <@ operator'; + +create function pg_catalog.encode(bytea, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.encode(bytea, text) is 'convert bytea value into some ascii-only text string'; + +create function pg_catalog.enum_cmp(anyenum, anyenum) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_cmp(anyenum, anyenum) is 'less-equal-greater'; + +create function pg_catalog.enum_eq(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_eq(anyenum, anyenum) is 'implementation of = operator'; + +create function pg_catalog.enum_first(anyenum) returns anyenum + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_first(anyenum) is 'first value of the input enum type'; + +create function pg_catalog.enum_ge(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_ge(anyenum, anyenum) is 'implementation of >= operator'; + +create function pg_catalog.enum_gt(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_gt(anyenum, anyenum) is 'implementation of > operator'; + +create function pg_catalog.enum_in(cstring, oid) returns anyenum + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_in(cstring, oid) is 'I/O'; + +create function pg_catalog.enum_larger(anyenum, anyenum) returns anyenum + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_larger(anyenum, anyenum) is 'larger of two'; + +create function pg_catalog.enum_last(anyenum) returns anyenum + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_last(anyenum) is 'last value of the input enum type'; + +create function pg_catalog.enum_le(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_le(anyenum, anyenum) is 'implementation of <= operator'; + +create function pg_catalog.enum_lt(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_lt(anyenum, anyenum) is 'implementation of < operator'; + +create function pg_catalog.enum_ne(anyenum, anyenum) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_ne(anyenum, anyenum) is 'implementation of <> operator'; + +create function pg_catalog.enum_out(anyenum) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_out(anyenum) is 'I/O'; + +create function pg_catalog.enum_range(anyenum) returns anyarray + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_range(anyenum) is 'range of the given enum type, as an ordered array'; + +create function pg_catalog.enum_range(anyenum, anyenum) returns anyarray + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_range(anyenum, anyenum) is 'range between the two given enum values, as an ordered array'; + +create function pg_catalog.enum_recv(internal, oid) returns anyenum + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_recv(internal, oid) is 'I/O'; + +create function pg_catalog.enum_send(anyenum) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_send(anyenum) is 'I/O'; + +create function pg_catalog.enum_smaller(anyenum, anyenum) returns anyenum + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.enum_smaller(anyenum, anyenum) is 'smaller of two'; + +create function pg_catalog.eqjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.eqjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of = and related operators'; + +create function pg_catalog.eqsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.eqsel(internal, oid, internal, integer) is 'restriction selectivity of = and related operators'; + +create function pg_catalog.erf(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.erf(double precision) is 'error function'; + +create function pg_catalog.erfc(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.erfc(double precision) is 'complementary error function'; + +create function pg_catalog.euc_cn_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_cn_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_CN to MULE_INTERNAL'; + +create function pg_catalog.euc_cn_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_cn_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_CN to UTF8'; + +create function pg_catalog.euc_jis_2004_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_jis_2004_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_JIS_2004 to SHIFT_JIS_2004'; + +create function pg_catalog.euc_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_JIS_2004 to UTF8'; + +create function pg_catalog.euc_jp_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_jp_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_JP to MULE_INTERNAL'; + +create function pg_catalog.euc_jp_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_jp_to_sjis(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_JP to SJIS'; + +create function pg_catalog.euc_jp_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_jp_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_JP to UTF8'; + +create function pg_catalog.euc_kr_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_kr_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_KR to MULE_INTERNAL'; + +create function pg_catalog.euc_kr_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_kr_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_KR to UTF8'; + +create function pg_catalog.euc_tw_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_tw_to_big5(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_TW to BIG5'; + +create function pg_catalog.euc_tw_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_tw_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_TW to MULE_INTERNAL'; + +create function pg_catalog.euc_tw_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.euc_tw_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for EUC_TW to UTF8'; + +create function pg_catalog.event_trigger_in(cstring) returns event_trigger + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.event_trigger_in(cstring) is 'I/O'; + +create function pg_catalog.event_trigger_out(event_trigger) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.event_trigger_out(event_trigger) is 'I/O'; + +create function pg_catalog.exp(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.exp(double precision) is 'natural exponential (e^x)'; + +create function pg_catalog.exp(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.exp(numeric) is 'natural exponential (e^x)'; + +create function pg_catalog.extract(text, date) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, date) is 'extract field from date'; + +create function pg_catalog.extract(text, interval) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, interval) is 'extract field from interval'; + +create function pg_catalog.extract(text, time with time zone) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, time with time zone) is 'extract field from time with time zone'; + +create function pg_catalog.extract(text, time) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, time) is 'extract field from time'; + +create function pg_catalog.extract(text, timestamp with time zone) returns numeric + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, timestamp with time zone) is 'extract field from timestamp with time zone'; + +create function pg_catalog.extract(text, timestamp) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.extract(text, timestamp) is 'extract field from timestamp'; + +create function pg_catalog.factorial(bigint) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.factorial(bigint) is 'factorial'; + +create function pg_catalog.family(inet) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.family(inet) is 'address family (4 for IPv4, 6 for IPv6)'; + +create function pg_catalog.fdw_handler_in(cstring) returns fdw_handler + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.fdw_handler_in(cstring) is 'I/O'; + +create function pg_catalog.fdw_handler_out(fdw_handler) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.fdw_handler_out(fdw_handler) is 'I/O'; + +create function pg_catalog.first_value(anyelement) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.first_value(anyelement) is 'fetch the first row value'; + +create function pg_catalog.float4(bigint) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(bigint) is 'convert int8 to float4'; + +create function pg_catalog.float4(double precision) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(double precision) is 'convert float8 to float4'; + +create function pg_catalog.float4(integer) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(integer) is 'convert int4 to float4'; + +create function pg_catalog.float4(jsonb) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(jsonb) is 'convert jsonb to float4'; + +create function pg_catalog.float4(numeric) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(numeric) is 'convert numeric to float4'; + +create function pg_catalog.float4(smallint) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4(smallint) is 'convert int2 to float4'; + +create function pg_catalog.float48div(real, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48div(real, double precision) is 'implementation of / operator'; + +create function pg_catalog.float48eq(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48eq(real, double precision) is 'implementation of = operator'; + +create function pg_catalog.float48ge(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48ge(real, double precision) is 'implementation of >= operator'; + +create function pg_catalog.float48gt(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48gt(real, double precision) is 'implementation of > operator'; + +create function pg_catalog.float48le(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48le(real, double precision) is 'implementation of <= operator'; + +create function pg_catalog.float48lt(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48lt(real, double precision) is 'implementation of < operator'; + +create function pg_catalog.float48mi(real, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48mi(real, double precision) is 'implementation of - operator'; + +create function pg_catalog.float48mul(real, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48mul(real, double precision) is 'implementation of * operator'; + +create function pg_catalog.float48ne(real, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48ne(real, double precision) is 'implementation of <> operator'; + +create function pg_catalog.float48pl(real, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float48pl(real, double precision) is 'implementation of + operator'; + +create function pg_catalog.float4_accum(double precision[], real) returns double precision[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4_accum(double precision[], real) is 'aggregate transition function'; + +create function pg_catalog.float4abs(real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4abs(real) is 'implementation of @ operator'; + +create function pg_catalog.float4div(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4div(real, real) is 'implementation of / operator'; + +create function pg_catalog.float4eq(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4eq(real, real) is 'implementation of = operator'; + +create function pg_catalog.float4ge(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4ge(real, real) is 'implementation of >= operator'; + +create function pg_catalog.float4gt(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4gt(real, real) is 'implementation of > operator'; + +create function pg_catalog.float4in(cstring) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4in(cstring) is 'I/O'; + +create function pg_catalog.float4larger(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4larger(real, real) is 'larger of two'; + +create function pg_catalog.float4le(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4le(real, real) is 'implementation of <= operator'; + +create function pg_catalog.float4lt(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4lt(real, real) is 'implementation of < operator'; + +create function pg_catalog.float4mi(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4mi(real, real) is 'implementation of - operator'; + +create function pg_catalog.float4mul(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4mul(real, real) is 'implementation of * operator'; + +create function pg_catalog.float4ne(real, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4ne(real, real) is 'implementation of <> operator'; + +create function pg_catalog.float4out(real) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4out(real) is 'I/O'; + +create function pg_catalog.float4pl(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4pl(real, real) is 'implementation of + operator'; + +create function pg_catalog.float4recv(internal) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4recv(internal) is 'I/O'; + +create function pg_catalog.float4send(real) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4send(real) is 'I/O'; + +create function pg_catalog.float4smaller(real, real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4smaller(real, real) is 'smaller of two'; + +create function pg_catalog.float4um(real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4um(real) is 'implementation of - operator'; + +create function pg_catalog.float4up(real) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float4up(real) is 'implementation of + operator'; + +create function pg_catalog.float8(bigint) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(bigint) is 'convert int8 to float8'; + +create function pg_catalog.float8(integer) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(integer) is 'convert int4 to float8'; + +create function pg_catalog.float8(jsonb) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(jsonb) is 'convert jsonb to float8'; + +create function pg_catalog.float8(numeric) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(numeric) is 'convert numeric to float8'; + +create function pg_catalog.float8(real) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(real) is 'convert float4 to float8'; + +create function pg_catalog.float8(smallint) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8(smallint) is 'convert int2 to float8'; + +create function pg_catalog.float84div(double precision, real) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84div(double precision, real) is 'implementation of / operator'; + +create function pg_catalog.float84eq(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84eq(double precision, real) is 'implementation of = operator'; + +create function pg_catalog.float84ge(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84ge(double precision, real) is 'implementation of >= operator'; + +create function pg_catalog.float84gt(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84gt(double precision, real) is 'implementation of > operator'; + +create function pg_catalog.float84le(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84le(double precision, real) is 'implementation of <= operator'; + +create function pg_catalog.float84lt(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84lt(double precision, real) is 'implementation of < operator'; + +create function pg_catalog.float84mi(double precision, real) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84mi(double precision, real) is 'implementation of - operator'; + +create function pg_catalog.float84mul(double precision, real) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84mul(double precision, real) is 'implementation of * operator'; + +create function pg_catalog.float84ne(double precision, real) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84ne(double precision, real) is 'implementation of <> operator'; + +create function pg_catalog.float84pl(double precision, real) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float84pl(double precision, real) is 'implementation of + operator'; + +create function pg_catalog.float8_accum(double precision[], double precision) returns double precision[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_accum(double precision[], double precision) is 'aggregate transition function'; + +create function pg_catalog.float8_avg(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_avg(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_combine(double precision[], double precision[]) returns double precision[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_combine(double precision[], double precision[]) is 'aggregate combine function'; + +create function pg_catalog.float8_corr(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_corr(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_covar_pop(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_covar_pop(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_covar_samp(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_covar_samp(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_accum(double precision[], double precision, double precision) returns double precision[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_accum(double precision[], double precision, double precision) is 'aggregate transition function'; + +create function pg_catalog.float8_regr_avgx(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_avgx(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_avgy(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_avgy(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_combine(double precision[], double precision[]) returns double precision[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_combine(double precision[], double precision[]) is 'aggregate combine function'; + +create function pg_catalog.float8_regr_intercept(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_intercept(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_r2(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_r2(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_slope(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_slope(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_sxx(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_sxx(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_sxy(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_sxy(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_regr_syy(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_regr_syy(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_stddev_pop(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_stddev_pop(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_stddev_samp(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_stddev_samp(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_var_pop(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_var_pop(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8_var_samp(double precision[]) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8_var_samp(double precision[]) is 'aggregate final function'; + +create function pg_catalog.float8abs(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8abs(double precision) is 'implementation of @ operator'; + +create function pg_catalog.float8div(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8div(double precision, double precision) is 'implementation of / operator'; + +create function pg_catalog.float8eq(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8eq(double precision, double precision) is 'implementation of = operator'; + +create function pg_catalog.float8ge(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8ge(double precision, double precision) is 'implementation of >= operator'; + +create function pg_catalog.float8gt(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8gt(double precision, double precision) is 'implementation of > operator'; + +create function pg_catalog.float8in(cstring) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8in(cstring) is 'I/O'; + +create function pg_catalog.float8larger(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8larger(double precision, double precision) is 'larger of two'; + +create function pg_catalog.float8le(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8le(double precision, double precision) is 'implementation of <= operator'; + +create function pg_catalog.float8lt(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8lt(double precision, double precision) is 'implementation of < operator'; + +create function pg_catalog.float8mi(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8mi(double precision, double precision) is 'implementation of - operator'; + +create function pg_catalog.float8mul(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8mul(double precision, double precision) is 'implementation of * operator'; + +create function pg_catalog.float8ne(double precision, double precision) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8ne(double precision, double precision) is 'implementation of <> operator'; + +create function pg_catalog.float8out(double precision) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8out(double precision) is 'I/O'; + +create function pg_catalog.float8pl(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8pl(double precision, double precision) is 'implementation of + operator'; + +create function pg_catalog.float8recv(internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8recv(internal) is 'I/O'; + +create function pg_catalog.float8send(double precision) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8send(double precision) is 'I/O'; + +create function pg_catalog.float8smaller(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8smaller(double precision, double precision) is 'smaller of two'; + +create function pg_catalog.float8um(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8um(double precision) is 'implementation of - operator'; + +create function pg_catalog.float8up(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.float8up(double precision) is 'implementation of + operator'; + +create function pg_catalog.floor(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.floor(double precision) is 'nearest integer <= value'; + +create function pg_catalog.floor(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.floor(numeric) is 'nearest integer <= value'; + +create function pg_catalog.flt4_mul_cash(real, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.flt4_mul_cash(real, money) is 'implementation of * operator'; + +create function pg_catalog.flt8_mul_cash(double precision, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.flt8_mul_cash(double precision, money) is 'implementation of * operator'; + +create function pg_catalog.fmgr_c_validator(oid) returns void + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.fmgr_c_validator(oid) is '(internal)'; + +create function pg_catalog.fmgr_internal_validator(oid) returns void + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.fmgr_internal_validator(oid) is '(internal)'; + +create function pg_catalog.fmgr_sql_validator(oid) returns void + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.fmgr_sql_validator(oid) is '(internal)'; + +create function pg_catalog.format(text) returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.format(text) is 'format text message'; + +create function pg_catalog.format(text, "any") returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.format(text, "any") is 'format text message'; + +create function pg_catalog.format_type(oid, integer) returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.format_type(oid, integer) is 'format a type oid and atttypmod to canonical SQL'; + +create function pg_catalog.gb18030_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gb18030_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for GB18030 to UTF8'; + +create function pg_catalog.gbk_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gbk_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for GBK to UTF8'; + +create function pg_catalog.gcd(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gcd(bigint, bigint) is 'greatest common divisor'; + +create function pg_catalog.gcd(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gcd(integer, integer) is 'greatest common divisor'; + +create function pg_catalog.gcd(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gcd(numeric, numeric) is 'greatest common divisor'; + +create function pg_catalog.gen_random_uuid() returns uuid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gen_random_uuid() is 'generate random UUID'; + +create function pg_catalog.generate_series(bigint, bigint) returns setof bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(bigint, bigint) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(bigint, bigint, bigint) returns setof bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(bigint, bigint, bigint) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(integer, integer) returns setof integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(integer, integer) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(integer, integer, integer) returns setof integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(integer, integer, integer) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(numeric, numeric) returns setof numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(numeric, numeric) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(numeric, numeric, numeric) returns setof numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(numeric, numeric, numeric) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval) returns setof timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval, text) returns setof timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval, text) is 'non-persistent series generator'; + +create function pg_catalog.generate_series(timestamp, timestamp, interval) returns setof timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series(timestamp, timestamp, interval) is 'non-persistent series generator'; + +create function pg_catalog.generate_series_int4_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series_int4_support(internal) is 'planner support for generate_series'; + +create function pg_catalog.generate_series_int8_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_series_int8_support(internal) is 'planner support for generate_series'; + +create function pg_catalog.generate_subscripts(anyarray, integer) returns setof integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_subscripts(anyarray, integer) is 'array subscripts generator'; + +create function pg_catalog.generate_subscripts(anyarray, integer, boolean) returns setof integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.generate_subscripts(anyarray, integer, boolean) is 'array subscripts generator'; + +create function pg_catalog.get_bit(bit, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.get_bit(bit, integer) is 'get bit'; + +create function pg_catalog.get_bit(bytea, bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.get_bit(bytea, bigint) is 'get bit'; + +create function pg_catalog.get_byte(bytea, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.get_byte(bytea, integer) is 'get byte'; + +create function pg_catalog.get_current_ts_config() returns regconfig + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.get_current_ts_config() is 'get current tsearch configuration'; + +create function pg_catalog.getdatabaseencoding() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.getdatabaseencoding() is 'encoding name of current database'; + +create function pg_catalog.getpgusername() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.getpgusername() is 'deprecated, use current_user instead'; + +create function pg_catalog.gin_clean_pending_list(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_clean_pending_list(regclass) is 'clean up GIN pending list'; + +create function pg_catalog.gin_cmp_prefix(text, text, smallint, internal) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_cmp_prefix(text, text, smallint, internal) is 'GIN tsvector support'; + +create function pg_catalog.gin_cmp_tslexeme(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_cmp_tslexeme(text, text) is 'GIN tsvector support'; + +create function pg_catalog.gin_compare_jsonb(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_compare_jsonb(text, text) is 'GIN support'; + +create function pg_catalog.gin_consistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_consistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_consistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_consistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_extract_jsonb(jsonb, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_jsonb(jsonb, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_extract_jsonb_path(jsonb, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_jsonb_path(jsonb, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_extract_jsonb_query(jsonb, internal, smallint, internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_jsonb_query(jsonb, internal, smallint, internal, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_extract_jsonb_query_path(jsonb, internal, smallint, internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_jsonb_query_path(jsonb, internal, smallint, internal, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal) is 'GIN tsvector support (obsolete)'; + +create function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal, internal, internal) is 'GIN tsvector support (obsolete)'; + +create function pg_catalog.gin_extract_tsquery(tsvector, internal, smallint, internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_tsquery(tsvector, internal, smallint, internal, internal, internal, internal) is 'GIN tsvector support'; + +create function pg_catalog.gin_extract_tsvector(tsvector, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_tsvector(tsvector, internal) is 'GIN tsvector support (obsolete)'; + +create function pg_catalog.gin_extract_tsvector(tsvector, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_extract_tsvector(tsvector, internal, internal) is 'GIN tsvector support'; + +create function pg_catalog.gin_triconsistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_triconsistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_triconsistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_triconsistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal) is 'GIN support'; + +create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal) is 'GIN tsvector support (obsolete)'; + +create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal, internal, internal) is 'GIN tsvector support (obsolete)'; + +create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsvector, integer, internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_tsquery_consistent(internal, smallint, tsvector, integer, internal, internal, internal, internal) is 'GIN tsvector support'; + +create function pg_catalog.gin_tsquery_triconsistent(internal, smallint, tsvector, integer, internal, internal, internal) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gin_tsquery_triconsistent(internal, smallint, tsvector, integer, internal, internal, internal) is 'GIN tsvector support'; + +create function pg_catalog.ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal, internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal, internal, internal) is 'GIN array support'; + +create function pg_catalog.ginarrayextract(anyarray, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginarrayextract(anyarray, internal) is 'GIN array support (obsolete)'; + +create function pg_catalog.ginarrayextract(anyarray, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginarrayextract(anyarray, internal, internal) is 'GIN array support'; + +create function pg_catalog.ginarraytriconsistent(internal, smallint, anyarray, integer, internal, internal, internal) returns "char" + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginarraytriconsistent(internal, smallint, anyarray, integer, internal, internal, internal) is 'GIN array support'; + +create function pg_catalog.ginhandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginhandler(internal) is 'gin index access method handler'; + +create function pg_catalog.ginqueryarrayextract(anyarray, internal, smallint, internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ginqueryarrayextract(anyarray, internal, smallint, internal, internal, internal, internal) is 'GIN array support'; + +create function pg_catalog.gist_box_consistent(internal, box, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_consistent(internal, box, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_box_distance(internal, box, smallint, oid, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_distance(internal, box, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_box_penalty(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_penalty(internal, internal, internal) is 'GiST support'; + +create function pg_catalog.gist_box_picksplit(internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_picksplit(internal, internal) is 'GiST support'; + +create function pg_catalog.gist_box_same(box, box, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_same(box, box, internal) is 'GiST support'; + +create function pg_catalog.gist_box_union(internal, internal) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_box_union(internal, internal) is 'GiST support'; + +create function pg_catalog.gist_circle_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_circle_compress(internal) is 'GiST support'; + +create function pg_catalog.gist_circle_consistent(internal, circle, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_circle_consistent(internal, circle, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_circle_distance(internal, circle, smallint, oid, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_circle_distance(internal, circle, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_point_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_point_compress(internal) is 'GiST support'; + +create function pg_catalog.gist_point_consistent(internal, point, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_point_consistent(internal, point, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_point_distance(internal, point, smallint, oid, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_point_distance(internal, point, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_point_fetch(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_point_fetch(internal) is 'GiST support'; + +create function pg_catalog.gist_point_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_point_sortsupport(internal) is 'sort support'; + +create function pg_catalog.gist_poly_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_poly_compress(internal) is 'GiST support'; + +create function pg_catalog.gist_poly_consistent(internal, polygon, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_poly_consistent(internal, polygon, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gist_poly_distance(internal, polygon, smallint, oid, internal) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gist_poly_distance(internal, polygon, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.gisthandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gisthandler(internal) is 'gist index access method handler'; + +create function pg_catalog.gtsquery_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_compress(internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsquery_consistent(internal, internal, integer, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_consistent(internal, internal, integer, oid, internal) is 'GiST tsquery support (obsolete)'; + +create function pg_catalog.gtsquery_consistent(internal, tsquery, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_consistent(internal, tsquery, smallint, oid, internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsquery_penalty(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_penalty(internal, internal, internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsquery_picksplit(internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_picksplit(internal, internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsquery_same(bigint, bigint, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_same(bigint, bigint, internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsquery_union(internal, internal) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsquery_union(internal, internal) is 'GiST tsquery support'; + +create function pg_catalog.gtsvector_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_compress(internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_consistent(internal, gtsvector, integer, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_consistent(internal, gtsvector, integer, oid, internal) is 'GiST tsvector support (obsolete)'; + +create function pg_catalog.gtsvector_consistent(internal, tsvector, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_consistent(internal, tsvector, smallint, oid, internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_decompress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_decompress(internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_options(internal) returns void + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_options(internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_penalty(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_penalty(internal, internal, internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_picksplit(internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_picksplit(internal, internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_same(gtsvector, gtsvector, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_same(gtsvector, gtsvector, internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvector_union(internal, internal) returns gtsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvector_union(internal, internal) is 'GiST tsvector support'; + +create function pg_catalog.gtsvectorin(cstring) returns gtsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvectorin(cstring) is 'I/O'; + +create function pg_catalog.gtsvectorout(gtsvector) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.gtsvectorout(gtsvector) is 'I/O'; + +create function pg_catalog.has_any_column_privilege(name, oid, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(name, oid, text) is 'user privilege on any column by username, rel oid'; + +create function pg_catalog.has_any_column_privilege(name, text, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(name, text, text) is 'user privilege on any column by username, rel name'; + +create function pg_catalog.has_any_column_privilege(oid, oid, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(oid, oid, text) is 'user privilege on any column by user oid, rel oid'; + +create function pg_catalog.has_any_column_privilege(oid, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(oid, text) is 'current user privilege on any column by rel oid'; + +create function pg_catalog.has_any_column_privilege(oid, text, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(oid, text, text) is 'user privilege on any column by user oid, rel name'; + +create function pg_catalog.has_any_column_privilege(text, text) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_any_column_privilege(text, text) is 'current user privilege on any column by rel name'; + +create function pg_catalog.has_column_privilege(name, oid, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(name, oid, smallint, text) is 'user privilege on column by username, rel oid, col attnum'; + +create function pg_catalog.has_column_privilege(name, oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(name, oid, text, text) is 'user privilege on column by username, rel oid, col name'; + +create function pg_catalog.has_column_privilege(name, text, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(name, text, smallint, text) is 'user privilege on column by username, rel name, col attnum'; + +create function pg_catalog.has_column_privilege(name, text, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(name, text, text, text) is 'user privilege on column by username, rel name, col name'; + +create function pg_catalog.has_column_privilege(oid, oid, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, oid, smallint, text) is 'user privilege on column by user oid, rel oid, col attnum'; + +create function pg_catalog.has_column_privilege(oid, oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, oid, text, text) is 'user privilege on column by user oid, rel oid, col name'; + +create function pg_catalog.has_column_privilege(oid, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, smallint, text) is 'current user privilege on column by rel oid, col attnum'; + +create function pg_catalog.has_column_privilege(oid, text, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, text, smallint, text) is 'user privilege on column by user oid, rel name, col attnum'; + +create function pg_catalog.has_column_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, text, text) is 'current user privilege on column by rel oid, col name'; + +create function pg_catalog.has_column_privilege(oid, text, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(oid, text, text, text) is 'user privilege on column by user oid, rel name, col name'; + +create function pg_catalog.has_column_privilege(text, smallint, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(text, smallint, text) is 'current user privilege on column by rel name, col attnum'; + +create function pg_catalog.has_column_privilege(text, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_column_privilege(text, text, text) is 'current user privilege on column by rel name, col name'; + +create function pg_catalog.has_database_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(name, oid, text) is 'user privilege on database by username, database oid'; + +create function pg_catalog.has_database_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(name, text, text) is 'user privilege on database by username, database name'; + +create function pg_catalog.has_database_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(oid, oid, text) is 'user privilege on database by user oid, database oid'; + +create function pg_catalog.has_database_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(oid, text) is 'current user privilege on database by database oid'; + +create function pg_catalog.has_database_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(oid, text, text) is 'user privilege on database by user oid, database name'; + +create function pg_catalog.has_database_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_database_privilege(text, text) is 'current user privilege on database by database name'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(name, oid, text) is 'user privilege on foreign data wrapper by username, foreign data wrapper oid'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(name, text, text) is 'user privilege on foreign data wrapper by username, foreign data wrapper name'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(oid, oid, text) is 'user privilege on foreign data wrapper by user oid, foreign data wrapper oid'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(oid, text) is 'current user privilege on foreign data wrapper by foreign data wrapper oid'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(oid, text, text) is 'user privilege on foreign data wrapper by user oid, foreign data wrapper name'; + +create function pg_catalog.has_foreign_data_wrapper_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_foreign_data_wrapper_privilege(text, text) is 'current user privilege on foreign data wrapper by foreign data wrapper name'; + +create function pg_catalog.has_function_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(name, oid, text) is 'user privilege on function by username, function oid'; + +create function pg_catalog.has_function_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(name, text, text) is 'user privilege on function by username, function name'; + +create function pg_catalog.has_function_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(oid, oid, text) is 'user privilege on function by user oid, function oid'; + +create function pg_catalog.has_function_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(oid, text) is 'current user privilege on function by function oid'; + +create function pg_catalog.has_function_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(oid, text, text) is 'user privilege on function by user oid, function name'; + +create function pg_catalog.has_function_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_function_privilege(text, text) is 'current user privilege on function by function name'; + +create function pg_catalog.has_language_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(name, oid, text) is 'user privilege on language by username, language oid'; + +create function pg_catalog.has_language_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(name, text, text) is 'user privilege on language by username, language name'; + +create function pg_catalog.has_language_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(oid, oid, text) is 'user privilege on language by user oid, language oid'; + +create function pg_catalog.has_language_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(oid, text) is 'current user privilege on language by language oid'; + +create function pg_catalog.has_language_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(oid, text, text) is 'user privilege on language by user oid, language name'; + +create function pg_catalog.has_language_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_language_privilege(text, text) is 'current user privilege on language by language name'; + +create function pg_catalog.has_parameter_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_parameter_privilege(name, text, text) is 'user privilege on parameter by username, parameter name'; + +create function pg_catalog.has_parameter_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_parameter_privilege(oid, text, text) is 'user privilege on parameter by user oid, parameter name'; + +create function pg_catalog.has_parameter_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_parameter_privilege(text, text) is 'current user privilege on parameter by parameter name'; + +create function pg_catalog.has_schema_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(name, oid, text) is 'user privilege on schema by username, schema oid'; + +create function pg_catalog.has_schema_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(name, text, text) is 'user privilege on schema by username, schema name'; + +create function pg_catalog.has_schema_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(oid, oid, text) is 'user privilege on schema by user oid, schema oid'; + +create function pg_catalog.has_schema_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(oid, text) is 'current user privilege on schema by schema oid'; + +create function pg_catalog.has_schema_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(oid, text, text) is 'user privilege on schema by user oid, schema name'; + +create function pg_catalog.has_schema_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_schema_privilege(text, text) is 'current user privilege on schema by schema name'; + +create function pg_catalog.has_sequence_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(name, oid, text) is 'user privilege on sequence by username, seq oid'; + +create function pg_catalog.has_sequence_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(name, text, text) is 'user privilege on sequence by username, seq name'; + +create function pg_catalog.has_sequence_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(oid, oid, text) is 'user privilege on sequence by user oid, seq oid'; + +create function pg_catalog.has_sequence_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(oid, text) is 'current user privilege on sequence by seq oid'; + +create function pg_catalog.has_sequence_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(oid, text, text) is 'user privilege on sequence by user oid, seq name'; + +create function pg_catalog.has_sequence_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_sequence_privilege(text, text) is 'current user privilege on sequence by seq name'; + +create function pg_catalog.has_server_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(name, oid, text) is 'user privilege on server by username, server oid'; + +create function pg_catalog.has_server_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(name, text, text) is 'user privilege on server by username, server name'; + +create function pg_catalog.has_server_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(oid, oid, text) is 'user privilege on server by user oid, server oid'; + +create function pg_catalog.has_server_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(oid, text) is 'current user privilege on server by server oid'; + +create function pg_catalog.has_server_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(oid, text, text) is 'user privilege on server by user oid, server name'; + +create function pg_catalog.has_server_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_server_privilege(text, text) is 'current user privilege on server by server name'; + +create function pg_catalog.has_table_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(name, oid, text) is 'user privilege on relation by username, rel oid'; + +create function pg_catalog.has_table_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(name, text, text) is 'user privilege on relation by username, rel name'; + +create function pg_catalog.has_table_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(oid, oid, text) is 'user privilege on relation by user oid, rel oid'; + +create function pg_catalog.has_table_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(oid, text) is 'current user privilege on relation by rel oid'; + +create function pg_catalog.has_table_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(oid, text, text) is 'user privilege on relation by user oid, rel name'; + +create function pg_catalog.has_table_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_table_privilege(text, text) is 'current user privilege on relation by rel name'; + +create function pg_catalog.has_tablespace_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(name, oid, text) is 'user privilege on tablespace by username, tablespace oid'; + +create function pg_catalog.has_tablespace_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(name, text, text) is 'user privilege on tablespace by username, tablespace name'; + +create function pg_catalog.has_tablespace_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(oid, oid, text) is 'user privilege on tablespace by user oid, tablespace oid'; + +create function pg_catalog.has_tablespace_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(oid, text) is 'current user privilege on tablespace by tablespace oid'; + +create function pg_catalog.has_tablespace_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(oid, text, text) is 'user privilege on tablespace by user oid, tablespace name'; + +create function pg_catalog.has_tablespace_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_tablespace_privilege(text, text) is 'current user privilege on tablespace by tablespace name'; + +create function pg_catalog.has_type_privilege(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(name, oid, text) is 'user privilege on type by username, type oid'; + +create function pg_catalog.has_type_privilege(name, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(name, text, text) is 'user privilege on type by username, type name'; + +create function pg_catalog.has_type_privilege(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(oid, oid, text) is 'user privilege on type by user oid, type oid'; + +create function pg_catalog.has_type_privilege(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(oid, text) is 'current user privilege on type by type oid'; + +create function pg_catalog.has_type_privilege(oid, text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(oid, text, text) is 'user privilege on type by user oid, type name'; + +create function pg_catalog.has_type_privilege(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.has_type_privilege(text, text) is 'current user privilege on type by type name'; + +create function pg_catalog.hash_aclitem(aclitem) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_aclitem(aclitem) is 'hash'; + +create function pg_catalog.hash_aclitem_extended(aclitem, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_aclitem_extended(aclitem, bigint) is 'hash'; + +create function pg_catalog.hash_array(anyarray) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_array(anyarray) is 'hash'; + +create function pg_catalog.hash_array_extended(anyarray, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_array_extended(anyarray, bigint) is 'hash'; + +create function pg_catalog.hash_multirange(anymultirange) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_multirange(anymultirange) is 'hash a multirange'; + +create function pg_catalog.hash_multirange_extended(anymultirange, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_multirange_extended(anymultirange, bigint) is 'hash a multirange'; + +create function pg_catalog.hash_numeric(numeric) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_numeric(numeric) is 'hash'; + +create function pg_catalog.hash_numeric_extended(numeric, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_numeric_extended(numeric, bigint) is 'hash'; + +create function pg_catalog.hash_range(anyrange) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_range(anyrange) is 'hash a range'; + +create function pg_catalog.hash_range_extended(anyrange, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_range_extended(anyrange, bigint) is 'hash a range'; + +create function pg_catalog.hash_record(record) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_record(record) is 'hash'; + +create function pg_catalog.hash_record_extended(record, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hash_record_extended(record, bigint) is 'hash'; + +create function pg_catalog.hashbpchar(char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashbpchar(char) is 'hash'; + +create function pg_catalog.hashbpcharextended(char, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashbpcharextended(char, bigint) is 'hash'; + +create function pg_catalog.hashchar("char") returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashchar("char") is 'hash'; + +create function pg_catalog.hashcharextended("char", bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashcharextended("char", bigint) is 'hash'; + +create function pg_catalog.hashenum(anyenum) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashenum(anyenum) is 'hash'; + +create function pg_catalog.hashenumextended(anyenum, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashenumextended(anyenum, bigint) is 'hash'; + +create function pg_catalog.hashfloat4(real) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashfloat4(real) is 'hash'; + +create function pg_catalog.hashfloat4extended(real, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashfloat4extended(real, bigint) is 'hash'; + +create function pg_catalog.hashfloat8(double precision) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashfloat8(double precision) is 'hash'; + +create function pg_catalog.hashfloat8extended(double precision, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashfloat8extended(double precision, bigint) is 'hash'; + +create function pg_catalog.hashhandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashhandler(internal) is 'hash index access method handler'; + +create function pg_catalog.hashinet(inet) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashinet(inet) is 'hash'; + +create function pg_catalog.hashinetextended(inet, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashinetextended(inet, bigint) is 'hash'; + +create function pg_catalog.hashint2(smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint2(smallint) is 'hash'; + +create function pg_catalog.hashint2extended(smallint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint2extended(smallint, bigint) is 'hash'; + +create function pg_catalog.hashint4(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint4(integer) is 'hash'; + +create function pg_catalog.hashint4extended(integer, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint4extended(integer, bigint) is 'hash'; + +create function pg_catalog.hashint8(bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint8(bigint) is 'hash'; + +create function pg_catalog.hashint8extended(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashint8extended(bigint, bigint) is 'hash'; + +create function pg_catalog.hashmacaddr(macaddr) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashmacaddr(macaddr) is 'hash'; + +create function pg_catalog.hashmacaddr8(macaddr8) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashmacaddr8(macaddr8) is 'hash'; + +create function pg_catalog.hashmacaddr8extended(macaddr8, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashmacaddr8extended(macaddr8, bigint) is 'hash'; + +create function pg_catalog.hashmacaddrextended(macaddr, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashmacaddrextended(macaddr, bigint) is 'hash'; + +create function pg_catalog.hashname(name) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashname(name) is 'hash'; + +create function pg_catalog.hashnameextended(name, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashnameextended(name, bigint) is 'hash'; + +create function pg_catalog.hashoid(oid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashoid(oid) is 'hash'; + +create function pg_catalog.hashoidextended(oid, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashoidextended(oid, bigint) is 'hash'; + +create function pg_catalog.hashoidvector(oidvector) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashoidvector(oidvector) is 'hash'; + +create function pg_catalog.hashoidvectorextended(oidvector, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashoidvectorextended(oidvector, bigint) is 'hash'; + +create function pg_catalog.hashtext(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashtext(text) is 'hash'; + +create function pg_catalog.hashtextextended(text, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashtextextended(text, bigint) is 'hash'; + +create function pg_catalog.hashtid(tid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashtid(tid) is 'hash'; + +create function pg_catalog.hashtidextended(tid, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashtidextended(tid, bigint) is 'hash'; + +create function pg_catalog.hashvarlena(internal) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashvarlena(internal) is 'hash'; + +create function pg_catalog.hashvarlenaextended(internal, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hashvarlenaextended(internal, bigint) is 'hash'; + +create function pg_catalog.heap_tableam_handler(internal) returns table_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.heap_tableam_handler(internal) is 'row-oriented heap table access method handler'; + +create function pg_catalog.height(box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.height(box) is 'box height'; + +create function pg_catalog.host(inet) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.host(inet) is 'show address octets only'; + +create function pg_catalog.hostmask(inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.hostmask(inet) is 'hostmask of address'; + +create function pg_catalog.iclikejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iclikejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of ILIKE'; + +create function pg_catalog.iclikesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iclikesel(internal, oid, internal, integer) is 'restriction selectivity of ILIKE'; + +create function pg_catalog.icnlikejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icnlikejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of NOT ILIKE'; + +create function pg_catalog.icnlikesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icnlikesel(internal, oid, internal, integer) is 'restriction selectivity of NOT ILIKE'; + +create function pg_catalog.icregexeqjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icregexeqjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of case-insensitive regex match'; + +create function pg_catalog.icregexeqsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icregexeqsel(internal, oid, internal, integer) is 'restriction selectivity of case-insensitive regex match'; + +create function pg_catalog.icregexnejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icregexnejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of case-insensitive regex non-match'; + +create function pg_catalog.icregexnesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.icregexnesel(internal, oid, internal, integer) is 'restriction selectivity of case-insensitive regex non-match'; + +create function pg_catalog.in_range(bigint, bigint, bigint, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(bigint, bigint, bigint, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(date, date, interval, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(date, date, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(double precision, double precision, double precision, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(double precision, double precision, double precision, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(integer, integer, bigint, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(integer, integer, bigint, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(integer, integer, integer, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(integer, integer, integer, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(integer, integer, smallint, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(integer, integer, smallint, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(interval, interval, interval, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(interval, interval, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(numeric, numeric, numeric, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(numeric, numeric, numeric, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(real, real, double precision, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(real, real, double precision, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(smallint, smallint, bigint, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(smallint, smallint, bigint, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(smallint, smallint, integer, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(smallint, smallint, integer, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(smallint, smallint, smallint, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(smallint, smallint, smallint, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(time with time zone, time with time zone, interval, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(time with time zone, time with time zone, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(time, time, interval, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(time, time, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(timestamp with time zone, timestamp with time zone, interval, boolean, boolean) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(timestamp with time zone, timestamp with time zone, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.in_range(timestamp, timestamp, interval, boolean, boolean) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.in_range(timestamp, timestamp, interval, boolean, boolean) is 'window RANGE support'; + +create function pg_catalog.index_am_handler_in(cstring) returns index_am_handler + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.index_am_handler_in(cstring) is 'I/O'; + +create function pg_catalog.index_am_handler_out(index_am_handler) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.index_am_handler_out(index_am_handler) is 'I/O'; + +create function pg_catalog.inet_client_addr() returns inet + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_client_addr() is 'inet address of the client'; + +create function pg_catalog.inet_client_port() returns integer + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_client_port() is 'client''s port number for this connection'; + +create function pg_catalog.inet_gist_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_compress(internal) is 'GiST support'; + +create function pg_catalog.inet_gist_consistent(internal, inet, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_consistent(internal, inet, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.inet_gist_fetch(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_fetch(internal) is 'GiST support'; + +create function pg_catalog.inet_gist_penalty(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_penalty(internal, internal, internal) is 'GiST support'; + +create function pg_catalog.inet_gist_picksplit(internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_picksplit(internal, internal) is 'GiST support'; + +create function pg_catalog.inet_gist_same(inet, inet, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_same(inet, inet, internal) is 'GiST support'; + +create function pg_catalog.inet_gist_union(internal, internal) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_gist_union(internal, internal) is 'GiST support'; + +create function pg_catalog.inet_in(cstring) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_in(cstring) is 'I/O'; + +create function pg_catalog.inet_merge(inet, inet) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_merge(inet, inet) is 'the smallest network which includes both of the given networks'; + +create function pg_catalog.inet_out(inet) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_out(inet) is 'I/O'; + +create function pg_catalog.inet_recv(internal) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_recv(internal) is 'I/O'; + +create function pg_catalog.inet_same_family(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_same_family(inet, inet) is 'are the addresses from the same family?'; + +create function pg_catalog.inet_send(inet) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_send(inet) is 'I/O'; + +create function pg_catalog.inet_server_addr() returns inet + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_server_addr() is 'inet address of the server'; + +create function pg_catalog.inet_server_port() returns integer + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_server_port() is 'server''s port number for this connection'; + +create function pg_catalog.inet_spg_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_spg_choose(internal, internal) is 'SP-GiST support'; + +create function pg_catalog.inet_spg_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_spg_config(internal, internal) is 'SP-GiST support'; + +create function pg_catalog.inet_spg_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_spg_inner_consistent(internal, internal) is 'SP-GiST support'; + +create function pg_catalog.inet_spg_leaf_consistent(internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_spg_leaf_consistent(internal, internal) is 'SP-GiST support'; + +create function pg_catalog.inet_spg_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inet_spg_picksplit(internal, internal) is 'SP-GiST support'; + +create function pg_catalog.inetand(inet, inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetand(inet, inet) is 'implementation of & operator'; + +create function pg_catalog.inetmi(inet, inet) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetmi(inet, inet) is 'implementation of - operator'; + +create function pg_catalog.inetmi_int8(inet, bigint) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetmi_int8(inet, bigint) is 'implementation of - operator'; + +create function pg_catalog.inetnot(inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetnot(inet) is 'implementation of ~ operator'; + +create function pg_catalog.inetor(inet, inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetor(inet, inet) is 'implementation of | operator'; + +create function pg_catalog.inetpl(inet, bigint) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inetpl(inet, bigint) is 'implementation of + operator'; + +create function pg_catalog.initcap(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.initcap(text) is 'capitalize each word'; + +create function pg_catalog.int2(bigint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(bigint) is 'convert int8 to int2'; + +create function pg_catalog.int2(double precision) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(double precision) is 'convert float8 to int2'; + +create function pg_catalog.int2(integer) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(integer) is 'convert int4 to int2'; + +create function pg_catalog.int2(jsonb) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(jsonb) is 'convert jsonb to int2'; + +create function pg_catalog.int2(numeric) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(numeric) is 'convert numeric to int2'; + +create function pg_catalog.int2(real) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2(real) is 'convert float4 to int2'; + +create function pg_catalog.int24div(smallint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24div(smallint, integer) is 'implementation of / operator'; + +create function pg_catalog.int24eq(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24eq(smallint, integer) is 'implementation of = operator'; + +create function pg_catalog.int24ge(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24ge(smallint, integer) is 'implementation of >= operator'; + +create function pg_catalog.int24gt(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24gt(smallint, integer) is 'implementation of > operator'; + +create function pg_catalog.int24le(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24le(smallint, integer) is 'implementation of <= operator'; + +create function pg_catalog.int24lt(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24lt(smallint, integer) is 'implementation of < operator'; + +create function pg_catalog.int24mi(smallint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24mi(smallint, integer) is 'implementation of - operator'; + +create function pg_catalog.int24mul(smallint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24mul(smallint, integer) is 'implementation of * operator'; + +create function pg_catalog.int24ne(smallint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24ne(smallint, integer) is 'implementation of <> operator'; + +create function pg_catalog.int24pl(smallint, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int24pl(smallint, integer) is 'implementation of + operator'; + +create function pg_catalog.int28div(smallint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28div(smallint, bigint) is 'implementation of / operator'; + +create function pg_catalog.int28eq(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28eq(smallint, bigint) is 'implementation of = operator'; + +create function pg_catalog.int28ge(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28ge(smallint, bigint) is 'implementation of >= operator'; + +create function pg_catalog.int28gt(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28gt(smallint, bigint) is 'implementation of > operator'; + +create function pg_catalog.int28le(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28le(smallint, bigint) is 'implementation of <= operator'; + +create function pg_catalog.int28lt(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28lt(smallint, bigint) is 'implementation of < operator'; + +create function pg_catalog.int28mi(smallint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28mi(smallint, bigint) is 'implementation of - operator'; + +create function pg_catalog.int28mul(smallint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28mul(smallint, bigint) is 'implementation of * operator'; + +create function pg_catalog.int28ne(smallint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28ne(smallint, bigint) is 'implementation of <> operator'; + +create function pg_catalog.int28pl(smallint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int28pl(smallint, bigint) is 'implementation of + operator'; + +create function pg_catalog.int2_accum(internal, smallint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_accum(internal, smallint) is 'aggregate transition function'; + +create function pg_catalog.int2_accum_inv(internal, smallint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_accum_inv(internal, smallint) is 'aggregate transition function'; + +create function pg_catalog.int2_avg_accum(bigint[], smallint) returns bigint[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_avg_accum(bigint[], smallint) is 'aggregate transition function'; + +create function pg_catalog.int2_avg_accum_inv(bigint[], smallint) returns bigint[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_avg_accum_inv(bigint[], smallint) is 'aggregate transition function'; + +create function pg_catalog.int2_mul_cash(smallint, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_mul_cash(smallint, money) is 'implementation of * operator'; + +create function pg_catalog.int2_sum(bigint, smallint) returns bigint + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2_sum(bigint, smallint) is 'aggregate transition function'; + +create function pg_catalog.int2abs(smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2abs(smallint) is 'implementation of @ operator'; + +create function pg_catalog.int2and(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2and(smallint, smallint) is 'implementation of & operator'; + +create function pg_catalog.int2div(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2div(smallint, smallint) is 'implementation of / operator'; + +create function pg_catalog.int2eq(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2eq(smallint, smallint) is 'implementation of = operator'; + +create function pg_catalog.int2ge(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2ge(smallint, smallint) is 'implementation of >= operator'; + +create function pg_catalog.int2gt(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2gt(smallint, smallint) is 'implementation of > operator'; + +create function pg_catalog.int2in(cstring) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2in(cstring) is 'I/O'; + +create function pg_catalog.int2int4_sum(bigint[]) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2int4_sum(bigint[]) is 'aggregate final function'; + +create function pg_catalog.int2larger(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2larger(smallint, smallint) is 'larger of two'; + +create function pg_catalog.int2le(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2le(smallint, smallint) is 'implementation of <= operator'; + +create function pg_catalog.int2lt(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2lt(smallint, smallint) is 'implementation of < operator'; + +create function pg_catalog.int2mi(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2mi(smallint, smallint) is 'implementation of - operator'; + +create function pg_catalog.int2mod(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2mod(smallint, smallint) is 'implementation of % operator'; + +create function pg_catalog.int2mul(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2mul(smallint, smallint) is 'implementation of * operator'; + +create function pg_catalog.int2ne(smallint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2ne(smallint, smallint) is 'implementation of <> operator'; + +create function pg_catalog.int2not(smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2not(smallint) is 'implementation of ~ operator'; + +create function pg_catalog.int2or(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2or(smallint, smallint) is 'implementation of | operator'; + +create function pg_catalog.int2out(smallint) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2out(smallint) is 'I/O'; + +create function pg_catalog.int2pl(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2pl(smallint, smallint) is 'implementation of + operator'; + +create function pg_catalog.int2recv(internal) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2recv(internal) is 'I/O'; + +create function pg_catalog.int2send(smallint) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2send(smallint) is 'I/O'; + +create function pg_catalog.int2shl(smallint, integer) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2shl(smallint, integer) is 'implementation of << operator'; + +create function pg_catalog.int2shr(smallint, integer) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2shr(smallint, integer) is 'implementation of >> operator'; + +create function pg_catalog.int2smaller(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2smaller(smallint, smallint) is 'smaller of two'; + +create function pg_catalog.int2um(smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2um(smallint) is 'implementation of - operator'; + +create function pg_catalog.int2up(smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2up(smallint) is 'implementation of + operator'; + +create function pg_catalog.int2vectorin(cstring) returns int2vector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2vectorin(cstring) is 'I/O'; + +create function pg_catalog.int2vectorout(int2vector) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2vectorout(int2vector) is 'I/O'; + +create function pg_catalog.int2vectorrecv(internal) returns int2vector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2vectorrecv(internal) is 'I/O'; + +create function pg_catalog.int2vectorsend(int2vector) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2vectorsend(int2vector) is 'I/O'; + +create function pg_catalog.int2xor(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int2xor(smallint, smallint) is 'implementation of # operator'; + +create function pg_catalog.int4("char") returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4("char") is 'convert char to int4'; + +create function pg_catalog.int4(bigint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(bigint) is 'convert int8 to int4'; + +create function pg_catalog.int4(bit) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(bit) is 'convert bitstring to int4'; + +create function pg_catalog.int4(boolean) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(boolean) is 'convert boolean to int4'; + +create function pg_catalog.int4(double precision) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(double precision) is 'convert float8 to int4'; + +create function pg_catalog.int4(jsonb) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(jsonb) is 'convert jsonb to int4'; + +create function pg_catalog.int4(numeric) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(numeric) is 'convert numeric to int4'; + +create function pg_catalog.int4(real) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(real) is 'convert float4 to int4'; + +create function pg_catalog.int4(smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4(smallint) is 'convert int2 to int4'; + +create function pg_catalog.int42div(integer, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42div(integer, smallint) is 'implementation of / operator'; + +create function pg_catalog.int42eq(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42eq(integer, smallint) is 'implementation of = operator'; + +create function pg_catalog.int42ge(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42ge(integer, smallint) is 'implementation of >= operator'; + +create function pg_catalog.int42gt(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42gt(integer, smallint) is 'implementation of > operator'; + +create function pg_catalog.int42le(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42le(integer, smallint) is 'implementation of <= operator'; + +create function pg_catalog.int42lt(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42lt(integer, smallint) is 'implementation of < operator'; + +create function pg_catalog.int42mi(integer, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42mi(integer, smallint) is 'implementation of - operator'; + +create function pg_catalog.int42mul(integer, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42mul(integer, smallint) is 'implementation of * operator'; + +create function pg_catalog.int42ne(integer, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42ne(integer, smallint) is 'implementation of <> operator'; + +create function pg_catalog.int42pl(integer, smallint) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int42pl(integer, smallint) is 'implementation of + operator'; + +create function pg_catalog.int48div(integer, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48div(integer, bigint) is 'implementation of / operator'; + +create function pg_catalog.int48eq(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48eq(integer, bigint) is 'implementation of = operator'; + +create function pg_catalog.int48ge(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48ge(integer, bigint) is 'implementation of >= operator'; + +create function pg_catalog.int48gt(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48gt(integer, bigint) is 'implementation of > operator'; + +create function pg_catalog.int48le(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48le(integer, bigint) is 'implementation of <= operator'; + +create function pg_catalog.int48lt(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48lt(integer, bigint) is 'implementation of < operator'; + +create function pg_catalog.int48mi(integer, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48mi(integer, bigint) is 'implementation of - operator'; + +create function pg_catalog.int48mul(integer, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48mul(integer, bigint) is 'implementation of * operator'; + +create function pg_catalog.int48ne(integer, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48ne(integer, bigint) is 'implementation of <> operator'; + +create function pg_catalog.int48pl(integer, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int48pl(integer, bigint) is 'implementation of + operator'; + +create function pg_catalog.int4_accum(internal, integer) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_accum(internal, integer) is 'aggregate transition function'; + +create function pg_catalog.int4_accum_inv(internal, integer) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_accum_inv(internal, integer) is 'aggregate transition function'; + +create function pg_catalog.int4_avg_accum(bigint[], integer) returns bigint[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_avg_accum(bigint[], integer) is 'aggregate transition function'; + +create function pg_catalog.int4_avg_accum_inv(bigint[], integer) returns bigint[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_avg_accum_inv(bigint[], integer) is 'aggregate transition function'; + +create function pg_catalog.int4_avg_combine(bigint[], bigint[]) returns bigint[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_avg_combine(bigint[], bigint[]) is 'aggregate combine function'; + +create function pg_catalog.int4_mul_cash(integer, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_mul_cash(integer, money) is 'implementation of * operator'; + +create function pg_catalog.int4_sum(bigint, integer) returns bigint + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4_sum(bigint, integer) is 'aggregate transition function'; + +create function pg_catalog.int4abs(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4abs(integer) is 'implementation of @ operator'; + +create function pg_catalog.int4and(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4and(integer, integer) is 'implementation of & operator'; + +create function pg_catalog.int4div(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4div(integer, integer) is 'implementation of / operator'; + +create function pg_catalog.int4eq(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4eq(integer, integer) is 'implementation of = operator'; + +create function pg_catalog.int4ge(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4ge(integer, integer) is 'implementation of >= operator'; + +create function pg_catalog.int4gt(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4gt(integer, integer) is 'implementation of > operator'; + +create function pg_catalog.int4in(cstring) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4in(cstring) is 'I/O'; + +create function pg_catalog.int4inc(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4inc(integer) is 'increment'; + +create function pg_catalog.int4larger(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4larger(integer, integer) is 'larger of two'; + +create function pg_catalog.int4le(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4le(integer, integer) is 'implementation of <= operator'; + +create function pg_catalog.int4lt(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4lt(integer, integer) is 'implementation of < operator'; + +create function pg_catalog.int4mi(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4mi(integer, integer) is 'implementation of - operator'; + +create function pg_catalog.int4mod(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4mod(integer, integer) is 'implementation of % operator'; + +create function pg_catalog.int4mul(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4mul(integer, integer) is 'implementation of * operator'; + +create function pg_catalog.int4multirange() returns int4multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4multirange() is 'int4multirange constructor'; + +create function pg_catalog.int4multirange(int4range) returns int4multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4multirange(int4range) is 'int4multirange constructor'; + +create function pg_catalog.int4multirange(int4range[]) returns int4multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4multirange(int4range[]) is 'int4multirange constructor'; + +create function pg_catalog.int4ne(integer, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4ne(integer, integer) is 'implementation of <> operator'; + +create function pg_catalog.int4not(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4not(integer) is 'implementation of ~ operator'; + +create function pg_catalog.int4or(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4or(integer, integer) is 'implementation of | operator'; + +create function pg_catalog.int4out(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4out(integer) is 'I/O'; + +create function pg_catalog.int4pl(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4pl(integer, integer) is 'implementation of + operator'; + +create function pg_catalog.int4range(integer, integer) returns int4range + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4range(integer, integer) is 'int4range constructor'; + +create function pg_catalog.int4range(integer, integer, text) returns int4range + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4range(integer, integer, text) is 'int4range constructor'; + +create function pg_catalog.int4range_canonical(int4range) returns int4range + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4range_canonical(int4range) is 'convert an int4 range to canonical form'; + +create function pg_catalog.int4range_subdiff(integer, integer) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4range_subdiff(integer, integer) is 'float8 difference of two int4 values'; + +create function pg_catalog.int4recv(internal) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4recv(internal) is 'I/O'; + +create function pg_catalog.int4send(integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4send(integer) is 'I/O'; + +create function pg_catalog.int4shl(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4shl(integer, integer) is 'implementation of << operator'; + +create function pg_catalog.int4shr(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4shr(integer, integer) is 'implementation of >> operator'; + +create function pg_catalog.int4smaller(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4smaller(integer, integer) is 'smaller of two'; + +create function pg_catalog.int4um(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4um(integer) is 'implementation of - operator'; + +create function pg_catalog.int4up(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4up(integer) is 'implementation of + operator'; + +create function pg_catalog.int4xor(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int4xor(integer, integer) is 'implementation of # operator'; + +create function pg_catalog.int8(bit) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(bit) is 'convert bitstring to int8'; + +create function pg_catalog.int8(double precision) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(double precision) is 'convert float8 to int8'; + +create function pg_catalog.int8(integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(integer) is 'convert int4 to int8'; + +create function pg_catalog.int8(jsonb) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(jsonb) is 'convert jsonb to int8'; + +create function pg_catalog.int8(numeric) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(numeric) is 'convert numeric to int8'; + +create function pg_catalog.int8(oid) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(oid) is 'convert oid to int8'; + +create function pg_catalog.int8(real) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(real) is 'convert float4 to int8'; + +create function pg_catalog.int8(smallint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8(smallint) is 'convert int2 to int8'; + +create function pg_catalog.int82div(bigint, smallint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82div(bigint, smallint) is 'implementation of / operator'; + +create function pg_catalog.int82eq(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82eq(bigint, smallint) is 'implementation of = operator'; + +create function pg_catalog.int82ge(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82ge(bigint, smallint) is 'implementation of >= operator'; + +create function pg_catalog.int82gt(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82gt(bigint, smallint) is 'implementation of > operator'; + +create function pg_catalog.int82le(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82le(bigint, smallint) is 'implementation of <= operator'; + +create function pg_catalog.int82lt(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82lt(bigint, smallint) is 'implementation of < operator'; + +create function pg_catalog.int82mi(bigint, smallint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82mi(bigint, smallint) is 'implementation of - operator'; + +create function pg_catalog.int82mul(bigint, smallint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82mul(bigint, smallint) is 'implementation of * operator'; + +create function pg_catalog.int82ne(bigint, smallint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82ne(bigint, smallint) is 'implementation of <> operator'; + +create function pg_catalog.int82pl(bigint, smallint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int82pl(bigint, smallint) is 'implementation of + operator'; + +create function pg_catalog.int84div(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84div(bigint, integer) is 'implementation of / operator'; + +create function pg_catalog.int84eq(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84eq(bigint, integer) is 'implementation of = operator'; + +create function pg_catalog.int84ge(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84ge(bigint, integer) is 'implementation of >= operator'; + +create function pg_catalog.int84gt(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84gt(bigint, integer) is 'implementation of > operator'; + +create function pg_catalog.int84le(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84le(bigint, integer) is 'implementation of <= operator'; + +create function pg_catalog.int84lt(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84lt(bigint, integer) is 'implementation of < operator'; + +create function pg_catalog.int84mi(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84mi(bigint, integer) is 'implementation of - operator'; + +create function pg_catalog.int84mul(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84mul(bigint, integer) is 'implementation of * operator'; + +create function pg_catalog.int84ne(bigint, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84ne(bigint, integer) is 'implementation of <> operator'; + +create function pg_catalog.int84pl(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int84pl(bigint, integer) is 'implementation of + operator'; + +create function pg_catalog.int8_accum(internal, bigint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_accum(internal, bigint) is 'aggregate transition function'; + +create function pg_catalog.int8_accum_inv(internal, bigint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_accum_inv(internal, bigint) is 'aggregate transition function'; + +create function pg_catalog.int8_avg(bigint[]) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg(bigint[]) is 'aggregate final function'; + +create function pg_catalog.int8_avg_accum(internal, bigint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg_accum(internal, bigint) is 'aggregate transition function'; + +create function pg_catalog.int8_avg_accum_inv(internal, bigint) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg_accum_inv(internal, bigint) is 'aggregate transition function'; + +create function pg_catalog.int8_avg_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.int8_avg_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.int8_avg_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_avg_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.int8_mul_cash(bigint, money) returns money + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_mul_cash(bigint, money) is 'implementation of * operator'; + +create function pg_catalog.int8_sum(numeric, bigint) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8_sum(numeric, bigint) is 'aggregate transition function'; + +create function pg_catalog.int8abs(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8abs(bigint) is 'implementation of @ operator'; + +create function pg_catalog.int8and(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8and(bigint, bigint) is 'implementation of & operator'; + +create function pg_catalog.int8dec(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8dec(bigint) is 'decrement'; + +create function pg_catalog.int8dec_any(bigint, "any") returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8dec_any(bigint, "any") is 'decrement, ignores second argument'; + +create function pg_catalog.int8div(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8div(bigint, bigint) is 'implementation of / operator'; + +create function pg_catalog.int8eq(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8eq(bigint, bigint) is 'implementation of = operator'; + +create function pg_catalog.int8ge(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8ge(bigint, bigint) is 'implementation of >= operator'; + +create function pg_catalog.int8gt(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8gt(bigint, bigint) is 'implementation of > operator'; + +create function pg_catalog.int8in(cstring) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8in(cstring) is 'I/O'; + +create function pg_catalog.int8inc(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8inc(bigint) is 'increment'; + +create function pg_catalog.int8inc_any(bigint, "any") returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8inc_any(bigint, "any") is 'increment, ignores second argument'; + +create function pg_catalog.int8inc_float8_float8(bigint, double precision, double precision) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8inc_float8_float8(bigint, double precision, double precision) is 'aggregate transition function'; + +create function pg_catalog.int8inc_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8inc_support(internal) is 'planner support for count run condition'; + +create function pg_catalog.int8larger(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8larger(bigint, bigint) is 'larger of two'; + +create function pg_catalog.int8le(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8le(bigint, bigint) is 'implementation of <= operator'; + +create function pg_catalog.int8lt(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8lt(bigint, bigint) is 'implementation of < operator'; + +create function pg_catalog.int8mi(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8mi(bigint, bigint) is 'implementation of - operator'; + +create function pg_catalog.int8mod(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8mod(bigint, bigint) is 'implementation of % operator'; + +create function pg_catalog.int8mul(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8mul(bigint, bigint) is 'implementation of * operator'; + +create function pg_catalog.int8multirange() returns int8multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8multirange() is 'int8multirange constructor'; + +create function pg_catalog.int8multirange(int8range) returns int8multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8multirange(int8range) is 'int8multirange constructor'; + +create function pg_catalog.int8multirange(int8range[]) returns int8multirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8multirange(int8range[]) is 'int8multirange constructor'; + +create function pg_catalog.int8ne(bigint, bigint) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8ne(bigint, bigint) is 'implementation of <> operator'; + +create function pg_catalog.int8not(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8not(bigint) is 'implementation of ~ operator'; + +create function pg_catalog.int8or(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8or(bigint, bigint) is 'implementation of | operator'; + +create function pg_catalog.int8out(bigint) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8out(bigint) is 'I/O'; + +create function pg_catalog.int8pl(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8pl(bigint, bigint) is 'implementation of + operator'; + +create function pg_catalog.int8pl_inet(bigint, inet) returns inet + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8pl_inet(bigint, inet) is 'implementation of + operator'; + +create function pg_catalog.int8range(bigint, bigint) returns int8range + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8range(bigint, bigint) is 'int8range constructor'; + +create function pg_catalog.int8range(bigint, bigint, text) returns int8range + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8range(bigint, bigint, text) is 'int8range constructor'; + +create function pg_catalog.int8range_canonical(int8range) returns int8range + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8range_canonical(int8range) is 'convert an int8 range to canonical form'; + +create function pg_catalog.int8range_subdiff(bigint, bigint) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8range_subdiff(bigint, bigint) is 'float8 difference of two int8 values'; + +create function pg_catalog.int8recv(internal) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8recv(internal) is 'I/O'; + +create function pg_catalog.int8send(bigint) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8send(bigint) is 'I/O'; + +create function pg_catalog.int8shl(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8shl(bigint, integer) is 'implementation of << operator'; + +create function pg_catalog.int8shr(bigint, integer) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8shr(bigint, integer) is 'implementation of >> operator'; + +create function pg_catalog.int8smaller(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8smaller(bigint, bigint) is 'smaller of two'; + +create function pg_catalog.int8um(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8um(bigint) is 'implementation of - operator'; + +create function pg_catalog.int8up(bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8up(bigint) is 'implementation of + operator'; + +create function pg_catalog.int8xor(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.int8xor(bigint, bigint) is 'implementation of # operator'; + +create function pg_catalog.integer_pl_date(integer, date) returns date + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.integer_pl_date(integer, date) is 'implementation of + operator'; + +create function pg_catalog.inter_lb(line, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inter_lb(line, box) is 'implementation of ?# operator'; + +create function pg_catalog.inter_sb(lseg, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inter_sb(lseg, box) is 'implementation of ?# operator'; + +create function pg_catalog.inter_sl(lseg, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.inter_sl(lseg, line) is 'implementation of ?# operator'; + +create function pg_catalog.internal_in(cstring) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.internal_in(cstring) is 'I/O'; + +create function pg_catalog.internal_out(internal) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.internal_out(internal) is 'I/O'; + +create function pg_catalog.interval(interval, integer) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval(interval, integer) is 'adjust interval precision'; + +create function pg_catalog.interval(time) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval(time) is 'convert time to interval'; + +create function pg_catalog.interval_accum(interval[], interval) returns interval[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_accum(interval[], interval) is 'aggregate transition function'; + +create function pg_catalog.interval_accum_inv(interval[], interval) returns interval[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_accum_inv(interval[], interval) is 'aggregate transition function'; + +create function pg_catalog.interval_avg(interval[]) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_avg(interval[]) is 'aggregate final function'; + +create function pg_catalog.interval_cmp(interval, interval) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_cmp(interval, interval) is 'less-equal-greater'; + +create function pg_catalog.interval_combine(interval[], interval[]) returns interval[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_combine(interval[], interval[]) is 'aggregate combine function'; + +create function pg_catalog.interval_div(interval, double precision) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_div(interval, double precision) is 'implementation of / operator'; + +create function pg_catalog.interval_eq(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_eq(interval, interval) is 'implementation of = operator'; + +create function pg_catalog.interval_ge(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_ge(interval, interval) is 'implementation of >= operator'; + +create function pg_catalog.interval_gt(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_gt(interval, interval) is 'implementation of > operator'; + +create function pg_catalog.interval_hash(interval) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_hash(interval) is 'hash'; + +create function pg_catalog.interval_hash_extended(interval, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_hash_extended(interval, bigint) is 'hash'; + +create function pg_catalog.interval_in(cstring, oid, integer) returns interval + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.interval_larger(interval, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_larger(interval, interval) is 'larger of two'; + +create function pg_catalog.interval_le(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_le(interval, interval) is 'implementation of <= operator'; + +create function pg_catalog.interval_lt(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_lt(interval, interval) is 'implementation of < operator'; + +create function pg_catalog.interval_mi(interval, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_mi(interval, interval) is 'implementation of - operator'; + +create function pg_catalog.interval_mul(interval, double precision) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_mul(interval, double precision) is 'implementation of * operator'; + +create function pg_catalog.interval_ne(interval, interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_ne(interval, interval) is 'implementation of <> operator'; + +create function pg_catalog.interval_out(interval) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_out(interval) is 'I/O'; + +create function pg_catalog.interval_pl(interval, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl(interval, interval) is 'implementation of + operator'; + +create function pg_catalog.interval_pl_date(interval, date) returns timestamp + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl_date(interval, date) is 'implementation of + operator'; + +create function pg_catalog.interval_pl_time(interval, time) returns time + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl_time(interval, time) is 'implementation of + operator'; + +create function pg_catalog.interval_pl_timestamp(interval, timestamp) returns timestamp + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl_timestamp(interval, timestamp) is 'implementation of + operator'; + +create function pg_catalog.interval_pl_timestamptz(interval, timestamp with time zone) returns timestamp with time zone + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl_timestamptz(interval, timestamp with time zone) is 'implementation of + operator'; + +create function pg_catalog.interval_pl_timetz(interval, time with time zone) returns time with time zone + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_pl_timetz(interval, time with time zone) is 'implementation of + operator'; + +create function pg_catalog.interval_recv(internal, oid, integer) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.interval_send(interval) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_send(interval) is 'I/O'; + +create function pg_catalog.interval_smaller(interval, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_smaller(interval, interval) is 'smaller of two'; + +create function pg_catalog.interval_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_support(internal) is 'planner support for interval length coercion'; + +create function pg_catalog.interval_um(interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.interval_um(interval) is 'implementation of - operator'; + +create function pg_catalog.intervaltypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.intervaltypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.intervaltypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.intervaltypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.is_normalized(text, text default 'NFC'::text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.is_normalized(text, text) is 'check Unicode normalization'; + +create function pg_catalog.isclosed(path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isclosed(path) is 'path closed?'; + +create function pg_catalog.isempty(anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isempty(anymultirange) is 'is the multirange empty?'; + +create function pg_catalog.isempty(anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isempty(anyrange) is 'is the range empty?'; + +create function pg_catalog.isfinite(date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isfinite(date) is 'finite date?'; + +create function pg_catalog.isfinite(interval) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isfinite(interval) is 'finite interval?'; + +create function pg_catalog.isfinite(timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isfinite(timestamp with time zone) is 'finite timestamp?'; + +create function pg_catalog.isfinite(timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isfinite(timestamp) is 'finite timestamp?'; + +create function pg_catalog.ishorizontal(line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ishorizontal(line) is 'horizontal'; + +create function pg_catalog.ishorizontal(lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ishorizontal(lseg) is 'horizontal'; + +create function pg_catalog.ishorizontal(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ishorizontal(point, point) is 'horizontally aligned'; + +create function pg_catalog.iso8859_1_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso8859_1_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN1 to UTF8'; + +create function pg_catalog.iso8859_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso8859_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for ISO-8859 2-16 to UTF8'; + +create function pg_catalog.iso_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso_to_koi8r(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for ISO-8859-5 to KOI8R'; + +create function pg_catalog.iso_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for ISO-8859-5 to MULE_INTERNAL'; + +create function pg_catalog.iso_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso_to_win1251(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for ISO-8859-5 to WIN1251'; + +create function pg_catalog.iso_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.iso_to_win866(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for ISO-8859-5 to WIN866'; + +create function pg_catalog.isopen(path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isopen(path) is 'path open?'; + +create function pg_catalog.isparallel(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isparallel(line, line) is 'parallel'; + +create function pg_catalog.isparallel(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isparallel(lseg, lseg) is 'parallel'; + +create function pg_catalog.isperp(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isperp(line, line) is 'perpendicular'; + +create function pg_catalog.isperp(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isperp(lseg, lseg) is 'perpendicular'; + +create function pg_catalog.isvertical(line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isvertical(line) is 'vertical'; + +create function pg_catalog.isvertical(lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isvertical(lseg) is 'vertical'; + +create function pg_catalog.isvertical(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.isvertical(point, point) is 'vertically aligned'; + +create function pg_catalog.johab_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.johab_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for JOHAB to UTF8'; + +create function pg_catalog.json_agg_finalfn(internal) returns json + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_agg_finalfn(internal) is 'json aggregate final function'; + +create function pg_catalog.json_agg_strict_transfn(internal, anyelement) returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_agg_strict_transfn(internal, anyelement) is 'json aggregate transition function'; + +create function pg_catalog.json_agg_transfn(internal, anyelement) returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_agg_transfn(internal, anyelement) is 'json aggregate transition function'; + +create function pg_catalog.json_array_element(from_json json, element_index integer) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_array_element(json, integer) is 'implementation of -> operator'; + +create function pg_catalog.json_array_element_text(from_json json, element_index integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_array_element_text(json, integer) is 'implementation of ->> operator'; + +create function pg_catalog.json_array_elements(from_json json, out value json) returns setof json + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_array_elements(json, out json) is 'key value pairs of a json object'; + +create function pg_catalog.json_array_elements_text(from_json json, out value text) returns setof text + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_array_elements_text(json, out text) is 'elements of json array'; + +create function pg_catalog.json_array_length(json) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_array_length(json) is 'length of json array'; + +create function pg_catalog.json_build_array("any") returns json + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_build_array("any") is 'build a json array from any inputs'; + +create function pg_catalog.json_build_array() returns json + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_build_array() is 'build an empty json array'; + +create function pg_catalog.json_build_object("any") returns json + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_build_object("any") is 'build a json object from pairwise key/value inputs'; + +create function pg_catalog.json_build_object() returns json + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_build_object() is 'build an empty json object'; + +create function pg_catalog.json_each(from_json json, out key text, out value json) returns setof record + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_each(json, out text, out json) is 'key value pairs of a json object'; + +create function pg_catalog.json_each_text(from_json json, out key text, out value text) returns setof record + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_each_text(json, out text, out text) is 'key value pairs of a json object'; + +create function pg_catalog.json_extract_path(from_json json, path_elems text[]) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_extract_path(json, text[]) is 'get value from json with path elements'; + +create function pg_catalog.json_extract_path_text(from_json json, path_elems text[]) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_extract_path_text(json, text[]) is 'get value from json as text with path elements'; + +create function pg_catalog.json_in(cstring) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_in(cstring) is 'I/O'; + +create function pg_catalog.json_object(text[]) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object(text[]) is 'map text array of key value pairs to json object'; + +create function pg_catalog.json_object(text[], text[]) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object(text[], text[]) is 'map text arrays of keys and values to json object'; + +create function pg_catalog.json_object_agg_finalfn(internal) returns json + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_agg_finalfn(internal) is 'json object aggregate final function'; + +create function pg_catalog.json_object_agg_strict_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_agg_strict_transfn(internal, "any", "any") is 'json object aggregate transition function'; + +create function pg_catalog.json_object_agg_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_agg_transfn(internal, "any", "any") is 'json object aggregate transition function'; + +create function pg_catalog.json_object_agg_unique_strict_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_agg_unique_strict_transfn(internal, "any", "any") is 'json object aggregate transition function'; + +create function pg_catalog.json_object_agg_unique_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_agg_unique_transfn(internal, "any", "any") is 'json object aggregate transition function'; + +create function pg_catalog.json_object_field(from_json json, field_name text) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_field(json, text) is 'implementation of -> operator'; + +create function pg_catalog.json_object_field_text(from_json json, field_name text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_field_text(json, text) is 'implementation of ->> operator'; + +create function pg_catalog.json_object_keys(json) returns setof text + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_object_keys(json) is 'get json object keys'; + +create function pg_catalog.json_out(json) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_out(json) is 'I/O'; + +create function pg_catalog.json_populate_record(base anyelement, from_json json, use_json_as_text boolean default false) returns anyelement + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_populate_record(anyelement, json, boolean) is 'get record fields from a json object'; + +create function pg_catalog.json_populate_recordset(base anyelement, from_json json, use_json_as_text boolean default false) returns setof anyelement + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_populate_recordset(anyelement, json, boolean) is 'get set of records with fields from a json array of objects'; + +create function pg_catalog.json_recv(internal) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_recv(internal) is 'I/O'; + +create function pg_catalog.json_send(json) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_send(json) is 'I/O'; + +create function pg_catalog.json_strip_nulls(json) returns json + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_strip_nulls(json) is 'remove object fields with null values from json'; + +create function pg_catalog.json_to_record(json) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_to_record(json) is 'get record fields from a json object'; + +create function pg_catalog.json_to_recordset(json) returns setof record + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_to_recordset(json) is 'get set of records with fields from a json array of objects'; + +create function pg_catalog.json_to_tsvector(json, jsonb) returns tsvector + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_to_tsvector(json, jsonb) is 'transform specified values from json to tsvector'; + +create function pg_catalog.json_to_tsvector(regconfig, json, jsonb) returns tsvector + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_to_tsvector(regconfig, json, jsonb) is 'transform specified values from json to tsvector'; + +create function pg_catalog.json_typeof(json) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.json_typeof(json) is 'get the type of a json value'; + +create function pg_catalog.jsonb_agg_finalfn(internal) returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_agg_finalfn(internal) is 'jsonb aggregate final function'; + +create function pg_catalog.jsonb_agg_strict_transfn(internal, anyelement) returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_agg_strict_transfn(internal, anyelement) is 'jsonb aggregate transition function'; + +create function pg_catalog.jsonb_agg_transfn(internal, anyelement) returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_agg_transfn(internal, anyelement) is 'jsonb aggregate transition function'; + +create function pg_catalog.jsonb_array_element(from_json jsonb, element_index integer) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_array_element(jsonb, integer) is 'implementation of -> operator'; + +create function pg_catalog.jsonb_array_element_text(from_json jsonb, element_index integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_array_element_text(jsonb, integer) is 'implementation of ->> operator'; + +create function pg_catalog.jsonb_array_elements(from_json jsonb, out value jsonb) returns setof jsonb + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_array_elements(jsonb, out jsonb) is 'elements of a jsonb array'; + +create function pg_catalog.jsonb_array_elements_text(from_json jsonb, out value text) returns setof text + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_array_elements_text(jsonb, out text) is 'elements of jsonb array'; + +create function pg_catalog.jsonb_array_length(jsonb) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_array_length(jsonb) is 'length of jsonb array'; + +create function pg_catalog.jsonb_build_array("any") returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_build_array("any") is 'build a jsonb array from any inputs'; + +create function pg_catalog.jsonb_build_array() returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_build_array() is 'build an empty jsonb array'; + +create function pg_catalog.jsonb_build_object("any") returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_build_object("any") is 'build a jsonb object from pairwise key/value inputs'; + +create function pg_catalog.jsonb_build_object() returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_build_object() is 'build an empty jsonb object'; + +create function pg_catalog.jsonb_cmp(jsonb, jsonb) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_cmp(jsonb, jsonb) is 'less-equal-greater'; + +create function pg_catalog.jsonb_concat(jsonb, jsonb) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_concat(jsonb, jsonb) is 'implementation of || operator'; + +create function pg_catalog.jsonb_contained(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_contained(jsonb, jsonb) is 'implementation of <@ operator'; + +create function pg_catalog.jsonb_contains(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_contains(jsonb, jsonb) is 'implementation of @> operator'; + +create function pg_catalog.jsonb_delete(jsonb, integer) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_delete(jsonb, integer) is 'implementation of - operator'; + +create function pg_catalog.jsonb_delete(jsonb, text) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_delete(jsonb, text) is 'implementation of - operator'; + +create function pg_catalog.jsonb_delete(from_json jsonb, path_elems text[]) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_delete(jsonb, text[]) is 'implementation of - operator'; + +create function pg_catalog.jsonb_delete_path(jsonb, text[]) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_delete_path(jsonb, text[]) is 'implementation of #- operator'; + +create function pg_catalog.jsonb_each(from_json jsonb, out key text, out value jsonb) returns setof record + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_each(jsonb, out text, out jsonb) is 'key value pairs of a jsonb object'; + +create function pg_catalog.jsonb_each_text(from_json jsonb, out key text, out value text) returns setof record + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_each_text(jsonb, out text, out text) is 'key value pairs of a jsonb object'; + +create function pg_catalog.jsonb_eq(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_eq(jsonb, jsonb) is 'implementation of = operator'; + +create function pg_catalog.jsonb_exists(jsonb, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_exists(jsonb, text) is 'implementation of ? operator'; + +create function pg_catalog.jsonb_exists_all(jsonb, text[]) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_exists_all(jsonb, text[]) is 'implementation of ?& operator'; + +create function pg_catalog.jsonb_exists_any(jsonb, text[]) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_exists_any(jsonb, text[]) is 'implementation of ?| operator'; + +create function pg_catalog.jsonb_extract_path(from_json jsonb, path_elems text[]) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_extract_path(jsonb, text[]) is 'get value from jsonb with path elements'; + +create function pg_catalog.jsonb_extract_path_text(from_json jsonb, path_elems text[]) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_extract_path_text(jsonb, text[]) is 'get value from jsonb as text with path elements'; + +create function pg_catalog.jsonb_ge(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_ge(jsonb, jsonb) is 'implementation of >= operator'; + +create function pg_catalog.jsonb_gt(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_gt(jsonb, jsonb) is 'implementation of > operator'; + +create function pg_catalog.jsonb_hash(jsonb) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_hash(jsonb) is 'hash'; + +create function pg_catalog.jsonb_hash_extended(jsonb, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_hash_extended(jsonb, bigint) is 'hash'; + +create function pg_catalog.jsonb_in(cstring) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_in(cstring) is 'I/O'; + +create function pg_catalog.jsonb_insert(jsonb_in jsonb, path text[], replacement jsonb, insert_after boolean default false) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_insert(jsonb, text[], jsonb, boolean) is 'Insert value into a jsonb'; + +create function pg_catalog.jsonb_le(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_le(jsonb, jsonb) is 'implementation of <= operator'; + +create function pg_catalog.jsonb_lt(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_lt(jsonb, jsonb) is 'implementation of < operator'; + +create function pg_catalog.jsonb_ne(jsonb, jsonb) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_ne(jsonb, jsonb) is 'implementation of <> operator'; + +create function pg_catalog.jsonb_object(text[]) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object(text[]) is 'map text array of key value pairs to jsonb object'; + +create function pg_catalog.jsonb_object(text[], text[]) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object(text[], text[]) is 'map text array of key value pairs to jsonb object'; + +create function pg_catalog.jsonb_object_agg_finalfn(internal) returns jsonb + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_agg_finalfn(internal) is 'jsonb object aggregate final function'; + +create function pg_catalog.jsonb_object_agg_strict_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_agg_strict_transfn(internal, "any", "any") is 'jsonb object aggregate transition function'; + +create function pg_catalog.jsonb_object_agg_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_agg_transfn(internal, "any", "any") is 'jsonb object aggregate transition function'; + +create function pg_catalog.jsonb_object_agg_unique_strict_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_agg_unique_strict_transfn(internal, "any", "any") is 'jsonb object aggregate transition function'; + +create function pg_catalog.jsonb_object_agg_unique_transfn(internal, "any", "any") returns internal + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_agg_unique_transfn(internal, "any", "any") is 'jsonb object aggregate transition function'; + +create function pg_catalog.jsonb_object_field(from_json jsonb, field_name text) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_field(jsonb, text) is 'implementation of -> operator'; + +create function pg_catalog.jsonb_object_field_text(from_json jsonb, field_name text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_field_text(jsonb, text) is 'implementation of ->> operator'; + +create function pg_catalog.jsonb_object_keys(jsonb) returns setof text + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_object_keys(jsonb) is 'get jsonb object keys'; + +create function pg_catalog.jsonb_out(jsonb) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_out(jsonb) is 'I/O'; + +create function pg_catalog.jsonb_path_exists(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_exists(jsonb, jsonpath, jsonb, boolean) is 'jsonpath exists test'; + +create function pg_catalog.jsonb_path_exists_opr(jsonb, jsonpath) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_exists_opr(jsonb, jsonpath) is 'implementation of @? operator'; + +create function pg_catalog.jsonb_path_exists_tz(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_exists_tz(jsonb, jsonpath, jsonb, boolean) is 'jsonpath exists test with timezone'; + +create function pg_catalog.jsonb_path_match(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_match(jsonb, jsonpath, jsonb, boolean) is 'jsonpath match'; + +create function pg_catalog.jsonb_path_match_opr(jsonb, jsonpath) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_match_opr(jsonb, jsonpath) is 'implementation of @@ operator'; + +create function pg_catalog.jsonb_path_match_tz(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_match_tz(jsonb, jsonpath, jsonb, boolean) is 'jsonpath match with timezone'; + +create function pg_catalog.jsonb_path_query(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns setof jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query'; + +create function pg_catalog.jsonb_path_query_array(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query_array(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query wrapped into array'; + +create function pg_catalog.jsonb_path_query_array_tz(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns jsonb + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query_array_tz(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query wrapped into array with timezone'; + +create function pg_catalog.jsonb_path_query_first(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query_first(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query first item'; + +create function pg_catalog.jsonb_path_query_first_tz(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns jsonb + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query_first_tz(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query first item with timezone'; + +create function pg_catalog.jsonb_path_query_tz(target jsonb, path jsonpath, vars jsonb default '{}'::jsonb, silent boolean default false) returns setof jsonb + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_path_query_tz(jsonb, jsonpath, jsonb, boolean) is 'jsonpath query with timezone'; + +create function pg_catalog.jsonb_populate_record(anyelement, jsonb) returns anyelement + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_populate_record(anyelement, jsonb) is 'get record fields from a jsonb object'; + +create function pg_catalog.jsonb_populate_recordset(anyelement, jsonb) returns setof anyelement + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_populate_recordset(anyelement, jsonb) is 'get set of records with fields from a jsonb array of objects'; + +create function pg_catalog.jsonb_pretty(jsonb) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_pretty(jsonb) is 'Indented text from jsonb'; + +create function pg_catalog.jsonb_recv(internal) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_recv(internal) is 'I/O'; + +create function pg_catalog.jsonb_send(jsonb) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_send(jsonb) is 'I/O'; + +create function pg_catalog.jsonb_set(jsonb_in jsonb, path text[], replacement jsonb, create_if_missing boolean default true) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_set(jsonb, text[], jsonb, boolean) is 'Set part of a jsonb'; + +create function pg_catalog.jsonb_set_lax(jsonb_in jsonb, path text[], replacement jsonb, create_if_missing boolean default true, null_value_treatment text default 'use_json_null'::text) returns jsonb + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_set_lax(jsonb, text[], jsonb, boolean, text) is 'Set part of a jsonb, handle NULL value'; + +create function pg_catalog.jsonb_strip_nulls(jsonb) returns jsonb + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_strip_nulls(jsonb) is 'remove object fields with null values from jsonb'; + +create function pg_catalog.jsonb_subscript_handler(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_subscript_handler(internal) is 'jsonb subscripting logic'; + +create function pg_catalog.jsonb_to_record(jsonb) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_to_record(jsonb) is 'get record fields from a jsonb object'; + +create function pg_catalog.jsonb_to_recordset(jsonb) returns setof record + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_to_recordset(jsonb) is 'get set of records with fields from a jsonb array of objects'; + +create function pg_catalog.jsonb_to_tsvector(jsonb, jsonb) returns tsvector + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_to_tsvector(jsonb, jsonb) is 'transform specified values from jsonb to tsvector'; + +create function pg_catalog.jsonb_to_tsvector(regconfig, jsonb, jsonb) returns tsvector + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_to_tsvector(regconfig, jsonb, jsonb) is 'transform specified values from jsonb to tsvector'; + +create function pg_catalog.jsonb_typeof(jsonb) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonb_typeof(jsonb) is 'get the type of a jsonb value'; + +create function pg_catalog.jsonpath_in(cstring) returns jsonpath + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonpath_in(cstring) is 'I/O'; + +create function pg_catalog.jsonpath_out(jsonpath) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonpath_out(jsonpath) is 'I/O'; + +create function pg_catalog.jsonpath_recv(internal) returns jsonpath + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonpath_recv(internal) is 'I/O'; + +create function pg_catalog.jsonpath_send(jsonpath) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.jsonpath_send(jsonpath) is 'I/O'; + +create function pg_catalog.justify_days(interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.justify_days(interval) is 'promote groups of 30 days to numbers of months'; + +create function pg_catalog.justify_hours(interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.justify_hours(interval) is 'promote groups of 24 hours to numbers of days'; + +create function pg_catalog.justify_interval(interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.justify_interval(interval) is 'promote groups of 24 hours to numbers of days and promote groups of 30 days to numbers of months'; + +create function pg_catalog.koi8r_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8r_to_iso(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8R to ISO-8859-5'; + +create function pg_catalog.koi8r_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8r_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8R to MULE_INTERNAL'; + +create function pg_catalog.koi8r_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8r_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8R to UTF8'; + +create function pg_catalog.koi8r_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8r_to_win1251(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8R to WIN1251'; + +create function pg_catalog.koi8r_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8r_to_win866(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8R to WIN866'; + +create function pg_catalog.koi8u_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.koi8u_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for KOI8U to UTF8'; + +create function pg_catalog.lag(anycompatible, integer, anycompatible) returns anycompatible + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lag(anycompatible, integer, anycompatible) is 'fetch the Nth preceding row value with default'; + +create function pg_catalog.lag(anyelement) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lag(anyelement) is 'fetch the preceding row value'; + +create function pg_catalog.lag(anyelement, integer) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lag(anyelement, integer) is 'fetch the Nth preceding row value'; + +create function pg_catalog.language_handler_in(cstring) returns language_handler + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.language_handler_in(cstring) is 'I/O'; + +create function pg_catalog.language_handler_out(language_handler) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.language_handler_out(language_handler) is 'I/O'; + +create function pg_catalog.last_value(anyelement) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.last_value(anyelement) is 'fetch the last row value'; + +create function pg_catalog.lastval() returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lastval() is 'current value from last used sequence'; + +create function pg_catalog.latin1_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.latin1_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN1 to MULE_INTERNAL'; + +create function pg_catalog.latin2_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.latin2_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN2 to MULE_INTERNAL'; + +create function pg_catalog.latin2_to_win1250(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.latin2_to_win1250(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN2 to WIN1250'; + +create function pg_catalog.latin3_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.latin3_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN3 to MULE_INTERNAL'; + +create function pg_catalog.latin4_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.latin4_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for LATIN4 to MULE_INTERNAL'; + +create function pg_catalog.lcm(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lcm(bigint, bigint) is 'least common multiple'; + +create function pg_catalog.lcm(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lcm(integer, integer) is 'least common multiple'; + +create function pg_catalog.lcm(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lcm(numeric, numeric) is 'least common multiple'; + +create function pg_catalog.lead(anycompatible, integer, anycompatible) returns anycompatible + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lead(anycompatible, integer, anycompatible) is 'fetch the Nth following row value with default'; + +create function pg_catalog.lead(anyelement) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lead(anyelement) is 'fetch the following row value'; + +create function pg_catalog.lead(anyelement, integer) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lead(anyelement, integer) is 'fetch the Nth following row value'; + +create function pg_catalog."left"(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."left"(text, integer) is 'extract the first n characters'; + +create function pg_catalog.length(bit) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(bit) is 'bitstring length'; + +create function pg_catalog.length(bytea) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(bytea) is 'octet length'; + +create function pg_catalog.length(bytea, name) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(bytea, name) is 'length of string in specified encoding'; + +create function pg_catalog.length(char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(char) is 'character length'; + +create function pg_catalog.length(lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(lseg) is 'distance between endpoints'; + +create function pg_catalog.length(path) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(path) is 'sum of path segments'; + +create function pg_catalog.length(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(text) is 'length'; + +create function pg_catalog.length(tsvector) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.length(tsvector) is 'number of lexemes'; + +create function pg_catalog."like"(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."like"(bytea, bytea) is 'matches LIKE expression'; + +create function pg_catalog."like"(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."like"(name, text) is 'matches LIKE expression'; + +create function pg_catalog."like"(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."like"(text, text) is 'matches LIKE expression'; + +create function pg_catalog.like_escape(bytea, bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.like_escape(bytea, bytea) is 'convert LIKE pattern to use backslash escapes'; + +create function pg_catalog.like_escape(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.like_escape(text, text) is 'convert LIKE pattern to use backslash escapes'; + +create function pg_catalog.likejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.likejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of LIKE'; + +create function pg_catalog.likesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.likesel(internal, oid, internal, integer) is 'restriction selectivity of LIKE'; + +create function pg_catalog.line(point, point) returns line + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line(point, point) is 'construct line from points'; + +create function pg_catalog.line_distance(line, line) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_distance(line, line) is 'implementation of <-> operator'; + +create function pg_catalog.line_eq(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_eq(line, line) is 'implementation of = operator'; + +create function pg_catalog.line_horizontal(line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_horizontal(line) is 'implementation of ?- operator'; + +create function pg_catalog.line_in(cstring) returns line + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_in(cstring) is 'I/O'; + +create function pg_catalog.line_interpt(line, line) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_interpt(line, line) is 'implementation of # operator'; + +create function pg_catalog.line_intersect(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_intersect(line, line) is 'implementation of ?# operator'; + +create function pg_catalog.line_out(line) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_out(line) is 'I/O'; + +create function pg_catalog.line_parallel(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_parallel(line, line) is 'implementation of ?|| operator'; + +create function pg_catalog.line_perp(line, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_perp(line, line) is 'implementation of ?-| operator'; + +create function pg_catalog.line_recv(internal) returns line + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_recv(internal) is 'I/O'; + +create function pg_catalog.line_send(line) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_send(line) is 'I/O'; + +create function pg_catalog.line_vertical(line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.line_vertical(line) is 'implementation of ?| operator'; + +create function pg_catalog.ln(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ln(double precision) is 'natural logarithm'; + +create function pg_catalog.ln(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ln(numeric) is 'natural logarithm'; + +create function pg_catalog.lo_close(integer) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_close(integer) is 'large object close'; + +create function pg_catalog.lo_creat(integer) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_creat(integer) is 'large object create'; + +create function pg_catalog.lo_create(oid) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_create(oid) is 'large object create'; + +create function pg_catalog.lo_export(oid, text) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_export(oid, text) is 'large object export'; + +create function pg_catalog.lo_from_bytea(oid, bytea) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_from_bytea(oid, bytea) is 'create new large object with given content'; + +create function pg_catalog.lo_get(oid) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_get(oid) is 'read entire large object'; + +create function pg_catalog.lo_get(oid, bigint, integer) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_get(oid, bigint, integer) is 'read large object from offset for length'; + +create function pg_catalog.lo_import(text) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_import(text) is 'large object import'; + +create function pg_catalog.lo_import(text, oid) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_import(text, oid) is 'large object import'; + +create function pg_catalog.lo_lseek(integer, integer, integer) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_lseek(integer, integer, integer) is 'large object seek'; + +create function pg_catalog.lo_lseek64(integer, bigint, integer) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_lseek64(integer, bigint, integer) is 'large object seek (64 bit)'; + +create function pg_catalog.lo_open(oid, integer) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_open(oid, integer) is 'large object open'; + +create function pg_catalog.lo_put(oid, bigint, bytea) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_put(oid, bigint, bytea) is 'write data at offset'; + +create function pg_catalog.lo_tell(integer) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_tell(integer) is 'large object position'; + +create function pg_catalog.lo_tell64(integer) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_tell64(integer) is 'large object position (64 bit)'; + +create function pg_catalog.lo_truncate(integer, integer) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_truncate(integer, integer) is 'truncate large object'; + +create function pg_catalog.lo_truncate64(integer, bigint) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_truncate64(integer, bigint) is 'truncate large object (64 bit)'; + +create function pg_catalog.lo_unlink(oid) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lo_unlink(oid) is 'large object unlink (delete)'; + +create function pg_catalog.log(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.log(double precision) is 'base 10 logarithm'; + +create function pg_catalog.log(numeric) returns numeric + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.log(numeric) is 'base 10 logarithm'; + +create function pg_catalog.log(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.log(numeric, numeric) is 'logarithm base m of n'; + +create function pg_catalog.log10(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.log10(double precision) is 'base 10 logarithm'; + +create function pg_catalog.log10(numeric) returns numeric + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.log10(numeric) is 'base 10 logarithm'; + +create function pg_catalog.loread(integer, integer) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.loread(integer, integer) is 'large object read'; + +create function pg_catalog.lower(anymultirange) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower(anymultirange) is 'lower bound of multirange'; + +create function pg_catalog.lower(anyrange) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower(anyrange) is 'lower bound of range'; + +create function pg_catalog.lower(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower(text) is 'lowercase'; + +create function pg_catalog.lower_inc(anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower_inc(anymultirange) is 'is the multirange''s lower bound inclusive?'; + +create function pg_catalog.lower_inc(anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower_inc(anyrange) is 'is the range''s lower bound inclusive?'; + +create function pg_catalog.lower_inf(anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower_inf(anymultirange) is 'is the multirange''s lower bound infinite?'; + +create function pg_catalog.lower_inf(anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lower_inf(anyrange) is 'is the range''s lower bound infinite?'; + +create function pg_catalog.lowrite(integer, bytea) returns integer + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lowrite(integer, bytea) is 'large object write'; + +create function pg_catalog.lpad(text, integer) returns text + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lpad(text, integer) is 'left-pad string to length'; + +create function pg_catalog.lpad(text, integer, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lpad(text, integer, text) is 'left-pad string to length'; + +create function pg_catalog.lseg(box) returns lseg + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg(box) is 'diagonal of'; + +create function pg_catalog.lseg(point, point) returns lseg + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg(point, point) is 'convert points to line segment'; + +create function pg_catalog.lseg_center(lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_center(lseg) is 'implementation of @@ operator'; + +create function pg_catalog.lseg_distance(lseg, lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_distance(lseg, lseg) is 'implementation of <-> operator'; + +create function pg_catalog.lseg_eq(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_eq(lseg, lseg) is 'implementation of = operator'; + +create function pg_catalog.lseg_ge(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_ge(lseg, lseg) is 'implementation of >= operator'; + +create function pg_catalog.lseg_gt(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_gt(lseg, lseg) is 'implementation of > operator'; + +create function pg_catalog.lseg_horizontal(lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_horizontal(lseg) is 'implementation of ?- operator'; + +create function pg_catalog.lseg_in(cstring) returns lseg + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_in(cstring) is 'I/O'; + +create function pg_catalog.lseg_interpt(lseg, lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_interpt(lseg, lseg) is 'implementation of # operator'; + +create function pg_catalog.lseg_intersect(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_intersect(lseg, lseg) is 'implementation of ?# operator'; + +create function pg_catalog.lseg_le(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_le(lseg, lseg) is 'implementation of <= operator'; + +create function pg_catalog.lseg_length(lseg) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_length(lseg) is 'implementation of @-@ operator'; + +create function pg_catalog.lseg_lt(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_lt(lseg, lseg) is 'implementation of < operator'; + +create function pg_catalog.lseg_ne(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_ne(lseg, lseg) is 'implementation of <> operator'; + +create function pg_catalog.lseg_out(lseg) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_out(lseg) is 'I/O'; + +create function pg_catalog.lseg_parallel(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_parallel(lseg, lseg) is 'implementation of ?|| operator'; + +create function pg_catalog.lseg_perp(lseg, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_perp(lseg, lseg) is 'implementation of ?-| operator'; + +create function pg_catalog.lseg_recv(internal) returns lseg + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_recv(internal) is 'I/O'; + +create function pg_catalog.lseg_send(lseg) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_send(lseg) is 'I/O'; + +create function pg_catalog.lseg_vertical(lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.lseg_vertical(lseg) is 'implementation of ?| operator'; + +create function pg_catalog.ltrim(bytea, bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ltrim(bytea, bytea) is 'trim selected bytes from left end of string'; + +create function pg_catalog.ltrim(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ltrim(text) is 'trim spaces from left end of string'; + +create function pg_catalog.ltrim(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ltrim(text, text) is 'trim selected characters from left end of string'; + +create function pg_catalog.macaddr(macaddr8) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr(macaddr8) is 'convert macaddr8 to macaddr'; + +create function pg_catalog.macaddr8(macaddr) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8(macaddr) is 'convert macaddr to macaddr8'; + +create function pg_catalog.macaddr8_and(macaddr8, macaddr8) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_and(macaddr8, macaddr8) is 'implementation of & operator'; + +create function pg_catalog.macaddr8_cmp(macaddr8, macaddr8) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_cmp(macaddr8, macaddr8) is 'less-equal-greater'; + +create function pg_catalog.macaddr8_eq(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_eq(macaddr8, macaddr8) is 'implementation of = operator'; + +create function pg_catalog.macaddr8_ge(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_ge(macaddr8, macaddr8) is 'implementation of >= operator'; + +create function pg_catalog.macaddr8_gt(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_gt(macaddr8, macaddr8) is 'implementation of > operator'; + +create function pg_catalog.macaddr8_in(cstring) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_in(cstring) is 'I/O'; + +create function pg_catalog.macaddr8_le(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_le(macaddr8, macaddr8) is 'implementation of <= operator'; + +create function pg_catalog.macaddr8_lt(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_lt(macaddr8, macaddr8) is 'implementation of < operator'; + +create function pg_catalog.macaddr8_ne(macaddr8, macaddr8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_ne(macaddr8, macaddr8) is 'implementation of <> operator'; + +create function pg_catalog.macaddr8_not(macaddr8) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_not(macaddr8) is 'implementation of ~ operator'; + +create function pg_catalog.macaddr8_or(macaddr8, macaddr8) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_or(macaddr8, macaddr8) is 'implementation of | operator'; + +create function pg_catalog.macaddr8_out(macaddr8) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_out(macaddr8) is 'I/O'; + +create function pg_catalog.macaddr8_recv(internal) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_recv(internal) is 'I/O'; + +create function pg_catalog.macaddr8_send(macaddr8) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_send(macaddr8) is 'I/O'; + +create function pg_catalog.macaddr8_set7bit(macaddr8) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr8_set7bit(macaddr8) is 'set 7th bit in macaddr8'; + +create function pg_catalog.macaddr_and(macaddr, macaddr) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_and(macaddr, macaddr) is 'implementation of & operator'; + +create function pg_catalog.macaddr_cmp(macaddr, macaddr) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_cmp(macaddr, macaddr) is 'less-equal-greater'; + +create function pg_catalog.macaddr_eq(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_eq(macaddr, macaddr) is 'implementation of = operator'; + +create function pg_catalog.macaddr_ge(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_ge(macaddr, macaddr) is 'implementation of >= operator'; + +create function pg_catalog.macaddr_gt(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_gt(macaddr, macaddr) is 'implementation of > operator'; + +create function pg_catalog.macaddr_in(cstring) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_in(cstring) is 'I/O'; + +create function pg_catalog.macaddr_le(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_le(macaddr, macaddr) is 'implementation of <= operator'; + +create function pg_catalog.macaddr_lt(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_lt(macaddr, macaddr) is 'implementation of < operator'; + +create function pg_catalog.macaddr_ne(macaddr, macaddr) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_ne(macaddr, macaddr) is 'implementation of <> operator'; + +create function pg_catalog.macaddr_not(macaddr) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_not(macaddr) is 'implementation of ~ operator'; + +create function pg_catalog.macaddr_or(macaddr, macaddr) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_or(macaddr, macaddr) is 'implementation of | operator'; + +create function pg_catalog.macaddr_out(macaddr) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_out(macaddr) is 'I/O'; + +create function pg_catalog.macaddr_recv(internal) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_recv(internal) is 'I/O'; + +create function pg_catalog.macaddr_send(macaddr) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_send(macaddr) is 'I/O'; + +create function pg_catalog.macaddr_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.macaddr_sortsupport(internal) is 'sort support'; + +create function pg_catalog.make_date(year integer, month integer, day integer) returns date + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_date(integer, integer, integer) is 'construct date'; + +create function pg_catalog.make_interval(years integer default 0, months integer default 0, weeks integer default 0, days integer default 0, hours integer default 0, mins integer default 0, secs double precision default 0.0) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_interval(integer, integer, integer, integer, integer, integer, double precision) is 'construct interval'; + +create function pg_catalog.make_time(hour integer, min integer, sec double precision) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_time(integer, integer, double precision) is 'construct time'; + +create function pg_catalog.make_timestamp(year integer, month integer, mday integer, hour integer, min integer, sec double precision) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_timestamp(integer, integer, integer, integer, integer, double precision) is 'construct timestamp'; + +create function pg_catalog.make_timestamptz(year integer, month integer, mday integer, hour integer, min integer, sec double precision) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_timestamptz(integer, integer, integer, integer, integer, double precision) is 'construct timestamp with time zone'; + +create function pg_catalog.make_timestamptz(year integer, month integer, mday integer, hour integer, min integer, sec double precision, timezone text) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.make_timestamptz(integer, integer, integer, integer, integer, double precision, text) is 'construct timestamp with time zone'; + +create function pg_catalog.makeaclitem(oid, oid, text, boolean) returns aclitem + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.makeaclitem(oid, oid, text, boolean) is 'make ACL item'; + +create function pg_catalog.masklen(inet) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.masklen(inet) is 'netmask length'; + +create function pg_catalog.matchingjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.matchingjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for generic matching operators'; + +create function pg_catalog.matchingsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.matchingsel(internal, oid, internal, integer) is 'restriction selectivity for generic matching operators'; + +create function pg_catalog.md5(bytea) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.md5(bytea) is 'MD5 hash'; + +create function pg_catalog.md5(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.md5(text) is 'MD5 hash'; + +create function pg_catalog.mic_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_big5(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to BIG5'; + +create function pg_catalog.mic_to_euc_cn(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_euc_cn(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to EUC_CN'; + +create function pg_catalog.mic_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_euc_jp(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to EUC_JP'; + +create function pg_catalog.mic_to_euc_kr(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_euc_kr(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to EUC_KR'; + +create function pg_catalog.mic_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_euc_tw(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to EUC_TW'; + +create function pg_catalog.mic_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_iso(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to ISO-8859-5'; + +create function pg_catalog.mic_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_koi8r(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to KOI8R'; + +create function pg_catalog.mic_to_latin1(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_latin1(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to LATIN1'; + +create function pg_catalog.mic_to_latin2(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_latin2(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to LATIN2'; + +create function pg_catalog.mic_to_latin3(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_latin3(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to LATIN3'; + +create function pg_catalog.mic_to_latin4(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_latin4(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to LATIN4'; + +create function pg_catalog.mic_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_sjis(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to SJIS'; + +create function pg_catalog.mic_to_win1250(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_win1250(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to WIN1250'; + +create function pg_catalog.mic_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_win1251(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to WIN1251'; + +create function pg_catalog.mic_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mic_to_win866(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for MULE_INTERNAL to WIN866'; + +create function pg_catalog.min_scale(numeric) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.min_scale(numeric) is 'minimum scale needed to represent the value'; + +create function pg_catalog.mod(bigint, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mod(bigint, bigint) is 'modulus'; + +create function pg_catalog.mod(integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mod(integer, integer) is 'modulus'; + +create function pg_catalog.mod(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mod(numeric, numeric) is 'modulus'; + +create function pg_catalog.mod(smallint, smallint) returns smallint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mod(smallint, smallint) is 'modulus'; + +create function pg_catalog.mode_final(internal, anyelement) returns anyelement + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mode_final(internal, anyelement) is 'aggregate final function'; + +create function pg_catalog.money(bigint) returns money + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.money(bigint) is 'convert int8 to money'; + +create function pg_catalog.money(integer) returns money + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.money(integer) is 'convert int4 to money'; + +create function pg_catalog.money(numeric) returns money + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.money(numeric) is 'convert numeric to money'; + +create function pg_catalog.mul_d_interval(double precision, interval) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mul_d_interval(double precision, interval) is 'implementation of * operator'; + +create function pg_catalog.multirange(anyrange) returns anymultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange(anyrange) is 'anymultirange cast'; + +create function pg_catalog.multirange_adjacent_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_adjacent_multirange(anymultirange, anymultirange) is 'implementation of -|- operator'; + +create function pg_catalog.multirange_adjacent_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_adjacent_range(anymultirange, anyrange) is 'implementation of -|- operator'; + +create function pg_catalog.multirange_after_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_after_multirange(anymultirange, anymultirange) is 'implementation of >> operator'; + +create function pg_catalog.multirange_after_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_after_range(anymultirange, anyrange) is 'implementation of >> operator'; + +create function pg_catalog.multirange_agg_finalfn(internal, anymultirange) returns anymultirange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_agg_finalfn(internal, anymultirange) is 'aggregate final function'; + +create function pg_catalog.multirange_agg_transfn(internal, anymultirange) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_agg_transfn(internal, anymultirange) is 'aggregate transition function'; + +create function pg_catalog.multirange_before_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_before_multirange(anymultirange, anymultirange) is 'implementation of << operator'; + +create function pg_catalog.multirange_before_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_before_range(anymultirange, anyrange) is 'implementation of << operator'; + +create function pg_catalog.multirange_cmp(anymultirange, anymultirange) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_cmp(anymultirange, anymultirange) is 'less-equal-greater'; + +create function pg_catalog.multirange_contained_by_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_contained_by_multirange(anymultirange, anymultirange) is 'implementation of <@ operator'; + +create function pg_catalog.multirange_contained_by_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_contained_by_range(anymultirange, anyrange) is 'implementation of <@ operator'; + +create function pg_catalog.multirange_contains_elem(anymultirange, anyelement) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_contains_elem(anymultirange, anyelement) is 'implementation of @> operator'; + +create function pg_catalog.multirange_contains_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_contains_multirange(anymultirange, anymultirange) is 'implementation of @> operator'; + +create function pg_catalog.multirange_contains_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_contains_range(anymultirange, anyrange) is 'implementation of @> operator'; + +create function pg_catalog.multirange_eq(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_eq(anymultirange, anymultirange) is 'implementation of = operator'; + +create function pg_catalog.multirange_ge(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_ge(anymultirange, anymultirange) is 'implementation of >= operator'; + +create function pg_catalog.multirange_gist_compress(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_gist_compress(internal) is 'GiST support'; + +create function pg_catalog.multirange_gist_consistent(internal, anymultirange, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_gist_consistent(internal, anymultirange, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.multirange_gt(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_gt(anymultirange, anymultirange) is 'implementation of > operator'; + +create function pg_catalog.multirange_in(cstring, oid, integer) returns anymultirange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.multirange_intersect(anymultirange, anymultirange) returns anymultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_intersect(anymultirange, anymultirange) is 'implementation of * operator'; + +create function pg_catalog.multirange_intersect_agg_transfn(anymultirange, anymultirange) returns anymultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_intersect_agg_transfn(anymultirange, anymultirange) is 'range aggregate by intersecting'; + +create function pg_catalog.multirange_le(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_le(anymultirange, anymultirange) is 'implementation of <= operator'; + +create function pg_catalog.multirange_lt(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_lt(anymultirange, anymultirange) is 'implementation of < operator'; + +create function pg_catalog.multirange_minus(anymultirange, anymultirange) returns anymultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_minus(anymultirange, anymultirange) is 'implementation of - operator'; + +create function pg_catalog.multirange_ne(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_ne(anymultirange, anymultirange) is 'implementation of <> operator'; + +create function pg_catalog.multirange_out(anymultirange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_out(anymultirange) is 'I/O'; + +create function pg_catalog.multirange_overlaps_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overlaps_multirange(anymultirange, anymultirange) is 'implementation of && operator'; + +create function pg_catalog.multirange_overlaps_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overlaps_range(anymultirange, anyrange) is 'implementation of && operator'; + +create function pg_catalog.multirange_overleft_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overleft_multirange(anymultirange, anymultirange) is 'implementation of &< operator'; + +create function pg_catalog.multirange_overleft_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overleft_range(anymultirange, anyrange) is 'implementation of &< operator'; + +create function pg_catalog.multirange_overright_multirange(anymultirange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overright_multirange(anymultirange, anymultirange) is 'implementation of &> operator'; + +create function pg_catalog.multirange_overright_range(anymultirange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_overright_range(anymultirange, anyrange) is 'implementation of &> operator'; + +create function pg_catalog.multirange_recv(internal, oid, integer) returns anymultirange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.multirange_send(anymultirange) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_send(anymultirange) is 'I/O'; + +create function pg_catalog.multirange_typanalyze(internal) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_typanalyze(internal) is 'multirange typanalyze'; + +create function pg_catalog.multirange_union(anymultirange, anymultirange) returns anymultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirange_union(anymultirange, anymultirange) is 'implementation of + operator'; + +create function pg_catalog.multirangesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.multirangesel(internal, oid, internal, integer) is 'restriction selectivity for multirange operators'; + +create function pg_catalog.mxid_age(xid) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.mxid_age(xid) is 'age of a multi-transaction ID, in multi-transactions before current multi-transaction'; + +create function pg_catalog.name(char) returns name + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.name(char) is 'convert char(n) to name'; + +create function pg_catalog.name(text) returns name + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.name(text) is 'convert text to name'; + +create function pg_catalog.name(varchar) returns name + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.name(varchar) is 'convert varchar to name'; + +create function pg_catalog.nameconcatoid(name, oid) returns name + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameconcatoid(name, oid) is 'concatenate name and oid'; + +create function pg_catalog.nameeq(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameeq(name, name) is 'implementation of = operator'; + +create function pg_catalog.nameeqtext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameeqtext(name, text) is 'implementation of = operator'; + +create function pg_catalog.namege(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namege(name, name) is 'implementation of >= operator'; + +create function pg_catalog.namegetext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namegetext(name, text) is 'implementation of >= operator'; + +create function pg_catalog.namegt(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namegt(name, name) is 'implementation of > operator'; + +create function pg_catalog.namegttext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namegttext(name, text) is 'implementation of > operator'; + +create function pg_catalog.nameiclike(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameiclike(name, text) is 'implementation of ~~* operator'; + +create function pg_catalog.nameicnlike(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameicnlike(name, text) is 'implementation of !~~* operator'; + +create function pg_catalog.nameicregexeq(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameicregexeq(name, text) is 'implementation of ~* operator'; + +create function pg_catalog.nameicregexne(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameicregexne(name, text) is 'implementation of !~* operator'; + +create function pg_catalog.namein(cstring) returns name + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namein(cstring) is 'I/O'; + +create function pg_catalog.namele(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namele(name, name) is 'implementation of <= operator'; + +create function pg_catalog.nameletext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameletext(name, text) is 'implementation of <= operator'; + +create function pg_catalog.namelike(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namelike(name, text) is 'implementation of ~~ operator'; + +create function pg_catalog.namelt(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namelt(name, name) is 'implementation of < operator'; + +create function pg_catalog.namelttext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namelttext(name, text) is 'implementation of < operator'; + +create function pg_catalog.namene(name, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namene(name, name) is 'implementation of <> operator'; + +create function pg_catalog.namenetext(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namenetext(name, text) is 'implementation of <> operator'; + +create function pg_catalog.namenlike(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namenlike(name, text) is 'implementation of !~~ operator'; + +create function pg_catalog.nameout(name) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameout(name) is 'I/O'; + +create function pg_catalog.namerecv(internal) returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namerecv(internal) is 'I/O'; + +create function pg_catalog.nameregexeq(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameregexeq(name, text) is 'implementation of ~ operator'; + +create function pg_catalog.nameregexne(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nameregexne(name, text) is 'implementation of !~ operator'; + +create function pg_catalog.namesend(name) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.namesend(name) is 'I/O'; + +create function pg_catalog.neqjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.neqjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of <> and related operators'; + +create function pg_catalog.neqsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.neqsel(internal, oid, internal, integer) is 'restriction selectivity of <> and related operators'; + +create function pg_catalog.netmask(inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.netmask(inet) is 'netmask of address'; + +create function pg_catalog.network(inet) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network(inet) is 'network part of address'; + +create function pg_catalog.network_cmp(inet, inet) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_cmp(inet, inet) is 'less-equal-greater'; + +create function pg_catalog.network_eq(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_eq(inet, inet) is 'implementation of = operator'; + +create function pg_catalog.network_ge(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_ge(inet, inet) is 'implementation of >= operator'; + +create function pg_catalog.network_gt(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_gt(inet, inet) is 'implementation of > operator'; + +create function pg_catalog.network_larger(inet, inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_larger(inet, inet) is 'larger of two'; + +create function pg_catalog.network_le(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_le(inet, inet) is 'implementation of <= operator'; + +create function pg_catalog.network_lt(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_lt(inet, inet) is 'implementation of < operator'; + +create function pg_catalog.network_ne(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_ne(inet, inet) is 'implementation of <> operator'; + +create function pg_catalog.network_overlap(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_overlap(inet, inet) is 'implementation of && operator'; + +create function pg_catalog.network_smaller(inet, inet) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_smaller(inet, inet) is 'smaller of two'; + +create function pg_catalog.network_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_sortsupport(internal) is 'sort support'; + +create function pg_catalog.network_sub(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_sub(inet, inet) is 'implementation of << operator'; + +create function pg_catalog.network_subeq(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_subeq(inet, inet) is 'implementation of <<= operator'; + +create function pg_catalog.network_subset_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_subset_support(internal) is 'planner support for network_sub/superset'; + +create function pg_catalog.network_sup(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_sup(inet, inet) is 'implementation of >> operator'; + +create function pg_catalog.network_supeq(inet, inet) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.network_supeq(inet, inet) is 'implementation of >>= operator'; + +create function pg_catalog.networkjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.networkjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for network operators'; + +create function pg_catalog.networksel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.networksel(internal, oid, internal, integer) is 'restriction selectivity for network operators'; + +create function pg_catalog.nextval(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nextval(regclass) is 'sequence next value'; + +create function pg_catalog.nlikejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nlikejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of NOT LIKE'; + +create function pg_catalog.nlikesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nlikesel(internal, oid, internal, integer) is 'restriction selectivity of NOT LIKE'; + +create function pg_catalog.normalize(text, text default 'NFC'::text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.normalize(text, text) is 'Unicode normalization'; + +create function pg_catalog.notlike(bytea, bytea) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.notlike(bytea, bytea) is 'does not match LIKE expression'; + +create function pg_catalog.notlike(name, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.notlike(name, text) is 'does not match LIKE expression'; + +create function pg_catalog.notlike(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.notlike(text, text) is 'does not match LIKE expression'; + +create function pg_catalog.now() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.now() is 'current transaction time'; + +create function pg_catalog.npoints(path) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.npoints(path) is 'number of points'; + +create function pg_catalog.npoints(polygon) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.npoints(polygon) is 'number of points'; + +create function pg_catalog.nth_value(anyelement, integer) returns anyelement + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nth_value(anyelement, integer) is 'fetch the Nth row value'; + +create function pg_catalog.ntile(integer) returns integer + immutable + window + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ntile(integer) is 'split rows into N groups'; + +create function pg_catalog.num_nonnulls("any") returns integer + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.num_nonnulls("any") is 'count the number of non-NULL arguments'; + +create function pg_catalog.num_nulls("any") returns integer + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.num_nulls("any") is 'count the number of NULL arguments'; + +create function pg_catalog.numeric(bigint) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(bigint) is 'convert int8 to numeric'; + +create function pg_catalog.numeric(double precision) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(double precision) is 'convert float8 to numeric'; + +create function pg_catalog.numeric(integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(integer) is 'convert int4 to numeric'; + +create function pg_catalog.numeric(jsonb) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(jsonb) is 'convert jsonb to numeric'; + +create function pg_catalog.numeric(money) returns numeric + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(money) is 'convert money to numeric'; + +create function pg_catalog.numeric(numeric, integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(numeric, integer) is 'adjust numeric to typmod precision/scale'; + +create function pg_catalog.numeric(real) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(real) is 'convert float4 to numeric'; + +create function pg_catalog.numeric(smallint) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric(smallint) is 'convert int2 to numeric'; + +create function pg_catalog.numeric_abs(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_abs(numeric) is 'implementation of @ operator'; + +create function pg_catalog.numeric_accum(internal, numeric) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_accum(internal, numeric) is 'aggregate transition function'; + +create function pg_catalog.numeric_accum_inv(internal, numeric) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_accum_inv(internal, numeric) is 'aggregate transition function'; + +create function pg_catalog.numeric_add(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_add(numeric, numeric) is 'implementation of + operator'; + +create function pg_catalog.numeric_avg(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_avg(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_avg_accum(internal, numeric) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_avg_accum(internal, numeric) is 'aggregate transition function'; + +create function pg_catalog.numeric_avg_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_avg_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.numeric_avg_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_avg_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.numeric_avg_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_avg_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.numeric_cmp(numeric, numeric) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_cmp(numeric, numeric) is 'less-equal-greater'; + +create function pg_catalog.numeric_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.numeric_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.numeric_div(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_div(numeric, numeric) is 'implementation of / operator'; + +create function pg_catalog.numeric_div_trunc(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_div_trunc(numeric, numeric) is 'trunc(x/y)'; + +create function pg_catalog.numeric_eq(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_eq(numeric, numeric) is 'implementation of = operator'; + +create function pg_catalog.numeric_exp(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_exp(numeric) is 'natural exponential (e^x)'; + +create function pg_catalog.numeric_ge(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_ge(numeric, numeric) is 'implementation of >= operator'; + +create function pg_catalog.numeric_gt(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_gt(numeric, numeric) is 'implementation of > operator'; + +create function pg_catalog.numeric_in(cstring, oid, integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.numeric_inc(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_inc(numeric) is 'increment by one'; + +create function pg_catalog.numeric_larger(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_larger(numeric, numeric) is 'larger of two'; + +create function pg_catalog.numeric_le(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_le(numeric, numeric) is 'implementation of <= operator'; + +create function pg_catalog.numeric_ln(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_ln(numeric) is 'natural logarithm'; + +create function pg_catalog.numeric_log(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_log(numeric, numeric) is 'logarithm base m of n'; + +create function pg_catalog.numeric_lt(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_lt(numeric, numeric) is 'implementation of < operator'; + +create function pg_catalog.numeric_mod(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_mod(numeric, numeric) is 'implementation of % operator'; + +create function pg_catalog.numeric_mul(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_mul(numeric, numeric) is 'implementation of * operator'; + +create function pg_catalog.numeric_ne(numeric, numeric) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_ne(numeric, numeric) is 'implementation of <> operator'; + +create function pg_catalog.numeric_out(numeric) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_out(numeric) is 'I/O'; + +create function pg_catalog.numeric_pl_pg_lsn(numeric, pg_lsn) returns pg_lsn + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_pl_pg_lsn(numeric, pg_lsn) is 'implementation of + operator'; + +create function pg_catalog.numeric_poly_avg(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_avg(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_poly_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.numeric_poly_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.numeric_poly_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.numeric_poly_stddev_pop(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_stddev_pop(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_poly_stddev_samp(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_stddev_samp(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_poly_sum(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_sum(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_poly_var_pop(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_var_pop(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_poly_var_samp(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_poly_var_samp(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_power(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_power(numeric, numeric) is 'implementation of ^ operator'; + +create function pg_catalog.numeric_recv(internal, oid, integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.numeric_send(numeric) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_send(numeric) is 'I/O'; + +create function pg_catalog.numeric_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.numeric_smaller(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_smaller(numeric, numeric) is 'smaller of two'; + +create function pg_catalog.numeric_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_sortsupport(internal) is 'sort support'; + +create function pg_catalog.numeric_sqrt(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_sqrt(numeric) is 'square root'; + +create function pg_catalog.numeric_stddev_pop(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_stddev_pop(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_stddev_samp(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_stddev_samp(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_sub(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_sub(numeric, numeric) is 'implementation of - operator'; + +create function pg_catalog.numeric_sum(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_sum(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_support(internal) is 'planner support for numeric length coercion'; + +create function pg_catalog.numeric_uminus(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_uminus(numeric) is 'implementation of - operator'; + +create function pg_catalog.numeric_uplus(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_uplus(numeric) is 'implementation of + operator'; + +create function pg_catalog.numeric_var_pop(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_var_pop(internal) is 'aggregate final function'; + +create function pg_catalog.numeric_var_samp(internal) returns numeric + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numeric_var_samp(internal) is 'aggregate final function'; + +create function pg_catalog.numerictypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numerictypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.numerictypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numerictypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.nummultirange() returns nummultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nummultirange() is 'nummultirange constructor'; + +create function pg_catalog.nummultirange(numrange) returns nummultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nummultirange(numrange) is 'nummultirange constructor'; + +create function pg_catalog.nummultirange(numrange[]) returns nummultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.nummultirange(numrange[]) is 'nummultirange constructor'; + +create function pg_catalog.numnode(tsquery) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numnode(tsquery) is 'number of nodes'; + +create function pg_catalog.numrange(numeric, numeric) returns numrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numrange(numeric, numeric) is 'numrange constructor'; + +create function pg_catalog.numrange(numeric, numeric, text) returns numrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numrange(numeric, numeric, text) is 'numrange constructor'; + +create function pg_catalog.numrange_subdiff(numeric, numeric) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.numrange_subdiff(numeric, numeric) is 'float8 difference of two numeric values'; + +create function pg_catalog.obj_description(oid) returns text + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.obj_description(oid) is 'deprecated, use two-argument form instead'; + +create function pg_catalog.obj_description(oid, name) returns text + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.obj_description(oid, name) is 'get description for object id and catalog name'; + +create function pg_catalog.octet_length(bit) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.octet_length(bit) is 'octet length'; + +create function pg_catalog.octet_length(bytea) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.octet_length(bytea) is 'octet length'; + +create function pg_catalog.octet_length(char) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.octet_length(char) is 'octet length'; + +create function pg_catalog.octet_length(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.octet_length(text) is 'octet length'; + +create function pg_catalog.oid(bigint) returns oid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oid(bigint) is 'convert int8 to oid'; + +create function pg_catalog.oideq(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oideq(oid, oid) is 'implementation of = operator'; + +create function pg_catalog.oidge(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidge(oid, oid) is 'implementation of >= operator'; + +create function pg_catalog.oidgt(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidgt(oid, oid) is 'implementation of > operator'; + +create function pg_catalog.oidin(cstring) returns oid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidin(cstring) is 'I/O'; + +create function pg_catalog.oidlarger(oid, oid) returns oid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidlarger(oid, oid) is 'larger of two'; + +create function pg_catalog.oidle(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidle(oid, oid) is 'implementation of <= operator'; + +create function pg_catalog.oidlt(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidlt(oid, oid) is 'implementation of < operator'; + +create function pg_catalog.oidne(oid, oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidne(oid, oid) is 'implementation of <> operator'; + +create function pg_catalog.oidout(oid) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidout(oid) is 'I/O'; + +create function pg_catalog.oidrecv(internal) returns oid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidrecv(internal) is 'I/O'; + +create function pg_catalog.oidsend(oid) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidsend(oid) is 'I/O'; + +create function pg_catalog.oidsmaller(oid, oid) returns oid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidsmaller(oid, oid) is 'smaller of two'; + +create function pg_catalog.oidvectoreq(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectoreq(oidvector, oidvector) is 'implementation of = operator'; + +create function pg_catalog.oidvectorge(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorge(oidvector, oidvector) is 'implementation of >= operator'; + +create function pg_catalog.oidvectorgt(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorgt(oidvector, oidvector) is 'implementation of > operator'; + +create function pg_catalog.oidvectorin(cstring) returns oidvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorin(cstring) is 'I/O'; + +create function pg_catalog.oidvectorle(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorle(oidvector, oidvector) is 'implementation of <= operator'; + +create function pg_catalog.oidvectorlt(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorlt(oidvector, oidvector) is 'implementation of < operator'; + +create function pg_catalog.oidvectorne(oidvector, oidvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorne(oidvector, oidvector) is 'implementation of <> operator'; + +create function pg_catalog.oidvectorout(oidvector) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorout(oidvector) is 'I/O'; + +create function pg_catalog.oidvectorrecv(internal) returns oidvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorrecv(internal) is 'I/O'; + +create function pg_catalog.oidvectorsend(oidvector) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectorsend(oidvector) is 'I/O'; + +create function pg_catalog.oidvectortypes(oidvector) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.oidvectortypes(oidvector) is 'print type names of oidvector field'; + +create function pg_catalog.on_pb(point, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_pb(point, box) is 'implementation of <@ operator'; + +create function pg_catalog.on_pl(point, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_pl(point, line) is 'implementation of <@ operator'; + +create function pg_catalog.on_ppath(point, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_ppath(point, path) is 'implementation of <@ operator'; + +create function pg_catalog.on_ps(point, lseg) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_ps(point, lseg) is 'implementation of <@ operator'; + +create function pg_catalog.on_sb(lseg, box) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_sb(lseg, box) is 'implementation of <@ operator'; + +create function pg_catalog.on_sl(lseg, line) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.on_sl(lseg, line) is 'implementation of <@ operator'; + +create function pg_catalog.ordered_set_transition(internal, "any") returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ordered_set_transition(internal, "any") is 'aggregate transition function'; + +create function pg_catalog.ordered_set_transition_multi(internal, "any") returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ordered_set_transition_multi(internal, "any") is 'aggregate transition function'; + +create function pg_catalog."overlaps"(time with time zone, time with time zone, time with time zone, time with time zone) returns boolean + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(time with time zone, time with time zone, time with time zone, time with time zone) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(time, interval, time, interval) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(time, interval, time, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(time, interval, time, time) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(time, interval, time, time) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(time, time, time, interval) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(time, time, time, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(time, time, time, time) returns boolean + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(time, time, time, time) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp with time zone, interval, timestamp with time zone, interval) returns boolean + stable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp with time zone, interval, timestamp with time zone, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp with time zone, interval, timestamp with time zone, timestamp with time zone) returns boolean + stable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp with time zone, interval, timestamp with time zone, timestamp with time zone) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp with time zone, timestamp with time zone, timestamp with time zone, interval) returns boolean + stable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp with time zone, timestamp with time zone, timestamp with time zone, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp with time zone, timestamp with time zone, timestamp with time zone, timestamp with time zone) returns boolean + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp with time zone, timestamp with time zone, timestamp with time zone, timestamp with time zone) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp, interval, timestamp, interval) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp, interval, timestamp, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp, interval, timestamp, timestamp) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp, interval, timestamp, timestamp) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp, timestamp, timestamp, interval) returns boolean + immutable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp, timestamp, timestamp, interval) is 'intervals overlap?'; + +create function pg_catalog."overlaps"(timestamp, timestamp, timestamp, timestamp) returns boolean + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."overlaps"(timestamp, timestamp, timestamp, timestamp) is 'intervals overlap?'; + +create function pg_catalog.overlay(bit, bit, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(bit, bit, integer) is 'substitute portion of bitstring'; + +create function pg_catalog.overlay(bit, bit, integer, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(bit, bit, integer, integer) is 'substitute portion of bitstring'; + +create function pg_catalog.overlay(bytea, bytea, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(bytea, bytea, integer) is 'substitute portion of string'; + +create function pg_catalog.overlay(bytea, bytea, integer, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(bytea, bytea, integer, integer) is 'substitute portion of string'; + +create function pg_catalog.overlay(text, text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(text, text, integer) is 'substitute portion of string'; + +create function pg_catalog.overlay(text, text, integer, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.overlay(text, text, integer, integer) is 'substitute portion of string'; + +create function pg_catalog.parse_ident(str text, strict boolean default true) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.parse_ident(text, boolean) is 'parse qualified identifier to array of identifiers'; + +create function pg_catalog.path(polygon) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path(polygon) is 'convert polygon to path'; + +create function pg_catalog.path_add(path, path) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_add(path, path) is 'implementation of + operator'; + +create function pg_catalog.path_add_pt(path, point) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_add_pt(path, point) is 'implementation of + operator'; + +create function pg_catalog.path_contain_pt(path, point) returns boolean + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_contain_pt(path, point) is 'implementation of @> operator'; + +create function pg_catalog.path_distance(path, path) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_distance(path, path) is 'implementation of <-> operator'; + +create function pg_catalog.path_div_pt(path, point) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_div_pt(path, point) is 'implementation of / operator'; + +create function pg_catalog.path_in(cstring) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_in(cstring) is 'I/O'; + +create function pg_catalog.path_inter(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_inter(path, path) is 'implementation of ?# operator'; + +create function pg_catalog.path_length(path) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_length(path) is 'implementation of @-@ operator'; + +create function pg_catalog.path_mul_pt(path, point) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_mul_pt(path, point) is 'implementation of * operator'; + +create function pg_catalog.path_n_eq(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_n_eq(path, path) is 'implementation of = operator'; + +create function pg_catalog.path_n_ge(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_n_ge(path, path) is 'implementation of >= operator'; + +create function pg_catalog.path_n_gt(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_n_gt(path, path) is 'implementation of > operator'; + +create function pg_catalog.path_n_le(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_n_le(path, path) is 'implementation of <= operator'; + +create function pg_catalog.path_n_lt(path, path) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_n_lt(path, path) is 'implementation of < operator'; + +create function pg_catalog.path_npoints(path) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_npoints(path) is 'implementation of # operator'; + +create function pg_catalog.path_out(path) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_out(path) is 'I/O'; + +create function pg_catalog.path_recv(internal) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_recv(internal) is 'I/O'; + +create function pg_catalog.path_send(path) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_send(path) is 'I/O'; + +create function pg_catalog.path_sub_pt(path, point) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.path_sub_pt(path, point) is 'implementation of - operator'; + +create function pg_catalog.pclose(path) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pclose(path) is 'close path'; + +create function pg_catalog.percent_rank() returns double precision + immutable + window + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percent_rank() is 'fractional rank within partition'; + +create function pg_catalog.percent_rank_final(internal, "any") returns double precision + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percent_rank_final(internal, "any") is 'aggregate final function'; + +create function pg_catalog.percentile_cont_float8_final(internal, double precision) returns double precision + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_cont_float8_final(internal, double precision) is 'aggregate final function'; + +create function pg_catalog.percentile_cont_float8_multi_final(internal, double precision[]) returns double precision[] + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_cont_float8_multi_final(internal, double precision[]) is 'aggregate final function'; + +create function pg_catalog.percentile_cont_interval_final(internal, double precision) returns interval + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_cont_interval_final(internal, double precision) is 'aggregate final function'; + +create function pg_catalog.percentile_cont_interval_multi_final(internal, double precision[]) returns interval[] + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_cont_interval_multi_final(internal, double precision[]) is 'aggregate final function'; + +create function pg_catalog.percentile_disc_final(internal, double precision, anyelement) returns anyelement + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_disc_final(internal, double precision, anyelement) is 'aggregate final function'; + +create function pg_catalog.percentile_disc_multi_final(internal, double precision[], anyelement) returns anyarray + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.percentile_disc_multi_final(internal, double precision[], anyelement) is 'aggregate final function'; + +create function pg_catalog.pg_advisory_lock(bigint) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_lock(bigint) is 'obtain exclusive advisory lock'; + +create function pg_catalog.pg_advisory_lock(integer, integer) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_lock(integer, integer) is 'obtain exclusive advisory lock'; + +create function pg_catalog.pg_advisory_lock_shared(bigint) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_lock_shared(bigint) is 'obtain shared advisory lock'; + +create function pg_catalog.pg_advisory_lock_shared(integer, integer) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_lock_shared(integer, integer) is 'obtain shared advisory lock'; + +create function pg_catalog.pg_advisory_unlock(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_unlock(bigint) is 'release exclusive advisory lock'; + +create function pg_catalog.pg_advisory_unlock(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_unlock(integer, integer) is 'release exclusive advisory lock'; + +create function pg_catalog.pg_advisory_unlock_all() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_unlock_all() is 'release all advisory locks'; + +create function pg_catalog.pg_advisory_unlock_shared(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_unlock_shared(bigint) is 'release shared advisory lock'; + +create function pg_catalog.pg_advisory_unlock_shared(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_unlock_shared(integer, integer) is 'release shared advisory lock'; + +create function pg_catalog.pg_advisory_xact_lock(bigint) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_xact_lock(bigint) is 'obtain exclusive advisory lock'; + +create function pg_catalog.pg_advisory_xact_lock(integer, integer) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_xact_lock(integer, integer) is 'obtain exclusive advisory lock'; + +create function pg_catalog.pg_advisory_xact_lock_shared(bigint) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_xact_lock_shared(bigint) is 'obtain shared advisory lock'; + +create function pg_catalog.pg_advisory_xact_lock_shared(integer, integer) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_advisory_xact_lock_shared(integer, integer) is 'obtain shared advisory lock'; + +create function pg_catalog.pg_available_extension_versions(out name name, out version text, out superuser boolean, out trusted boolean, out relocatable boolean, out schema name, out requires name[], out comment text) returns setof record + stable + strict + cost 10 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_available_extension_versions(out name, out text, out boolean, out boolean, out boolean, out name, out name[], out text) is 'list available extension versions'; + +create function pg_catalog.pg_available_extensions(out name name, out default_version text, out comment text) returns setof record + stable + strict + cost 10 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_available_extensions(out name, out text, out text) is 'list available extensions'; + +create function pg_catalog.pg_backend_pid() returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_backend_pid() is 'statistics: current backend PID'; + +create function pg_catalog.pg_backup_start(label text, fast boolean default false) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_backup_start(text, boolean) is 'prepare for taking an online backup'; + +create function pg_catalog.pg_backup_stop(wait_for_archive boolean default true, out lsn pg_lsn, out labelfile text, out spcmapfile text) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_backup_stop(boolean, out pg_lsn, out text, out text) is 'finish taking an online backup'; + +create function pg_catalog.pg_blocking_pids(integer) returns integer[] + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_blocking_pids(integer) is 'get array of PIDs of sessions blocking specified backend PID from acquiring a heavyweight lock'; + +create function pg_catalog.pg_cancel_backend(integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_cancel_backend(integer) is 'cancel a server process'' current query'; + +create function pg_catalog.pg_char_to_encoding(name) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_char_to_encoding(name) is 'convert encoding name to encoding id'; + +create function pg_catalog.pg_client_encoding() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_client_encoding() is 'encoding name of current database'; + +create function pg_catalog.pg_collation_actual_version(oid) returns text + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_collation_actual_version(oid) is 'get actual version of collation from operating system'; + +create function pg_catalog.pg_collation_for("any") returns text + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_collation_for("any") is 'collation of the argument; implementation of the COLLATION FOR expression'; + +create function pg_catalog.pg_collation_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_collation_is_visible(oid) is 'is collation visible in search path?'; + +create function pg_catalog.pg_column_compression("any") returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_column_compression("any") is 'compression method for the compressed datum'; + +create function pg_catalog.pg_column_is_updatable(regclass, smallint, boolean) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_column_is_updatable(regclass, smallint, boolean) is 'is a column updatable'; + +create function pg_catalog.pg_column_size("any") returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_column_size("any") is 'bytes required to store the value, perhaps with compression'; + +create function pg_catalog.pg_conf_load_time() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_conf_load_time() is 'configuration load time'; + +create function pg_catalog.pg_config(out name text, out setting text) returns setof record + stable + strict + cost 1 + rows 23 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_config(out text, out text) is 'pg_config binary as a function'; + +create function pg_catalog.pg_control_checkpoint(out checkpoint_lsn pg_lsn, out redo_lsn pg_lsn, out redo_wal_file text, out timeline_id integer, out prev_timeline_id integer, out full_page_writes boolean, out next_xid text, out next_oid oid, out next_multixact_id xid, out next_multi_offset xid, out oldest_xid xid, out oldest_xid_dbid oid, out oldest_active_xid xid, out oldest_multi_xid xid, out oldest_multi_dbid oid, out oldest_commit_ts_xid xid, out newest_commit_ts_xid xid, out checkpoint_time timestamp with time zone) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_control_checkpoint(out pg_lsn, out pg_lsn, out text, out integer, out integer, out boolean, out text, out oid, out xid, out xid, out xid, out oid, out xid, out xid, out oid, out xid, out xid, out timestamp with time zone) is 'pg_controldata checkpoint state information as a function'; + +create function pg_catalog.pg_control_init(out max_data_alignment integer, out database_block_size integer, out blocks_per_segment integer, out wal_block_size integer, out bytes_per_wal_segment integer, out max_identifier_length integer, out max_index_columns integer, out max_toast_chunk_size integer, out large_object_chunk_size integer, out float8_pass_by_value boolean, out data_page_checksum_version integer) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_control_init(out integer, out integer, out integer, out integer, out integer, out integer, out integer, out integer, out integer, out boolean, out integer) is 'pg_controldata init state information as a function'; + +create function pg_catalog.pg_control_recovery(out min_recovery_end_lsn pg_lsn, out min_recovery_end_timeline integer, out backup_start_lsn pg_lsn, out backup_end_lsn pg_lsn, out end_of_backup_record_required boolean) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_control_recovery(out pg_lsn, out integer, out pg_lsn, out pg_lsn, out boolean) is 'pg_controldata recovery state information as a function'; + +create function pg_catalog.pg_control_system(out pg_control_version integer, out catalog_version_no integer, out system_identifier bigint, out pg_control_last_modified timestamp with time zone) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_control_system(out integer, out integer, out bigint, out timestamp with time zone) is 'pg_controldata general state information as a function'; + +create function pg_catalog.pg_conversion_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_conversion_is_visible(oid) is 'is conversion visible in search path?'; + +create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_copy_logical_replication_slot(name, name, out name, out pg_lsn) is 'copy a logical replication slot'; + +create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_copy_logical_replication_slot(name, name, boolean, out name, out pg_lsn) is 'copy a logical replication slot, changing temporality'; + +create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, plugin name, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_copy_logical_replication_slot(name, name, boolean, name, out name, out pg_lsn) is 'copy a logical replication slot, changing temporality and plugin'; + +create function pg_catalog.pg_copy_physical_replication_slot(src_slot_name name, dst_slot_name name, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_copy_physical_replication_slot(name, name, out name, out pg_lsn) is 'copy a physical replication slot'; + +create function pg_catalog.pg_copy_physical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_copy_physical_replication_slot(name, name, boolean, out name, out pg_lsn) is 'copy a physical replication slot, changing temporality'; + +create function pg_catalog.pg_create_logical_replication_slot(slot_name name, plugin name, temporary boolean default false, twophase boolean default false, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_create_logical_replication_slot(name, name, boolean, boolean, out name, out pg_lsn) is 'set up a logical replication slot'; + +create function pg_catalog.pg_create_physical_replication_slot(slot_name name, immediately_reserve boolean default false, temporary boolean default false, out slot_name name, out lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_create_physical_replication_slot(name, boolean, boolean, out name, out pg_lsn) is 'create a physical replication slot'; + +create function pg_catalog.pg_create_restore_point(text) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_create_restore_point(text) is 'create a named restore point'; + +create function pg_catalog.pg_current_logfile() returns text + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_logfile() is 'current logging collector file location'; + +create function pg_catalog.pg_current_logfile(text) returns text + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_logfile(text) is 'current logging collector file location'; + +create function pg_catalog.pg_current_snapshot() returns pg_snapshot + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_snapshot() is 'get current snapshot'; + +create function pg_catalog.pg_current_wal_flush_lsn() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_wal_flush_lsn() is 'current wal flush location'; + +create function pg_catalog.pg_current_wal_insert_lsn() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_wal_insert_lsn() is 'current wal insert location'; + +create function pg_catalog.pg_current_wal_lsn() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_wal_lsn() is 'current wal write location'; + +create function pg_catalog.pg_current_xact_id() returns xid8 + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_xact_id() is 'get current transaction ID'; + +create function pg_catalog.pg_current_xact_id_if_assigned() returns xid8 + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_current_xact_id_if_assigned() is 'get current transaction ID'; + +create function pg_catalog.pg_cursor(out name text, out statement text, out is_holdable boolean, out is_binary boolean, out is_scrollable boolean, out creation_time timestamp with time zone) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_cursor(out text, out text, out boolean, out boolean, out boolean, out timestamp with time zone) is 'get the open cursors for this session'; + +create function pg_catalog.pg_database_collation_actual_version(oid) returns text + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_database_collation_actual_version(oid) is 'get actual version of database collation from operating system'; + +create function pg_catalog.pg_database_size(name) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_database_size(name) is 'total disk space usage for the specified database'; + +create function pg_catalog.pg_database_size(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_database_size(oid) is 'total disk space usage for the specified database'; + +create function pg_catalog.pg_ddl_command_in(cstring) returns pg_ddl_command + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ddl_command_in(cstring) is 'I/O'; + +create function pg_catalog.pg_ddl_command_out(pg_ddl_command) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ddl_command_out(pg_ddl_command) is 'I/O'; + +create function pg_catalog.pg_ddl_command_recv(internal) returns pg_ddl_command + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ddl_command_recv(internal) is 'I/O'; + +create function pg_catalog.pg_ddl_command_send(pg_ddl_command) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ddl_command_send(pg_ddl_command) is 'I/O'; + +create function pg_catalog.pg_dependencies_in(cstring) returns pg_dependencies + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_dependencies_in(cstring) is 'I/O'; + +create function pg_catalog.pg_dependencies_out(pg_dependencies) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_dependencies_out(pg_dependencies) is 'I/O'; + +create function pg_catalog.pg_dependencies_recv(internal) returns pg_dependencies + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_dependencies_recv(internal) is 'I/O'; + +create function pg_catalog.pg_dependencies_send(pg_dependencies) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_dependencies_send(pg_dependencies) is 'I/O'; + +create function pg_catalog.pg_describe_object(oid, oid, integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_describe_object(oid, oid, integer) is 'get identification of SQL object'; + +create function pg_catalog.pg_drop_replication_slot(name) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_drop_replication_slot(name) is 'drop a replication slot'; + +create function pg_catalog.pg_encoding_max_length(integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_encoding_max_length(integer) is 'maximum octet length of a character in given encoding'; + +create function pg_catalog.pg_encoding_to_char(integer) returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_encoding_to_char(integer) is 'convert encoding id to encoding name'; + +create function pg_catalog.pg_event_trigger_ddl_commands(out classid oid, out objid oid, out objsubid integer, out command_tag text, out object_type text, out schema_name text, out object_identity text, out in_extension boolean, out command pg_ddl_command) returns setof record + stable + strict + cost 10 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_event_trigger_ddl_commands(out oid, out oid, out integer, out text, out text, out text, out text, out boolean, out pg_ddl_command) is 'list DDL actions being executed by the current command'; + +create function pg_catalog.pg_event_trigger_dropped_objects(out classid oid, out objid oid, out objsubid integer, out original boolean, out normal boolean, out is_temporary boolean, out object_type text, out schema_name text, out object_name text, out object_identity text, out address_names text[], out address_args text[]) returns setof record + stable + strict + cost 10 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_event_trigger_dropped_objects(out oid, out oid, out integer, out boolean, out boolean, out boolean, out text, out text, out text, out text, out text[], out text[]) is 'list objects dropped by the current command'; + +create function pg_catalog.pg_event_trigger_table_rewrite_oid(out oid oid) returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_event_trigger_table_rewrite_oid(out oid) is 'return Oid of the table getting rewritten'; + +create function pg_catalog.pg_event_trigger_table_rewrite_reason() returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_event_trigger_table_rewrite_reason() is 'return reason code for table getting rewritten'; + +create function pg_catalog.pg_export_snapshot() returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_export_snapshot() is 'export a snapshot'; + +create function pg_catalog.pg_extension_config_dump(regclass, text) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_extension_config_dump(regclass, text) is 'flag an extension''s table contents to be emitted by pg_dump'; + +create function pg_catalog.pg_extension_update_paths(name name, out source text, out target text, out path text) returns setof record + stable + strict + cost 10 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_extension_update_paths(name, out text, out text, out text) is 'list an extension''s version update paths'; + +create function pg_catalog.pg_filenode_relation(oid, oid) returns regclass + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_filenode_relation(oid, oid) is 'relation OID for filenode and tablespace'; + +create function pg_catalog.pg_function_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_function_is_visible(oid) is 'is function visible in search path?'; + +create function pg_catalog.pg_get_backend_memory_contexts(out name text, out ident text, out parent text, out level integer, out total_bytes bigint, out total_nblocks bigint, out free_bytes bigint, out free_chunks bigint, out used_bytes bigint) returns setof record + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_backend_memory_contexts(out text, out text, out text, out integer, out bigint, out bigint, out bigint, out bigint, out bigint) is 'information about all memory contexts of local backend'; + +create function pg_catalog.pg_get_catalog_foreign_keys(out fktable regclass, out fkcols text[], out pktable regclass, out pkcols text[], out is_array boolean, out is_opt boolean) returns setof record + stable + strict + cost 10 + rows 250 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_catalog_foreign_keys(out regclass, out text[], out regclass, out text[], out boolean, out boolean) is 'list of catalog foreign key relationships'; + +create function pg_catalog.pg_get_constraintdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_constraintdef(oid) is 'constraint description'; + +create function pg_catalog.pg_get_constraintdef(oid, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_constraintdef(oid, boolean) is 'constraint description with pretty-print option'; + +create function pg_catalog.pg_get_expr(pg_node_tree, oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_expr(pg_node_tree, oid) is 'deparse an encoded expression'; + +create function pg_catalog.pg_get_expr(pg_node_tree, oid, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_expr(pg_node_tree, oid, boolean) is 'deparse an encoded expression with pretty-print option'; + +create function pg_catalog.pg_get_function_arg_default(oid, integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_function_arg_default(oid, integer) is 'function argument default'; + +create function pg_catalog.pg_get_function_arguments(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_function_arguments(oid) is 'argument list of a function'; + +create function pg_catalog.pg_get_function_identity_arguments(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_function_identity_arguments(oid) is 'identity argument list of a function'; + +create function pg_catalog.pg_get_function_result(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_function_result(oid) is 'result type of a function'; + +create function pg_catalog.pg_get_function_sqlbody(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_function_sqlbody(oid) is 'function SQL body'; + +create function pg_catalog.pg_get_functiondef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_functiondef(oid) is 'definition of a function'; + +create function pg_catalog.pg_get_indexdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_indexdef(oid) is 'index description'; + +create function pg_catalog.pg_get_indexdef(oid, integer, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_indexdef(oid, integer, boolean) is 'index description (full create statement or single expression) with pretty-print option'; + +create function pg_catalog.pg_get_keywords(out word text, out catcode "char", out barelabel boolean, out catdesc text, out baredesc text) returns setof record + stable + strict + cost 10 + rows 500 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_keywords(out text, out "char", out boolean, out text, out text) is 'list of SQL keywords'; + +create function pg_catalog.pg_get_multixact_members(multixid xid, out xid xid, out mode text) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_multixact_members(xid, out xid, out text) is 'view members of a multixactid'; + +create function pg_catalog.pg_get_object_address(type text, object_names text[], object_args text[], out classid oid, out objid oid, out objsubid integer) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_object_address(text, text[], text[], out oid, out oid, out integer) is 'get OID-based object address from name/args arrays'; + +create function pg_catalog.pg_get_partition_constraintdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_partition_constraintdef(oid) is 'partition constraint description'; + +create function pg_catalog.pg_get_partkeydef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_partkeydef(oid) is 'partition key description'; + +create function pg_catalog.pg_get_publication_tables(pubname text[], out pubid oid, out relid oid, out attrs int2vector, out qual pg_node_tree) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_publication_tables(text[], out oid, out oid, out int2vector, out pg_node_tree) is 'get information of the tables that are part of the specified publications'; + +create function pg_catalog.pg_get_replica_identity_index(regclass) returns regclass + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_replica_identity_index(regclass) is 'oid of replica identity index if any'; + +create function pg_catalog.pg_get_replication_slots(out slot_name name, out plugin name, out slot_type text, out datoid oid, out temporary boolean, out active boolean, out active_pid integer, out xmin xid, out catalog_xmin xid, out restart_lsn pg_lsn, out confirmed_flush_lsn pg_lsn, out wal_status text, out safe_wal_size bigint, out two_phase boolean, out conflicting boolean) returns setof record + stable + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_replication_slots(out name, out name, out text, out oid, out boolean, out boolean, out integer, out xid, out xid, out pg_lsn, out pg_lsn, out text, out bigint, out boolean, out boolean) is 'information about replication slots currently in use'; + +create function pg_catalog.pg_get_ruledef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_ruledef(oid) is 'source text of a rule'; + +create function pg_catalog.pg_get_ruledef(oid, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_ruledef(oid, boolean) is 'source text of a rule with pretty-print option'; + +create function pg_catalog.pg_get_serial_sequence(text, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_serial_sequence(text, text) is 'name of sequence for a serial column'; + +create function pg_catalog.pg_get_shmem_allocations(out name text, out "off" bigint, out size bigint, out allocated_size bigint) returns setof record + strict + cost 1 + rows 50 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_shmem_allocations(out text, out bigint, out bigint, out bigint) is 'allocations from the main shared memory segment'; + +create function pg_catalog.pg_get_statisticsobjdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_statisticsobjdef(oid) is 'extended statistics object description'; + +create function pg_catalog.pg_get_statisticsobjdef_columns(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_statisticsobjdef_columns(oid) is 'extended statistics columns'; + +create function pg_catalog.pg_get_statisticsobjdef_expressions(oid) returns text[] + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_statisticsobjdef_expressions(oid) is 'extended statistics expressions'; + +create function pg_catalog.pg_get_triggerdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_triggerdef(oid) is 'trigger description'; + +create function pg_catalog.pg_get_triggerdef(oid, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_triggerdef(oid, boolean) is 'trigger description with pretty-print option'; + +create function pg_catalog.pg_get_userbyid(oid) returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_userbyid(oid) is 'role name by OID (with fallback)'; + +create function pg_catalog.pg_get_viewdef(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_viewdef(oid) is 'select statement of a view'; + +create function pg_catalog.pg_get_viewdef(oid, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_viewdef(oid, boolean) is 'select statement of a view with pretty-print option'; + +create function pg_catalog.pg_get_viewdef(oid, integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_viewdef(oid, integer) is 'select statement of a view with pretty-printing and specified line wrapping'; + +create function pg_catalog.pg_get_viewdef(text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_viewdef(text) is 'select statement of a view'; + +create function pg_catalog.pg_get_viewdef(text, boolean) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_viewdef(text, boolean) is 'select statement of a view with pretty-print option'; + +create function pg_catalog.pg_get_wal_replay_pause_state() returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_wal_replay_pause_state() is 'get wal replay pause state'; + +create function pg_catalog.pg_get_wal_resource_managers(out rm_id integer, out rm_name text, out rm_builtin boolean) returns setof record + strict + cost 1 + rows 50 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_get_wal_resource_managers(out integer, out text, out boolean) is 'get resource managers loaded in system'; + +create function pg_catalog.pg_has_role(name, name, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(name, name, text) is 'user privilege on role by username, role name'; + +create function pg_catalog.pg_has_role(name, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(name, oid, text) is 'user privilege on role by username, role oid'; + +create function pg_catalog.pg_has_role(name, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(name, text) is 'current user privilege on role by role name'; + +create function pg_catalog.pg_has_role(oid, name, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(oid, name, text) is 'user privilege on role by user oid, role name'; + +create function pg_catalog.pg_has_role(oid, oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(oid, oid, text) is 'user privilege on role by user oid, role oid'; + +create function pg_catalog.pg_has_role(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_has_role(oid, text) is 'current user privilege on role by role oid'; + +create function pg_catalog.pg_hba_file_rules(out rule_number integer, out file_name text, out line_number integer, out type text, out database text[], out user_name text[], out address text, out netmask text, out auth_method text, out options text[], out error text) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_hba_file_rules(out integer, out text, out integer, out text, out text[], out text[], out text, out text, out text, out text[], out text) is 'show pg_hba.conf rules'; + +create function pg_catalog.pg_ident_file_mappings(out map_number integer, out file_name text, out line_number integer, out map_name text, out sys_name text, out pg_username text, out error text) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ident_file_mappings(out integer, out text, out integer, out text, out text, out text, out text) is 'show pg_ident.conf mappings'; + +create function pg_catalog.pg_identify_object(classid oid, objid oid, objsubid integer, out type text, out schema text, out name text, out identity text) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_identify_object(oid, oid, integer, out text, out text, out text, out text) is 'get machine-parseable identification of SQL object'; + +create function pg_catalog.pg_identify_object_as_address(classid oid, objid oid, objsubid integer, out type text, out object_names text[], out object_args text[]) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_identify_object_as_address(oid, oid, integer, out text, out text[], out text[]) is 'get identification of SQL object for pg_get_object_address()'; + +create function pg_catalog.pg_import_system_collations(regnamespace) returns integer + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_import_system_collations(regnamespace) is 'import collations from operating system'; + +create function pg_catalog.pg_index_column_has_property(regclass, integer, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_index_column_has_property(regclass, integer, text) is 'test property of an index column'; + +create function pg_catalog.pg_index_has_property(regclass, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_index_has_property(regclass, text) is 'test property of an index'; + +create function pg_catalog.pg_indexam_has_property(oid, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_indexam_has_property(oid, text) is 'test property of an index access method'; + +create function pg_catalog.pg_indexam_progress_phasename(oid, bigint) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_indexam_progress_phasename(oid, bigint) is 'return name of given index build phase'; + +create function pg_catalog.pg_indexes_size(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_indexes_size(regclass) is 'disk space usage for all indexes attached to the specified table'; + +create function pg_catalog.pg_input_error_info(value text, type_name text, out message text, out detail text, out hint text, out sql_error_code text) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_input_error_info(text, text, out text, out text, out text, out text) is 'get error details if string is not valid input for data type'; + +create function pg_catalog.pg_input_is_valid(text, text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_input_is_valid(text, text) is 'test whether string is valid input for data type'; + +create function pg_catalog.pg_is_in_recovery() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_is_in_recovery() is 'true if server is in recovery'; + +create function pg_catalog.pg_is_other_temp_schema(oid) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_is_other_temp_schema(oid) is 'is schema another session''s temp schema?'; + +create function pg_catalog.pg_is_wal_replay_paused() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_is_wal_replay_paused() is 'true if wal replay is paused'; + +create function pg_catalog.pg_isolation_test_session_is_blocked(integer, integer[]) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_isolation_test_session_is_blocked(integer, integer[]) is 'isolationtester support function'; + +create function pg_catalog.pg_jit_available() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_jit_available() is 'Is JIT compilation available in this session?'; + +create function pg_catalog.pg_last_committed_xact(out xid xid, out timestamp timestamp with time zone, out roident oid) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_last_committed_xact(out xid, out timestamp with time zone, out oid) is 'get transaction Id, commit timestamp and replication origin of latest transaction commit'; + +create function pg_catalog.pg_last_wal_receive_lsn() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_last_wal_receive_lsn() is 'current wal flush location'; + +create function pg_catalog.pg_last_wal_replay_lsn() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_last_wal_replay_lsn() is 'last wal replay location'; + +create function pg_catalog.pg_last_xact_replay_timestamp() returns timestamp with time zone + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_last_xact_replay_timestamp() is 'timestamp of last replay xact'; + +create function pg_catalog.pg_listening_channels() returns setof text + stable + strict + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_listening_channels() is 'get the channels that the current backend listens to'; + +create function pg_catalog.pg_lock_status(out locktype text, out database oid, out relation oid, out page integer, out tuple smallint, out virtualxid text, out transactionid xid, out classid oid, out objid oid, out objsubid smallint, out virtualtransaction text, out pid integer, out mode text, out granted boolean, out fastpath boolean, out waitstart timestamp with time zone) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lock_status(out text, out oid, out oid, out integer, out smallint, out text, out xid, out oid, out oid, out smallint, out text, out integer, out text, out boolean, out boolean, out timestamp with time zone) is 'view system lock information'; + +create function pg_catalog.pg_log_backend_memory_contexts(integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_log_backend_memory_contexts(integer) is 'log memory contexts of the specified backend'; + +create function pg_catalog.pg_log_standby_snapshot() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_log_standby_snapshot() is 'log details of the current snapshot to WAL'; + +create function pg_catalog.pg_logical_emit_message(boolean, text, bytea) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_emit_message(boolean, text, bytea) is 'emit a binary logical decoding message'; + +create function pg_catalog.pg_logical_emit_message(boolean, text, text) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_emit_message(boolean, text, text) is 'emit a textual logical decoding message'; + +create function pg_catalog.pg_logical_slot_get_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, options text[] default '{}'::text[], out lsn pg_lsn, out xid xid, out data bytea) returns setof record + cost 1000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_slot_get_binary_changes(name, pg_lsn, integer, text[], out pg_lsn, out xid, out bytea) is 'get binary changes from replication slot'; + +create function pg_catalog.pg_logical_slot_get_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, options text[] default '{}'::text[], out lsn pg_lsn, out xid xid, out data text) returns setof record + cost 1000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_slot_get_changes(name, pg_lsn, integer, text[], out pg_lsn, out xid, out text) is 'get changes from replication slot'; + +create function pg_catalog.pg_logical_slot_peek_binary_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, options text[] default '{}'::text[], out lsn pg_lsn, out xid xid, out data bytea) returns setof record + cost 1000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_slot_peek_binary_changes(name, pg_lsn, integer, text[], out pg_lsn, out xid, out bytea) is 'peek at binary changes from replication slot'; + +create function pg_catalog.pg_logical_slot_peek_changes(slot_name name, upto_lsn pg_lsn, upto_nchanges integer, options text[] default '{}'::text[], out lsn pg_lsn, out xid xid, out data text) returns setof record + cost 1000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_logical_slot_peek_changes(name, pg_lsn, integer, text[], out pg_lsn, out xid, out text) is 'peek at changes from replication slot'; + +create function pg_catalog.pg_ls_archive_statusdir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_archive_statusdir(out text, out bigint, out timestamp with time zone) is 'list of files in the archive_status directory'; + +create function pg_catalog.pg_ls_dir(text) returns setof text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_dir(text) is 'list all files in a directory'; + +create function pg_catalog.pg_ls_dir(text, boolean, boolean) returns setof text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_dir(text, boolean, boolean) is 'list all files in a directory'; + +create function pg_catalog.pg_ls_logdir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_logdir(out text, out bigint, out timestamp with time zone) is 'list files in the log directory'; + +create function pg_catalog.pg_ls_logicalmapdir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_logicalmapdir(out text, out bigint, out timestamp with time zone) is 'list of files in the pg_logical/mappings directory'; + +create function pg_catalog.pg_ls_logicalsnapdir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_logicalsnapdir(out text, out bigint, out timestamp with time zone) is 'list of files in the pg_logical/snapshots directory'; + +create function pg_catalog.pg_ls_replslotdir(slot_name text, out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_replslotdir(text, out text, out bigint, out timestamp with time zone) is 'list of files in the pg_replslot/slot_name directory'; + +create function pg_catalog.pg_ls_tmpdir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_tmpdir(out text, out bigint, out timestamp with time zone) is 'list files in the pgsql_tmp directory'; + +create function pg_catalog.pg_ls_tmpdir(tablespace oid, out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_tmpdir(oid, out text, out bigint, out timestamp with time zone) is 'list files in the pgsql_tmp directory'; + +create function pg_catalog.pg_ls_waldir(out name text, out size bigint, out modification timestamp with time zone) returns setof record + strict + cost 10 + rows 20 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ls_waldir(out text, out bigint, out timestamp with time zone) is 'list of files in the WAL directory'; + +create function pg_catalog.pg_lsn(numeric) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn(numeric) is 'convert numeric to pg_lsn'; + +create function pg_catalog.pg_lsn_cmp(pg_lsn, pg_lsn) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_cmp(pg_lsn, pg_lsn) is 'less-equal-greater'; + +create function pg_catalog.pg_lsn_eq(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_eq(pg_lsn, pg_lsn) is 'implementation of = operator'; + +create function pg_catalog.pg_lsn_ge(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_ge(pg_lsn, pg_lsn) is 'implementation of >= operator'; + +create function pg_catalog.pg_lsn_gt(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_gt(pg_lsn, pg_lsn) is 'implementation of > operator'; + +create function pg_catalog.pg_lsn_hash(pg_lsn) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_hash(pg_lsn) is 'hash'; + +create function pg_catalog.pg_lsn_hash_extended(pg_lsn, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_hash_extended(pg_lsn, bigint) is 'hash'; + +create function pg_catalog.pg_lsn_in(cstring) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_in(cstring) is 'I/O'; + +create function pg_catalog.pg_lsn_larger(pg_lsn, pg_lsn) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_larger(pg_lsn, pg_lsn) is 'larger of two'; + +create function pg_catalog.pg_lsn_le(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_le(pg_lsn, pg_lsn) is 'implementation of <= operator'; + +create function pg_catalog.pg_lsn_lt(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_lt(pg_lsn, pg_lsn) is 'implementation of < operator'; + +create function pg_catalog.pg_lsn_mi(pg_lsn, pg_lsn) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_mi(pg_lsn, pg_lsn) is 'implementation of - operator'; + +create function pg_catalog.pg_lsn_mii(pg_lsn, numeric) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_mii(pg_lsn, numeric) is 'implementation of - operator'; + +create function pg_catalog.pg_lsn_ne(pg_lsn, pg_lsn) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_ne(pg_lsn, pg_lsn) is 'implementation of <> operator'; + +create function pg_catalog.pg_lsn_out(pg_lsn) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_out(pg_lsn) is 'I/O'; + +create function pg_catalog.pg_lsn_pli(pg_lsn, numeric) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_pli(pg_lsn, numeric) is 'implementation of + operator'; + +create function pg_catalog.pg_lsn_recv(internal) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_recv(internal) is 'I/O'; + +create function pg_catalog.pg_lsn_send(pg_lsn) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_send(pg_lsn) is 'I/O'; + +create function pg_catalog.pg_lsn_smaller(pg_lsn, pg_lsn) returns pg_lsn + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_lsn_smaller(pg_lsn, pg_lsn) is 'smaller of two'; + +create function pg_catalog.pg_mcv_list_in(cstring) returns pg_mcv_list + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_mcv_list_in(cstring) is 'I/O'; + +create function pg_catalog.pg_mcv_list_items(mcv_list pg_mcv_list, out index integer, out values text[], out nulls boolean[], out frequency double precision, out base_frequency double precision) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_mcv_list_items(pg_mcv_list, out integer, out text[], out boolean[], out double precision, out double precision) is 'details about MCV list items'; + +create function pg_catalog.pg_mcv_list_out(pg_mcv_list) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_mcv_list_out(pg_mcv_list) is 'I/O'; + +create function pg_catalog.pg_mcv_list_recv(internal) returns pg_mcv_list + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_mcv_list_recv(internal) is 'I/O'; + +create function pg_catalog.pg_mcv_list_send(pg_mcv_list) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_mcv_list_send(pg_mcv_list) is 'I/O'; + +create function pg_catalog.pg_my_temp_schema() returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_my_temp_schema() is 'get OID of current session''s temp schema, if any'; + +create function pg_catalog.pg_ndistinct_in(cstring) returns pg_ndistinct + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ndistinct_in(cstring) is 'I/O'; + +create function pg_catalog.pg_ndistinct_out(pg_ndistinct) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ndistinct_out(pg_ndistinct) is 'I/O'; + +create function pg_catalog.pg_ndistinct_recv(internal) returns pg_ndistinct + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ndistinct_recv(internal) is 'I/O'; + +create function pg_catalog.pg_ndistinct_send(pg_ndistinct) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ndistinct_send(pg_ndistinct) is 'I/O'; + +create function pg_catalog.pg_nextoid(regclass, name, regclass) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_nextoid(regclass, name, regclass) is 'return the next oid for a system table'; + +create function pg_catalog.pg_node_tree_in(cstring) returns pg_node_tree + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_node_tree_in(cstring) is 'I/O'; + +create function pg_catalog.pg_node_tree_out(pg_node_tree) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_node_tree_out(pg_node_tree) is 'I/O'; + +create function pg_catalog.pg_node_tree_recv(internal) returns pg_node_tree + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_node_tree_recv(internal) is 'I/O'; + +create function pg_catalog.pg_node_tree_send(pg_node_tree) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_node_tree_send(pg_node_tree) is 'I/O'; + +create function pg_catalog.pg_notification_queue_usage() returns double precision + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_notification_queue_usage() is 'get the fraction of the asynchronous notification queue currently in use'; + +create function pg_catalog.pg_notify(text, text) returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_notify(text, text) is 'send a notification event'; + +create function pg_catalog.pg_opclass_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_opclass_is_visible(oid) is 'is opclass visible in search path?'; + +create function pg_catalog.pg_operator_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_operator_is_visible(oid) is 'is operator visible in search path?'; + +create function pg_catalog.pg_opfamily_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_opfamily_is_visible(oid) is 'is opfamily visible in search path?'; + +create function pg_catalog.pg_options_to_table(options_array text[], out option_name text, out option_value text) returns setof record + stable + strict + cost 1 + rows 3 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_options_to_table(text[], out text, out text) is 'convert generic options array to name/value table'; + +create function pg_catalog.pg_partition_ancestors(partitionid regclass, out relid regclass) returns setof regclass + strict + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_partition_ancestors(regclass, out regclass) is 'view ancestors of the partition'; + +create function pg_catalog.pg_partition_root(regclass) returns regclass + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_partition_root(regclass) is 'get top-most partition root parent'; + +create function pg_catalog.pg_partition_tree(rootrelid regclass, out relid regclass, out parentrelid regclass, out isleaf boolean, out level integer) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_partition_tree(regclass, out regclass, out regclass, out boolean, out integer) is 'view partition tree tables'; + +create function pg_catalog.pg_postmaster_start_time() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_postmaster_start_time() is 'postmaster start time'; + +create function pg_catalog.pg_prepared_statement(out name text, out statement text, out prepare_time timestamp with time zone, out parameter_types regtype[], out result_types regtype[], out from_sql boolean, out generic_plans bigint, out custom_plans bigint) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_prepared_statement(out text, out text, out timestamp with time zone, out regtype[], out regtype[], out boolean, out bigint, out bigint) is 'get the prepared statements for this session'; + +create function pg_catalog.pg_prepared_xact(out transaction xid, out gid text, out prepared timestamp with time zone, out ownerid oid, out dbid oid) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_prepared_xact(out xid, out text, out timestamp with time zone, out oid, out oid) is 'view two-phase transactions'; + +create function pg_catalog.pg_promote(wait boolean default true, wait_seconds integer default 60) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_promote(boolean, integer) is 'promote standby server'; + +create function pg_catalog.pg_read_binary_file(text) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_binary_file(text) is 'read bytea from a file'; + +create function pg_catalog.pg_read_binary_file(text, bigint, bigint) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_binary_file(text, bigint, bigint) is 'read bytea from a file'; + +create function pg_catalog.pg_read_binary_file(text, bigint, bigint, boolean) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_binary_file(text, bigint, bigint, boolean) is 'read bytea from a file'; + +create function pg_catalog.pg_read_binary_file(text, boolean) returns bytea + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_binary_file(text, boolean) is 'read bytea from a file'; + +create function pg_catalog.pg_read_file(text) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_file(text) is 'read text from a file'; + +create function pg_catalog.pg_read_file(text, bigint, bigint) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_file(text, bigint, bigint) is 'read text from a file'; + +create function pg_catalog.pg_read_file(text, bigint, bigint, boolean) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_file(text, bigint, bigint, boolean) is 'read text from a file'; + +create function pg_catalog.pg_read_file(text, boolean) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_file(text, boolean) is 'read text from a file'; + +create function pg_catalog.pg_read_file_old(text, bigint, bigint) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_read_file_old(text, bigint, bigint) is 'read text from a file - old version for adminpack 1.0'; + +create function pg_catalog.pg_relation_filenode(regclass) returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_filenode(regclass) is 'filenode identifier of relation'; + +create function pg_catalog.pg_relation_filepath(regclass) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_filepath(regclass) is 'file path of relation'; + +create function pg_catalog.pg_relation_is_publishable(regclass) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_is_publishable(regclass) is 'returns whether a relation can be part of a publication'; + +create function pg_catalog.pg_relation_is_updatable(regclass, boolean) returns integer + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_is_updatable(regclass, boolean) is 'is a relation insertable/updatable/deletable'; + +create function pg_catalog.pg_relation_size(regclass) returns bigint + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_size(regclass) is 'disk space usage for the main fork of the specified table or index'; + +create function pg_catalog.pg_relation_size(regclass, text) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_relation_size(regclass, text) is 'disk space usage for the specified fork of a table or index'; + +create function pg_catalog.pg_reload_conf() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_reload_conf() is 'reload configuration files'; + +create function pg_catalog.pg_replication_origin_advance(text, pg_lsn) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_advance(text, pg_lsn) is 'advance replication origin to specific location'; + +create function pg_catalog.pg_replication_origin_create(text) returns oid + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_create(text) is 'create a replication origin'; + +create function pg_catalog.pg_replication_origin_drop(text) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_drop(text) is 'drop replication origin identified by its name'; + +create function pg_catalog.pg_replication_origin_oid(text) returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_oid(text) is 'translate the replication origin''s name to its id'; + +create function pg_catalog.pg_replication_origin_progress(text, boolean) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_progress(text, boolean) is 'get an individual replication origin''s replication progress'; + +create function pg_catalog.pg_replication_origin_session_is_setup() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_session_is_setup() is 'is a replication origin configured in this session'; + +create function pg_catalog.pg_replication_origin_session_progress(boolean) returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_session_progress(boolean) is 'get the replication progress of the current session'; + +create function pg_catalog.pg_replication_origin_session_reset() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_session_reset() is 'teardown configured replication progress tracking'; + +create function pg_catalog.pg_replication_origin_session_setup(text) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_session_setup(text) is 'configure session to maintain replication progress tracking for the passed in origin'; + +create function pg_catalog.pg_replication_origin_xact_reset() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_xact_reset() is 'reset the transaction''s origin lsn and timestamp'; + +create function pg_catalog.pg_replication_origin_xact_setup(pg_lsn, timestamp with time zone) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_origin_xact_setup(pg_lsn, timestamp with time zone) is 'setup the transaction''s origin lsn and timestamp'; + +create function pg_catalog.pg_replication_slot_advance(slot_name name, upto_lsn pg_lsn, out slot_name name, out end_lsn pg_lsn) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_replication_slot_advance(name, pg_lsn, out name, out pg_lsn) is 'advance logical replication slot'; + +create function pg_catalog.pg_rotate_logfile() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_rotate_logfile() is 'rotate log file'; + +create function pg_catalog.pg_rotate_logfile_old() returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_rotate_logfile_old() is 'rotate log file - old version for adminpack 1.0'; + +create function pg_catalog.pg_safe_snapshot_blocking_pids(integer) returns integer[] + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_safe_snapshot_blocking_pids(integer) is 'get array of PIDs of sessions blocking specified backend PID from acquiring a safe snapshot'; + +create function pg_catalog.pg_sequence_last_value(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_sequence_last_value(regclass) is 'sequence last value'; + +create function pg_catalog.pg_sequence_parameters(sequence_oid oid, out start_value bigint, out minimum_value bigint, out maximum_value bigint, out increment bigint, out cycle_option boolean, out cache_size bigint, out data_type oid) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_sequence_parameters(oid, out bigint, out bigint, out bigint, out bigint, out boolean, out bigint, out oid) is 'sequence parameters, for use by information schema'; + +create function pg_catalog.pg_settings_get_flags(text) returns text[] + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_settings_get_flags(text) is 'return flags for specified GUC'; + +create function pg_catalog.pg_show_all_file_settings(out sourcefile text, out sourceline integer, out seqno integer, out name text, out setting text, out applied boolean, out error text) returns setof record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_show_all_file_settings(out text, out integer, out integer, out text, out text, out boolean, out text) is 'show config file settings'; + +create function pg_catalog.pg_show_all_settings(out name text, out setting text, out unit text, out category text, out short_desc text, out extra_desc text, out context text, out vartype text, out source text, out min_val text, out max_val text, out enumvals text[], out boot_val text, out reset_val text, out sourcefile text, out sourceline integer, out pending_restart boolean) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_show_all_settings(out text, out text, out text, out text, out text, out text, out text, out text, out text, out text, out text, out text[], out text, out text, out text, out integer, out boolean) is 'SHOW ALL as a function'; + +create function pg_catalog.pg_show_replication_origin_status(out local_id oid, out external_id text, out remote_lsn pg_lsn, out local_lsn pg_lsn) returns setof record + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_show_replication_origin_status(out oid, out text, out pg_lsn, out pg_lsn) is 'get progress for all replication origins'; + +create function pg_catalog.pg_size_bytes(text) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_size_bytes(text) is 'convert a size in human-readable format with size units into bytes'; + +create function pg_catalog.pg_size_pretty(bigint) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_size_pretty(bigint) is 'convert a long int to a human readable text using size units'; + +create function pg_catalog.pg_size_pretty(numeric) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_size_pretty(numeric) is 'convert a numeric to a human readable text using size units'; + +create function pg_catalog.pg_sleep(double precision) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_sleep(double precision) is 'sleep for the specified time in seconds'; + +create function pg_catalog.pg_sleep_for(interval) returns void + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_sleep_for(interval) is 'sleep for the specified interval'; + +create function pg_catalog.pg_sleep_until(timestamp with time zone) returns void + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_sleep_until(timestamp with time zone) is 'sleep until the specified time'; + +create function pg_catalog.pg_snapshot_in(cstring) returns pg_snapshot + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_in(cstring) is 'I/O'; + +create function pg_catalog.pg_snapshot_out(pg_snapshot) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_out(pg_snapshot) is 'I/O'; + +create function pg_catalog.pg_snapshot_recv(internal) returns pg_snapshot + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_recv(internal) is 'I/O'; + +create function pg_catalog.pg_snapshot_send(pg_snapshot) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_send(pg_snapshot) is 'I/O'; + +create function pg_catalog.pg_snapshot_xip(pg_snapshot) returns setof xid8 + immutable + strict + cost 1 + rows 50 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_xip(pg_snapshot) is 'get set of in-progress transactions in snapshot'; + +create function pg_catalog.pg_snapshot_xmax(pg_snapshot) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_xmax(pg_snapshot) is 'get xmax of snapshot'; + +create function pg_catalog.pg_snapshot_xmin(pg_snapshot) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_snapshot_xmin(pg_snapshot) is 'get xmin of snapshot'; + +create function pg_catalog.pg_split_walfile_name(file_name text, out segment_number numeric, out timeline_id bigint) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_split_walfile_name(text, out numeric, out bigint) is 'sequence number and timeline ID given a wal filename'; + +create function pg_catalog.pg_stat_clear_snapshot() returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_clear_snapshot() is 'statistics: discard current transaction''s statistics snapshot'; + +create function pg_catalog.pg_stat_file(filename text, out size bigint, out access timestamp with time zone, out modification timestamp with time zone, out change timestamp with time zone, out creation timestamp with time zone, out isdir boolean) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_file(text, out bigint, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out boolean) is 'get information about file'; + +create function pg_catalog.pg_stat_file(filename text, missing_ok boolean, out size bigint, out access timestamp with time zone, out modification timestamp with time zone, out change timestamp with time zone, out creation timestamp with time zone, out isdir boolean) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_file(text, boolean, out bigint, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out boolean) is 'get information about file'; + +create function pg_catalog.pg_stat_force_next_flush() returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_force_next_flush() is 'statistics: force stats to be flushed after the next commit'; + +create function pg_catalog.pg_stat_get_activity(pid integer, out datid oid, out pid integer, out usesysid oid, out application_name text, out state text, out query text, out wait_event_type text, out wait_event text, out xact_start timestamp with time zone, out query_start timestamp with time zone, out backend_start timestamp with time zone, out state_change timestamp with time zone, out client_addr inet, out client_hostname text, out client_port integer, out backend_xid xid, out backend_xmin xid, out backend_type text, out ssl boolean, out sslversion text, out sslcipher text, out sslbits integer, out ssl_client_dn text, out ssl_client_serial numeric, out ssl_issuer_dn text, out gss_auth boolean, out gss_princ text, out gss_enc boolean, out gss_delegation boolean, out leader_pid integer, out query_id bigint) returns setof record + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_activity(integer, out oid, out integer, out oid, out text, out text, out text, out text, out text, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out timestamp with time zone, out inet, out text, out integer, out xid, out xid, out text, out boolean, out text, out text, out integer, out text, out numeric, out text, out boolean, out text, out boolean, out boolean, out integer, out bigint) is 'statistics: information about currently active backends'; + +create function pg_catalog.pg_stat_get_analyze_count(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_analyze_count(oid) is 'statistics: number of manual analyzes for a table'; + +create function pg_catalog.pg_stat_get_archiver(out archived_count bigint, out last_archived_wal text, out last_archived_time timestamp with time zone, out failed_count bigint, out last_failed_wal text, out last_failed_time timestamp with time zone, out stats_reset timestamp with time zone) returns record + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_archiver(out bigint, out text, out timestamp with time zone, out bigint, out text, out timestamp with time zone, out timestamp with time zone) is 'statistics: information about WAL archiver'; + +create function pg_catalog.pg_stat_get_autoanalyze_count(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_autoanalyze_count(oid) is 'statistics: number of auto analyzes for a table'; + +create function pg_catalog.pg_stat_get_autovacuum_count(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_autovacuum_count(oid) is 'statistics: number of auto vacuums for a table'; + +create function pg_catalog.pg_stat_get_backend_activity(integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_activity(integer) is 'statistics: current query of backend'; + +create function pg_catalog.pg_stat_get_backend_activity_start(integer) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_activity_start(integer) is 'statistics: start time for current query of backend'; + +create function pg_catalog.pg_stat_get_backend_client_addr(integer) returns inet + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_client_addr(integer) is 'statistics: address of client connected to backend'; + +create function pg_catalog.pg_stat_get_backend_client_port(integer) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_client_port(integer) is 'statistics: port number of client connected to backend'; + +create function pg_catalog.pg_stat_get_backend_dbid(integer) returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_dbid(integer) is 'statistics: database ID of backend'; + +create function pg_catalog.pg_stat_get_backend_idset() returns setof integer + stable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_idset() is 'statistics: currently active backend IDs'; + +create function pg_catalog.pg_stat_get_backend_pid(integer) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_pid(integer) is 'statistics: PID of backend'; + +create function pg_catalog.pg_stat_get_backend_start(integer) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_start(integer) is 'statistics: start time for current backend session'; + +create function pg_catalog.pg_stat_get_backend_subxact(bid integer, out subxact_count integer, out subxact_overflowed boolean) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_subxact(integer, out integer, out boolean) is 'statistics: get subtransaction status of backend'; + +create function pg_catalog.pg_stat_get_backend_userid(integer) returns oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_userid(integer) is 'statistics: user ID of backend'; + +create function pg_catalog.pg_stat_get_backend_wait_event(integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_wait_event(integer) is 'statistics: wait event on which backend is currently waiting'; + +create function pg_catalog.pg_stat_get_backend_wait_event_type(integer) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_wait_event_type(integer) is 'statistics: wait event type on which backend is currently waiting'; + +create function pg_catalog.pg_stat_get_backend_xact_start(integer) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_backend_xact_start(integer) is 'statistics: start time for backend''s current transaction'; + +create function pg_catalog.pg_stat_get_bgwriter_buf_written_checkpoints() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_buf_written_checkpoints() is 'statistics: number of buffers written by the bgwriter during checkpoints'; + +create function pg_catalog.pg_stat_get_bgwriter_buf_written_clean() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_buf_written_clean() is 'statistics: number of buffers written by the bgwriter for cleaning dirty buffers'; + +create function pg_catalog.pg_stat_get_bgwriter_maxwritten_clean() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_maxwritten_clean() is 'statistics: number of times the bgwriter stopped processing when it had written too many buffers while cleaning'; + +create function pg_catalog.pg_stat_get_bgwriter_requested_checkpoints() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_requested_checkpoints() is 'statistics: number of backend requested checkpoints started by the bgwriter'; + +create function pg_catalog.pg_stat_get_bgwriter_stat_reset_time() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_stat_reset_time() is 'statistics: last reset for the bgwriter'; + +create function pg_catalog.pg_stat_get_bgwriter_timed_checkpoints() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_bgwriter_timed_checkpoints() is 'statistics: number of timed checkpoints started by the bgwriter'; + +create function pg_catalog.pg_stat_get_blocks_fetched(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_blocks_fetched(oid) is 'statistics: number of blocks fetched'; + +create function pg_catalog.pg_stat_get_blocks_hit(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_blocks_hit(oid) is 'statistics: number of blocks found in cache'; + +create function pg_catalog.pg_stat_get_buf_alloc() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_buf_alloc() is 'statistics: number of buffer allocations'; + +create function pg_catalog.pg_stat_get_buf_fsync_backend() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_buf_fsync_backend() is 'statistics: number of backend buffer writes that did their own fsync'; + +create function pg_catalog.pg_stat_get_buf_written_backend() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_buf_written_backend() is 'statistics: number of buffers written by backends'; + +create function pg_catalog.pg_stat_get_checkpoint_sync_time() returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_checkpoint_sync_time() is 'statistics: checkpoint time spent synchronizing buffers to disk, in milliseconds'; + +create function pg_catalog.pg_stat_get_checkpoint_write_time() returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_checkpoint_write_time() is 'statistics: checkpoint time spent writing buffers to disk, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_active_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_active_time(oid) is 'statistics: session active time, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_blk_read_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_blk_read_time(oid) is 'statistics: block read time, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_blk_write_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_blk_write_time(oid) is 'statistics: block write time, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_blocks_fetched(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_blocks_fetched(oid) is 'statistics: blocks fetched for database'; + +create function pg_catalog.pg_stat_get_db_blocks_hit(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_blocks_hit(oid) is 'statistics: blocks found in cache for database'; + +create function pg_catalog.pg_stat_get_db_checksum_failures(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_checksum_failures(oid) is 'statistics: checksum failures detected in database'; + +create function pg_catalog.pg_stat_get_db_checksum_last_failure(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_checksum_last_failure(oid) is 'statistics: when last checksum failure was detected in database'; + +create function pg_catalog.pg_stat_get_db_conflict_all(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_all(oid) is 'statistics: recovery conflicts in database'; + +create function pg_catalog.pg_stat_get_db_conflict_bufferpin(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_bufferpin(oid) is 'statistics: recovery conflicts in database caused by shared buffer pin'; + +create function pg_catalog.pg_stat_get_db_conflict_lock(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_lock(oid) is 'statistics: recovery conflicts in database caused by relation lock'; + +create function pg_catalog.pg_stat_get_db_conflict_logicalslot(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_logicalslot(oid) is 'statistics: recovery conflicts in database caused by logical replication slot'; + +create function pg_catalog.pg_stat_get_db_conflict_snapshot(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_snapshot(oid) is 'statistics: recovery conflicts in database caused by snapshot expiry'; + +create function pg_catalog.pg_stat_get_db_conflict_startup_deadlock(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_startup_deadlock(oid) is 'statistics: recovery conflicts in database caused by buffer deadlock'; + +create function pg_catalog.pg_stat_get_db_conflict_tablespace(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_conflict_tablespace(oid) is 'statistics: recovery conflicts in database caused by drop tablespace'; + +create function pg_catalog.pg_stat_get_db_deadlocks(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_deadlocks(oid) is 'statistics: deadlocks detected in database'; + +create function pg_catalog.pg_stat_get_db_idle_in_transaction_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_idle_in_transaction_time(oid) is 'statistics: session idle in transaction time, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_numbackends(oid) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_numbackends(oid) is 'statistics: number of backends in database'; + +create function pg_catalog.pg_stat_get_db_session_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_session_time(oid) is 'statistics: session time, in milliseconds'; + +create function pg_catalog.pg_stat_get_db_sessions(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_sessions(oid) is 'statistics: total number of sessions'; + +create function pg_catalog.pg_stat_get_db_sessions_abandoned(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_sessions_abandoned(oid) is 'statistics: number of sessions disconnected by the client closing the network connection'; + +create function pg_catalog.pg_stat_get_db_sessions_fatal(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_sessions_fatal(oid) is 'statistics: number of sessions disconnected by fatal errors'; + +create function pg_catalog.pg_stat_get_db_sessions_killed(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_sessions_killed(oid) is 'statistics: number of sessions killed by administrative action'; + +create function pg_catalog.pg_stat_get_db_stat_reset_time(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_stat_reset_time(oid) is 'statistics: last reset for a database'; + +create function pg_catalog.pg_stat_get_db_temp_bytes(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_temp_bytes(oid) is 'statistics: number of bytes in temporary files written'; + +create function pg_catalog.pg_stat_get_db_temp_files(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_temp_files(oid) is 'statistics: number of temporary files written'; + +create function pg_catalog.pg_stat_get_db_tuples_deleted(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_tuples_deleted(oid) is 'statistics: tuples deleted in database'; + +create function pg_catalog.pg_stat_get_db_tuples_fetched(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_tuples_fetched(oid) is 'statistics: tuples fetched for database'; + +create function pg_catalog.pg_stat_get_db_tuples_inserted(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_tuples_inserted(oid) is 'statistics: tuples inserted in database'; + +create function pg_catalog.pg_stat_get_db_tuples_returned(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_tuples_returned(oid) is 'statistics: tuples returned for database'; + +create function pg_catalog.pg_stat_get_db_tuples_updated(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_tuples_updated(oid) is 'statistics: tuples updated in database'; + +create function pg_catalog.pg_stat_get_db_xact_commit(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_xact_commit(oid) is 'statistics: transactions committed'; + +create function pg_catalog.pg_stat_get_db_xact_rollback(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_db_xact_rollback(oid) is 'statistics: transactions rolled back'; + +create function pg_catalog.pg_stat_get_dead_tuples(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_dead_tuples(oid) is 'statistics: number of dead tuples'; + +create function pg_catalog.pg_stat_get_function_calls(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_function_calls(oid) is 'statistics: number of function calls'; + +create function pg_catalog.pg_stat_get_function_self_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_function_self_time(oid) is 'statistics: self execution time of function, in milliseconds'; + +create function pg_catalog.pg_stat_get_function_total_time(oid) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_function_total_time(oid) is 'statistics: total execution time of function, in milliseconds'; + +create function pg_catalog.pg_stat_get_ins_since_vacuum(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_ins_since_vacuum(oid) is 'statistics: number of tuples inserted since last vacuum'; + +create function pg_catalog.pg_stat_get_io(out backend_type text, out object text, out context text, out reads bigint, out read_time double precision, out writes bigint, out write_time double precision, out writebacks bigint, out writeback_time double precision, out extends bigint, out extend_time double precision, out op_bytes bigint, out hits bigint, out evictions bigint, out reuses bigint, out fsyncs bigint, out fsync_time double precision, out stats_reset timestamp with time zone) returns setof record + strict + cost 1 + rows 30 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_io(out text, out text, out text, out bigint, out double precision, out bigint, out double precision, out bigint, out double precision, out bigint, out double precision, out bigint, out bigint, out bigint, out bigint, out bigint, out double precision, out timestamp with time zone) is 'statistics: per backend type IO statistics'; + +create function pg_catalog.pg_stat_get_last_analyze_time(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_last_analyze_time(oid) is 'statistics: last manual analyze time for a table'; + +create function pg_catalog.pg_stat_get_last_autoanalyze_time(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_last_autoanalyze_time(oid) is 'statistics: last auto analyze time for a table'; + +create function pg_catalog.pg_stat_get_last_autovacuum_time(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_last_autovacuum_time(oid) is 'statistics: last auto vacuum time for a table'; + +create function pg_catalog.pg_stat_get_last_vacuum_time(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_last_vacuum_time(oid) is 'statistics: last manual vacuum time for a table'; + +create function pg_catalog.pg_stat_get_lastscan(oid) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_lastscan(oid) is 'statistics: time of the last scan for table/index'; + +create function pg_catalog.pg_stat_get_live_tuples(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_live_tuples(oid) is 'statistics: number of live tuples'; + +create function pg_catalog.pg_stat_get_mod_since_analyze(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_mod_since_analyze(oid) is 'statistics: number of tuples changed since last analyze'; + +create function pg_catalog.pg_stat_get_numscans(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_numscans(oid) is 'statistics: number of scans done for table/index'; + +create function pg_catalog.pg_stat_get_progress_info(cmdtype text, out pid integer, out datid oid, out relid oid, out param1 bigint, out param2 bigint, out param3 bigint, out param4 bigint, out param5 bigint, out param6 bigint, out param7 bigint, out param8 bigint, out param9 bigint, out param10 bigint, out param11 bigint, out param12 bigint, out param13 bigint, out param14 bigint, out param15 bigint, out param16 bigint, out param17 bigint, out param18 bigint, out param19 bigint, out param20 bigint) returns setof record + stable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_progress_info(text, out integer, out oid, out oid, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint) is 'statistics: information about progress of backends running maintenance command'; + +create function pg_catalog.pg_stat_get_recovery_prefetch(out stats_reset timestamp with time zone, out prefetch bigint, out hit bigint, out skip_init bigint, out skip_new bigint, out skip_fpw bigint, out skip_rep bigint, out wal_distance integer, out block_distance integer, out io_depth integer) returns setof record + strict + cost 1 + rows 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_recovery_prefetch(out timestamp with time zone, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out integer, out integer, out integer) is 'statistics: information about WAL prefetching'; + +create function pg_catalog.pg_stat_get_replication_slot(slot_name text, out slot_name text, out spill_txns bigint, out spill_count bigint, out spill_bytes bigint, out stream_txns bigint, out stream_count bigint, out stream_bytes bigint, out total_txns bigint, out total_bytes bigint, out stats_reset timestamp with time zone) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_replication_slot(text, out text, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out timestamp with time zone) is 'statistics: information about replication slot'; + +create function pg_catalog.pg_stat_get_slru(out name text, out blks_zeroed bigint, out blks_hit bigint, out blks_read bigint, out blks_written bigint, out blks_exists bigint, out flushes bigint, out truncates bigint, out stats_reset timestamp with time zone) returns setof record + stable + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_slru(out text, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out bigint, out timestamp with time zone) is 'statistics: information about SLRU caches'; + +create function pg_catalog.pg_stat_get_snapshot_timestamp() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_snapshot_timestamp() is 'statistics: timestamp of the current statistics snapshot'; + +create function pg_catalog.pg_stat_get_subscription(subid oid, out subid oid, out relid oid, out pid integer, out leader_pid integer, out received_lsn pg_lsn, out last_msg_send_time timestamp with time zone, out last_msg_receipt_time timestamp with time zone, out latest_end_lsn pg_lsn, out latest_end_time timestamp with time zone) returns setof record + stable + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_subscription(oid, out oid, out oid, out integer, out integer, out pg_lsn, out timestamp with time zone, out timestamp with time zone, out pg_lsn, out timestamp with time zone) is 'statistics: information about subscription'; + +create function pg_catalog.pg_stat_get_subscription_stats(subid oid, out subid oid, out apply_error_count bigint, out sync_error_count bigint, out stats_reset timestamp with time zone) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_subscription_stats(oid, out oid, out bigint, out bigint, out timestamp with time zone) is 'statistics: information about subscription stats'; + +create function pg_catalog.pg_stat_get_tuples_deleted(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_deleted(oid) is 'statistics: number of tuples deleted'; + +create function pg_catalog.pg_stat_get_tuples_fetched(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_fetched(oid) is 'statistics: number of tuples fetched by idxscan'; + +create function pg_catalog.pg_stat_get_tuples_hot_updated(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_hot_updated(oid) is 'statistics: number of tuples hot updated'; + +create function pg_catalog.pg_stat_get_tuples_inserted(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_inserted(oid) is 'statistics: number of tuples inserted'; + +create function pg_catalog.pg_stat_get_tuples_newpage_updated(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_newpage_updated(oid) is 'statistics: number of tuples updated onto a new page'; + +create function pg_catalog.pg_stat_get_tuples_returned(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_returned(oid) is 'statistics: number of tuples read by seqscan'; + +create function pg_catalog.pg_stat_get_tuples_updated(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_tuples_updated(oid) is 'statistics: number of tuples updated'; + +create function pg_catalog.pg_stat_get_vacuum_count(oid) returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_vacuum_count(oid) is 'statistics: number of manual vacuums for a table'; + +create function pg_catalog.pg_stat_get_wal(out wal_records bigint, out wal_fpi bigint, out wal_bytes numeric, out wal_buffers_full bigint, out wal_write bigint, out wal_sync bigint, out wal_write_time double precision, out wal_sync_time double precision, out stats_reset timestamp with time zone) returns record + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_wal(out bigint, out bigint, out numeric, out bigint, out bigint, out bigint, out double precision, out double precision, out timestamp with time zone) is 'statistics: information about WAL activity'; + +create function pg_catalog.pg_stat_get_wal_receiver(out pid integer, out status text, out receive_start_lsn pg_lsn, out receive_start_tli integer, out written_lsn pg_lsn, out flushed_lsn pg_lsn, out received_tli integer, out last_msg_send_time timestamp with time zone, out last_msg_receipt_time timestamp with time zone, out latest_end_lsn pg_lsn, out latest_end_time timestamp with time zone, out slot_name text, out sender_host text, out sender_port integer, out conninfo text) returns record + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_wal_receiver(out integer, out text, out pg_lsn, out integer, out pg_lsn, out pg_lsn, out integer, out timestamp with time zone, out timestamp with time zone, out pg_lsn, out timestamp with time zone, out text, out text, out integer, out text) is 'statistics: information about WAL receiver'; + +create function pg_catalog.pg_stat_get_wal_senders(out pid integer, out state text, out sent_lsn pg_lsn, out write_lsn pg_lsn, out flush_lsn pg_lsn, out replay_lsn pg_lsn, out write_lag interval, out flush_lag interval, out replay_lag interval, out sync_priority integer, out sync_state text, out reply_time timestamp with time zone) returns setof record + stable + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_wal_senders(out integer, out text, out pg_lsn, out pg_lsn, out pg_lsn, out pg_lsn, out interval, out interval, out interval, out integer, out text, out timestamp with time zone) is 'statistics: information about currently active replication'; + +create function pg_catalog.pg_stat_get_xact_blocks_fetched(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_blocks_fetched(oid) is 'statistics: number of blocks fetched in current transaction'; + +create function pg_catalog.pg_stat_get_xact_blocks_hit(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_blocks_hit(oid) is 'statistics: number of blocks found in cache in current transaction'; + +create function pg_catalog.pg_stat_get_xact_function_calls(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_function_calls(oid) is 'statistics: number of function calls in current transaction'; + +create function pg_catalog.pg_stat_get_xact_function_self_time(oid) returns double precision + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_function_self_time(oid) is 'statistics: self execution time of function in current transaction, in milliseconds'; + +create function pg_catalog.pg_stat_get_xact_function_total_time(oid) returns double precision + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_function_total_time(oid) is 'statistics: total execution time of function in current transaction, in milliseconds'; + +create function pg_catalog.pg_stat_get_xact_numscans(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_numscans(oid) is 'statistics: number of scans done for table/index in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_deleted(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_deleted(oid) is 'statistics: number of tuples deleted in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_fetched(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_fetched(oid) is 'statistics: number of tuples fetched by idxscan in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_hot_updated(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_hot_updated(oid) is 'statistics: number of tuples hot updated in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_inserted(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_inserted(oid) is 'statistics: number of tuples inserted in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_newpage_updated(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_newpage_updated(oid) is 'statistics: number of tuples updated onto a new page in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_returned(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_returned(oid) is 'statistics: number of tuples read by seqscan in current transaction'; + +create function pg_catalog.pg_stat_get_xact_tuples_updated(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_get_xact_tuples_updated(oid) is 'statistics: number of tuples updated in current transaction'; + +create function pg_catalog.pg_stat_have_stats(text, oid, oid) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_have_stats(text, oid, oid) is 'statistics: check if a stats object exists'; + +create function pg_catalog.pg_stat_reset() returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset() is 'statistics: reset collected statistics for current database'; + +create function pg_catalog.pg_stat_reset_replication_slot(text) returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_replication_slot(text) is 'statistics: reset collected statistics for a single replication slot'; + +create function pg_catalog.pg_stat_reset_shared(text) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_shared(text) is 'statistics: reset collected statistics shared across the cluster'; + +create function pg_catalog.pg_stat_reset_single_function_counters(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_single_function_counters(oid) is 'statistics: reset collected statistics for a single function in the current database'; + +create function pg_catalog.pg_stat_reset_single_table_counters(oid) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_single_table_counters(oid) is 'statistics: reset collected statistics for a single table or index in the current database or shared across all databases in the cluster'; + +create function pg_catalog.pg_stat_reset_slru(text) returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_slru(text) is 'statistics: reset collected statistics for a single SLRU'; + +create function pg_catalog.pg_stat_reset_subscription_stats(oid) returns void + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stat_reset_subscription_stats(oid) is 'statistics: reset collected statistics for a single subscription'; + +create function pg_catalog.pg_statistics_obj_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_statistics_obj_is_visible(oid) is 'is statistics object visible in search path?'; + +create function pg_catalog.pg_stop_making_pinned_objects() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_stop_making_pinned_objects() is 'stop making pinned objects during initdb'; + +create function pg_catalog.pg_switch_wal() returns pg_lsn + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_switch_wal() is 'switch to new wal file'; + +create function pg_catalog.pg_table_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_table_is_visible(oid) is 'is table visible in search path?'; + +create function pg_catalog.pg_table_size(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_table_size(regclass) is 'disk space usage for the specified table, including TOAST, free space and visibility map'; + +create function pg_catalog.pg_tablespace_databases(oid) returns setof oid + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_tablespace_databases(oid) is 'get OIDs of databases in a tablespace'; + +create function pg_catalog.pg_tablespace_location(oid) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_tablespace_location(oid) is 'tablespace location'; + +create function pg_catalog.pg_tablespace_size(name) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_tablespace_size(name) is 'total disk space usage for the specified tablespace'; + +create function pg_catalog.pg_tablespace_size(oid) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_tablespace_size(oid) is 'total disk space usage for the specified tablespace'; + +create function pg_catalog.pg_terminate_backend(pid integer, timeout bigint default 0) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_terminate_backend(integer, bigint) is 'terminate a server process'; + +create function pg_catalog.pg_timezone_abbrevs(out abbrev text, out utc_offset interval, out is_dst boolean) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_timezone_abbrevs(out text, out interval, out boolean) is 'get the available time zone abbreviations'; + +create function pg_catalog.pg_timezone_names(out name text, out abbrev text, out utc_offset interval, out is_dst boolean) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_timezone_names(out text, out text, out interval, out boolean) is 'get the available time zone names'; + +create function pg_catalog.pg_total_relation_size(regclass) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_total_relation_size(regclass) is 'total disk space usage for the specified table and associated indexes'; + +create function pg_catalog.pg_trigger_depth() returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_trigger_depth() is 'current trigger depth'; + +create function pg_catalog.pg_try_advisory_lock(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_lock(bigint) is 'obtain exclusive advisory lock if available'; + +create function pg_catalog.pg_try_advisory_lock(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_lock(integer, integer) is 'obtain exclusive advisory lock if available'; + +create function pg_catalog.pg_try_advisory_lock_shared(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_lock_shared(bigint) is 'obtain shared advisory lock if available'; + +create function pg_catalog.pg_try_advisory_lock_shared(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_lock_shared(integer, integer) is 'obtain shared advisory lock if available'; + +create function pg_catalog.pg_try_advisory_xact_lock(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_xact_lock(bigint) is 'obtain exclusive advisory lock if available'; + +create function pg_catalog.pg_try_advisory_xact_lock(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_xact_lock(integer, integer) is 'obtain exclusive advisory lock if available'; + +create function pg_catalog.pg_try_advisory_xact_lock_shared(bigint) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_xact_lock_shared(bigint) is 'obtain shared advisory lock if available'; + +create function pg_catalog.pg_try_advisory_xact_lock_shared(integer, integer) returns boolean + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_try_advisory_xact_lock_shared(integer, integer) is 'obtain shared advisory lock if available'; + +create function pg_catalog.pg_ts_config_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ts_config_is_visible(oid) is 'is text search configuration visible in search path?'; + +create function pg_catalog.pg_ts_dict_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ts_dict_is_visible(oid) is 'is text search dictionary visible in search path?'; + +create function pg_catalog.pg_ts_parser_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ts_parser_is_visible(oid) is 'is text search parser visible in search path?'; + +create function pg_catalog.pg_ts_template_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_ts_template_is_visible(oid) is 'is text search template visible in search path?'; + +create function pg_catalog.pg_type_is_visible(oid) returns boolean + stable + strict + cost 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_type_is_visible(oid) is 'is type visible in search path?'; + +create function pg_catalog.pg_typeof("any") returns regtype + stable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_typeof("any") is 'type of the argument'; + +create function pg_catalog.pg_visible_in_snapshot(xid8, pg_snapshot) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_visible_in_snapshot(xid8, pg_snapshot) is 'is xid8 visible in snapshot?'; + +create function pg_catalog.pg_wal_lsn_diff(pg_lsn, pg_lsn) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_wal_lsn_diff(pg_lsn, pg_lsn) is 'difference in bytes, given two wal locations'; + +create function pg_catalog.pg_wal_replay_pause() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_wal_replay_pause() is 'pause wal replay'; + +create function pg_catalog.pg_wal_replay_resume() returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_wal_replay_resume() is 'resume wal replay, if it was paused'; + +create function pg_catalog.pg_walfile_name(pg_lsn) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_walfile_name(pg_lsn) is 'wal filename, given a wal location'; + +create function pg_catalog.pg_walfile_name_offset(lsn pg_lsn, out file_name text, out file_offset integer) returns record + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_walfile_name_offset(pg_lsn, out text, out integer) is 'wal filename and byte offset, given a wal location'; + +create function pg_catalog.pg_xact_commit_timestamp(xid) returns timestamp with time zone + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_xact_commit_timestamp(xid) is 'get commit timestamp of a transaction'; + +create function pg_catalog.pg_xact_commit_timestamp_origin(xid xid, out timestamp timestamp with time zone, out roident oid) returns record + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_xact_commit_timestamp_origin(xid, out timestamp with time zone, out oid) is 'get commit timestamp and replication origin of a transaction'; + +create function pg_catalog.pg_xact_status(xid8) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pg_xact_status(xid8) is 'commit status of transaction'; + +create function pg_catalog.phraseto_tsquery(regconfig, text) returns tsquery + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.phraseto_tsquery(regconfig, text) is 'transform to tsquery'; + +create function pg_catalog.phraseto_tsquery(text) returns tsquery + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.phraseto_tsquery(text) is 'transform to tsquery'; + +create function pg_catalog.pi() returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pi() is 'PI'; + +create function pg_catalog.plainto_tsquery(regconfig, text) returns tsquery + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.plainto_tsquery(regconfig, text) is 'transform to tsquery'; + +create function pg_catalog.plainto_tsquery(text) returns tsquery + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.plainto_tsquery(text) is 'transform to tsquery'; + +create function pg_catalog.plpgsql_call_handler() returns language_handler + language c + as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.plpgsql_inline_handler(internal) returns void + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.plpgsql_validator(oid) returns void + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +create function pg_catalog.point(box) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point(box) is 'center of'; + +create function pg_catalog.point(circle) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point(circle) is 'center of'; + +create function pg_catalog.point(double precision, double precision) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point(double precision, double precision) is 'convert x, y to point'; + +create function pg_catalog.point(lseg) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point(lseg) is 'center of'; + +create function pg_catalog.point(polygon) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point(polygon) is 'center of'; + +create function pg_catalog.point_above(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_above(point, point) is 'implementation of |>> operator'; + +create function pg_catalog.point_add(point, point) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_add(point, point) is 'implementation of + operator'; + +create function pg_catalog.point_below(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_below(point, point) is 'implementation of <<| operator'; + +create function pg_catalog.point_distance(point, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_distance(point, point) is 'implementation of <-> operator'; + +create function pg_catalog.point_div(point, point) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_div(point, point) is 'implementation of / operator'; + +create function pg_catalog.point_eq(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_eq(point, point) is 'implementation of ~= operator'; + +create function pg_catalog.point_horiz(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_horiz(point, point) is 'implementation of ?- operator'; + +create function pg_catalog.point_in(cstring) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_in(cstring) is 'I/O'; + +create function pg_catalog.point_left(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_left(point, point) is 'implementation of << operator'; + +create function pg_catalog.point_mul(point, point) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_mul(point, point) is 'implementation of * operator'; + +create function pg_catalog.point_ne(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_ne(point, point) is 'implementation of <> operator'; + +create function pg_catalog.point_out(point) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_out(point) is 'I/O'; + +create function pg_catalog.point_recv(internal) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_recv(internal) is 'I/O'; + +create function pg_catalog.point_right(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_right(point, point) is 'implementation of >> operator'; + +create function pg_catalog.point_send(point) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_send(point) is 'I/O'; + +create function pg_catalog.point_sub(point, point) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_sub(point, point) is 'implementation of - operator'; + +create function pg_catalog.point_vert(point, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.point_vert(point, point) is 'implementation of ?| operator'; + +create function pg_catalog.poly_above(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_above(polygon, polygon) is 'implementation of |>> operator'; + +create function pg_catalog.poly_below(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_below(polygon, polygon) is 'implementation of <<| operator'; + +create function pg_catalog.poly_center(polygon) returns point + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_center(polygon) is 'implementation of @@ operator'; + +create function pg_catalog.poly_contain(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_contain(polygon, polygon) is 'implementation of @> operator'; + +create function pg_catalog.poly_contain_pt(polygon, point) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_contain_pt(polygon, point) is 'implementation of @> operator'; + +create function pg_catalog.poly_contained(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_contained(polygon, polygon) is 'implementation of <@ operator'; + +create function pg_catalog.poly_distance(polygon, polygon) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_distance(polygon, polygon) is 'implementation of <-> operator'; + +create function pg_catalog.poly_in(cstring) returns polygon + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_in(cstring) is 'I/O'; + +create function pg_catalog.poly_left(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_left(polygon, polygon) is 'implementation of << operator'; + +create function pg_catalog.poly_npoints(polygon) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_npoints(polygon) is 'implementation of # operator'; + +create function pg_catalog.poly_out(polygon) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_out(polygon) is 'I/O'; + +create function pg_catalog.poly_overabove(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_overabove(polygon, polygon) is 'implementation of |&> operator'; + +create function pg_catalog.poly_overbelow(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_overbelow(polygon, polygon) is 'implementation of &<| operator'; + +create function pg_catalog.poly_overlap(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_overlap(polygon, polygon) is 'implementation of && operator'; + +create function pg_catalog.poly_overleft(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_overleft(polygon, polygon) is 'implementation of &< operator'; + +create function pg_catalog.poly_overright(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_overright(polygon, polygon) is 'implementation of &> operator'; + +create function pg_catalog.poly_recv(internal) returns polygon + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_recv(internal) is 'I/O'; + +create function pg_catalog.poly_right(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_right(polygon, polygon) is 'implementation of >> operator'; + +create function pg_catalog.poly_same(polygon, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_same(polygon, polygon) is 'implementation of ~= operator'; + +create function pg_catalog.poly_send(polygon) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.poly_send(polygon) is 'I/O'; + +create function pg_catalog.polygon(box) returns polygon + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.polygon(box) is 'convert box to polygon'; + +create function pg_catalog.polygon(circle) returns polygon + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.polygon(circle) is 'convert circle to 12-vertex polygon'; + +create function pg_catalog.polygon(integer, circle) returns polygon + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.polygon(integer, circle) is 'convert vertex count and circle to polygon'; + +create function pg_catalog.polygon(path) returns polygon + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.polygon(path) is 'convert path to polygon'; + +create function pg_catalog.popen(path) returns path + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.popen(path) is 'open path'; + +create function pg_catalog.position(bit, bit) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.position(bit, bit) is 'position of sub-bitstring'; + +create function pg_catalog.position(bytea, bytea) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.position(bytea, bytea) is 'position of substring'; + +create function pg_catalog.position(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.position(text, text) is 'position of substring'; + +create function pg_catalog.positionjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.positionjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity for position-comparison operators'; + +create function pg_catalog.positionsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.positionsel(internal, oid, internal, integer) is 'restriction selectivity for position-comparison operators'; + +create function pg_catalog.postgresql_fdw_validator(text[], oid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.postgresql_fdw_validator(text[], oid) is '(internal)'; + +create function pg_catalog.pow(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pow(double precision, double precision) is 'exponentiation'; + +create function pg_catalog.pow(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pow(numeric, numeric) is 'exponentiation'; + +create function pg_catalog.power(double precision, double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.power(double precision, double precision) is 'exponentiation'; + +create function pg_catalog.power(numeric, numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.power(numeric, numeric) is 'exponentiation'; + +create function pg_catalog.prefixjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prefixjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of exact prefix'; + +create function pg_catalog.prefixsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prefixsel(internal, oid, internal, integer) is 'restriction selectivity of exact prefix'; + +create function pg_catalog.prsd_end(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prsd_end(internal) is '(internal)'; + +create function pg_catalog.prsd_headline(internal, internal, tsquery) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prsd_headline(internal, internal, tsquery) is '(internal)'; + +create function pg_catalog.prsd_lextype(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prsd_lextype(internal) is '(internal)'; + +create function pg_catalog.prsd_nexttoken(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prsd_nexttoken(internal, internal, internal) is '(internal)'; + +create function pg_catalog.prsd_start(internal, integer) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.prsd_start(internal, integer) is '(internal)'; + +create function pg_catalog.pt_contained_circle(point, circle) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pt_contained_circle(point, circle) is 'implementation of <@ operator'; + +create function pg_catalog.pt_contained_poly(point, polygon) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.pt_contained_poly(point, polygon) is 'implementation of <@ operator'; + +create function pg_catalog.query_to_xml(query text, nulls boolean, tableforest boolean, targetns text) returns xml + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.query_to_xml(text, boolean, boolean, text) is 'map query result to XML'; + +create function pg_catalog.query_to_xml_and_xmlschema(query text, nulls boolean, tableforest boolean, targetns text) returns xml + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.query_to_xml_and_xmlschema(text, boolean, boolean, text) is 'map query result and structure to XML and XML Schema'; + +create function pg_catalog.query_to_xmlschema(query text, nulls boolean, tableforest boolean, targetns text) returns xml + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.query_to_xmlschema(text, boolean, boolean, text) is 'map query result structure to XML Schema'; + +create function pg_catalog.querytree(tsquery) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.querytree(tsquery) is 'show real useful query for GiST index'; + +create function pg_catalog.quote_ident(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.quote_ident(text) is 'quote an identifier for usage in a querystring'; + +create function pg_catalog.quote_literal(anyelement) returns text + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.quote_literal(anyelement) is 'quote a data value for usage in a querystring'; + +create function pg_catalog.quote_literal(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.quote_literal(text) is 'quote a literal for usage in a querystring'; + +create function pg_catalog.quote_nullable(anyelement) returns text + stable + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.quote_nullable(anyelement) is 'quote a possibly-null data value for usage in a querystring'; + +create function pg_catalog.quote_nullable(text) returns text + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.quote_nullable(text) is 'quote a possibly-null literal for usage in a querystring'; + +create function pg_catalog.radians(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.radians(double precision) is 'degrees to radians'; + +create function pg_catalog.radius(circle) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.radius(circle) is 'radius of circle'; + +create function pg_catalog.random() returns double precision + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.random() is 'random value'; + +create function pg_catalog.random_normal(mean double precision default 0, stddev double precision default 1) returns double precision + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.random_normal(double precision, double precision) is 'random value from normal distribution'; + +create function pg_catalog.range_adjacent(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_adjacent(anyrange, anyrange) is 'implementation of -|- operator'; + +create function pg_catalog.range_adjacent_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_adjacent_multirange(anyrange, anymultirange) is 'implementation of -|- operator'; + +create function pg_catalog.range_after(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_after(anyrange, anyrange) is 'implementation of >> operator'; + +create function pg_catalog.range_after_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_after_multirange(anyrange, anymultirange) is 'implementation of >> operator'; + +create function pg_catalog.range_agg_finalfn(internal, anyrange) returns anymultirange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_agg_finalfn(internal, anyrange) is 'aggregate final function'; + +create function pg_catalog.range_agg_transfn(internal, anyrange) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_agg_transfn(internal, anyrange) is 'aggregate transition function'; + +create function pg_catalog.range_before(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_before(anyrange, anyrange) is 'implementation of << operator'; + +create function pg_catalog.range_before_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_before_multirange(anyrange, anymultirange) is 'implementation of << operator'; + +create function pg_catalog.range_cmp(anyrange, anyrange) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_cmp(anyrange, anyrange) is 'less-equal-greater'; + +create function pg_catalog.range_contained_by(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_contained_by(anyrange, anyrange) is 'implementation of <@ operator'; + +create function pg_catalog.range_contained_by_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_contained_by_multirange(anyrange, anymultirange) is 'implementation of <@ operator'; + +create function pg_catalog.range_contains(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_contains(anyrange, anyrange) is 'implementation of @> operator'; + +create function pg_catalog.range_contains_elem(anyrange, anyelement) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_contains_elem(anyrange, anyelement) is 'implementation of @> operator'; + +create function pg_catalog.range_contains_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_contains_multirange(anyrange, anymultirange) is 'implementation of @> operator'; + +create function pg_catalog.range_eq(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_eq(anyrange, anyrange) is 'implementation of = operator'; + +create function pg_catalog.range_ge(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_ge(anyrange, anyrange) is 'implementation of >= operator'; + +create function pg_catalog.range_gist_consistent(internal, anyrange, smallint, oid, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gist_consistent(internal, anyrange, smallint, oid, internal) is 'GiST support'; + +create function pg_catalog.range_gist_penalty(internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gist_penalty(internal, internal, internal) is 'GiST support'; + +create function pg_catalog.range_gist_picksplit(internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gist_picksplit(internal, internal) is 'GiST support'; + +create function pg_catalog.range_gist_same(anyrange, anyrange, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gist_same(anyrange, anyrange, internal) is 'GiST support'; + +create function pg_catalog.range_gist_union(internal, internal) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gist_union(internal, internal) is 'GiST support'; + +create function pg_catalog.range_gt(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_gt(anyrange, anyrange) is 'implementation of > operator'; + +create function pg_catalog.range_in(cstring, oid, integer) returns anyrange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.range_intersect(anyrange, anyrange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_intersect(anyrange, anyrange) is 'implementation of * operator'; + +create function pg_catalog.range_intersect_agg_transfn(anyrange, anyrange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_intersect_agg_transfn(anyrange, anyrange) is 'range aggregate by intersecting'; + +create function pg_catalog.range_le(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_le(anyrange, anyrange) is 'implementation of <= operator'; + +create function pg_catalog.range_lt(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_lt(anyrange, anyrange) is 'implementation of < operator'; + +create function pg_catalog.range_merge(anymultirange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_merge(anymultirange) is 'the smallest range which includes the whole multirange'; + +create function pg_catalog.range_merge(anyrange, anyrange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_merge(anyrange, anyrange) is 'the smallest range which includes both of the given ranges'; + +create function pg_catalog.range_minus(anyrange, anyrange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_minus(anyrange, anyrange) is 'implementation of - operator'; + +create function pg_catalog.range_ne(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_ne(anyrange, anyrange) is 'implementation of <> operator'; + +create function pg_catalog.range_out(anyrange) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_out(anyrange) is 'I/O'; + +create function pg_catalog.range_overlaps(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overlaps(anyrange, anyrange) is 'implementation of && operator'; + +create function pg_catalog.range_overlaps_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overlaps_multirange(anyrange, anymultirange) is 'implementation of && operator'; + +create function pg_catalog.range_overleft(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overleft(anyrange, anyrange) is 'implementation of &< operator'; + +create function pg_catalog.range_overleft_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overleft_multirange(anyrange, anymultirange) is 'implementation of &< operator'; + +create function pg_catalog.range_overright(anyrange, anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overright(anyrange, anyrange) is 'implementation of &> operator'; + +create function pg_catalog.range_overright_multirange(anyrange, anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_overright_multirange(anyrange, anymultirange) is 'implementation of &> operator'; + +create function pg_catalog.range_recv(internal, oid, integer) returns anyrange + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.range_send(anyrange) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_send(anyrange) is 'I/O'; + +create function pg_catalog.range_typanalyze(internal) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_typanalyze(internal) is 'range typanalyze'; + +create function pg_catalog.range_union(anyrange, anyrange) returns anyrange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.range_union(anyrange, anyrange) is 'implementation of + operator'; + +create function pg_catalog.rangesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rangesel(internal, oid, internal, integer) is 'restriction selectivity for range operators'; + +create function pg_catalog.rank() returns bigint + immutable + window + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rank() is 'integer rank with gaps'; + +create function pg_catalog.rank_final(internal, "any") returns bigint + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rank_final(internal, "any") is 'aggregate final function'; + +create function pg_catalog.raw_array_subscript_handler(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.raw_array_subscript_handler(internal) is 'raw array subscripting support'; + +create function pg_catalog.record_eq(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_eq(record, record) is 'implementation of = operator'; + +create function pg_catalog.record_ge(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_ge(record, record) is 'implementation of >= operator'; + +create function pg_catalog.record_gt(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_gt(record, record) is 'implementation of > operator'; + +create function pg_catalog.record_image_eq(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_eq(record, record) is 'implementation of *= operator'; + +create function pg_catalog.record_image_ge(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_ge(record, record) is 'implementation of *>= operator'; + +create function pg_catalog.record_image_gt(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_gt(record, record) is 'implementation of *> operator'; + +create function pg_catalog.record_image_le(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_le(record, record) is 'implementation of *<= operator'; + +create function pg_catalog.record_image_lt(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_lt(record, record) is 'implementation of *< operator'; + +create function pg_catalog.record_image_ne(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_image_ne(record, record) is 'implementation of *<> operator'; + +create function pg_catalog.record_in(cstring, oid, integer) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.record_le(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_le(record, record) is 'implementation of <= operator'; + +create function pg_catalog.record_lt(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_lt(record, record) is 'implementation of < operator'; + +create function pg_catalog.record_ne(record, record) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_ne(record, record) is 'implementation of <> operator'; + +create function pg_catalog.record_out(record) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_out(record) is 'I/O'; + +create function pg_catalog.record_recv(internal, oid, integer) returns record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.record_send(record) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.record_send(record) is 'I/O'; + +create function pg_catalog.regclass(text) returns regclass + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regclass(text) is 'convert text to regclass'; + +create function pg_catalog.regclassin(cstring) returns regclass + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regclassin(cstring) is 'I/O'; + +create function pg_catalog.regclassout(regclass) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regclassout(regclass) is 'I/O'; + +create function pg_catalog.regclassrecv(internal) returns regclass + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regclassrecv(internal) is 'I/O'; + +create function pg_catalog.regclasssend(regclass) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regclasssend(regclass) is 'I/O'; + +create function pg_catalog.regcollationin(cstring) returns regcollation + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regcollationin(cstring) is 'I/O'; + +create function pg_catalog.regcollationout(regcollation) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regcollationout(regcollation) is 'I/O'; + +create function pg_catalog.regcollationrecv(internal) returns regcollation + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regcollationrecv(internal) is 'I/O'; + +create function pg_catalog.regcollationsend(regcollation) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regcollationsend(regcollation) is 'I/O'; + +create function pg_catalog.regconfigin(cstring) returns regconfig + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regconfigin(cstring) is 'I/O'; + +create function pg_catalog.regconfigout(regconfig) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regconfigout(regconfig) is 'I/O'; + +create function pg_catalog.regconfigrecv(internal) returns regconfig + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regconfigrecv(internal) is 'I/O'; + +create function pg_catalog.regconfigsend(regconfig) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regconfigsend(regconfig) is 'I/O'; + +create function pg_catalog.regdictionaryin(cstring) returns regdictionary + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regdictionaryin(cstring) is 'I/O'; + +create function pg_catalog.regdictionaryout(regdictionary) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regdictionaryout(regdictionary) is 'I/O'; + +create function pg_catalog.regdictionaryrecv(internal) returns regdictionary + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regdictionaryrecv(internal) is 'I/O'; + +create function pg_catalog.regdictionarysend(regdictionary) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regdictionarysend(regdictionary) is 'I/O'; + +create function pg_catalog.regexeqjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexeqjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of regex match'; + +create function pg_catalog.regexeqsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexeqsel(internal, oid, internal, integer) is 'restriction selectivity of regex match'; + +create function pg_catalog.regexnejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexnejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of regex non-match'; + +create function pg_catalog.regexnesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexnesel(internal, oid, internal, integer) is 'restriction selectivity of regex non-match'; + +create function pg_catalog.regexp_count(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_count(text, text) is 'count regexp matches'; + +create function pg_catalog.regexp_count(text, text, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_count(text, text, integer) is 'count regexp matches'; + +create function pg_catalog.regexp_count(text, text, integer, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_count(text, text, integer, text) is 'count regexp matches'; + +create function pg_catalog.regexp_instr(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text) is 'position of regexp match'; + +create function pg_catalog.regexp_instr(text, text, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text, integer) is 'position of regexp match'; + +create function pg_catalog.regexp_instr(text, text, integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text, integer, integer) is 'position of regexp match'; + +create function pg_catalog.regexp_instr(text, text, integer, integer, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text, integer, integer, integer) is 'position of regexp match'; + +create function pg_catalog.regexp_instr(text, text, integer, integer, integer, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text, integer, integer, integer, text) is 'position of regexp match'; + +create function pg_catalog.regexp_instr(text, text, integer, integer, integer, text, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_instr(text, text, integer, integer, integer, text, integer) is 'position of regexp match'; + +create function pg_catalog.regexp_like(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_like(text, text) is 'test for regexp match'; + +create function pg_catalog.regexp_like(text, text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_like(text, text, text) is 'test for regexp match'; + +create function pg_catalog.regexp_match(text, text) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_match(text, text) is 'find first match for regexp'; + +create function pg_catalog.regexp_match(text, text, text) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_match(text, text, text) is 'find first match for regexp'; + +create function pg_catalog.regexp_matches(text, text) returns setof text[] + immutable + strict + cost 1 + rows 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_matches(text, text) is 'find match(es) for regexp'; + +create function pg_catalog.regexp_matches(text, text, text) returns setof text[] + immutable + strict + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_matches(text, text, text) is 'find match(es) for regexp'; + +create function pg_catalog.regexp_replace(text, text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_replace(text, text, text) is 'replace text using regexp'; + +create function pg_catalog.regexp_replace(text, text, text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_replace(text, text, text, integer) is 'replace text using regexp'; + +create function pg_catalog.regexp_replace(text, text, text, integer, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_replace(text, text, text, integer, integer) is 'replace text using regexp'; + +create function pg_catalog.regexp_replace(text, text, text, integer, integer, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_replace(text, text, text, integer, integer, text) is 'replace text using regexp'; + +create function pg_catalog.regexp_replace(text, text, text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_replace(text, text, text, text) is 'replace text using regexp'; + +create function pg_catalog.regexp_split_to_array(text, text) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_split_to_array(text, text) is 'split string by pattern'; + +create function pg_catalog.regexp_split_to_array(text, text, text) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_split_to_array(text, text, text) is 'split string by pattern'; + +create function pg_catalog.regexp_split_to_table(text, text) returns setof text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_split_to_table(text, text) is 'split string by pattern'; + +create function pg_catalog.regexp_split_to_table(text, text, text) returns setof text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_split_to_table(text, text, text) is 'split string by pattern'; + +create function pg_catalog.regexp_substr(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_substr(text, text) is 'extract substring that matches regexp'; + +create function pg_catalog.regexp_substr(text, text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_substr(text, text, integer) is 'extract substring that matches regexp'; + +create function pg_catalog.regexp_substr(text, text, integer, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_substr(text, text, integer, integer) is 'extract substring that matches regexp'; + +create function pg_catalog.regexp_substr(text, text, integer, integer, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_substr(text, text, integer, integer, text) is 'extract substring that matches regexp'; + +create function pg_catalog.regexp_substr(text, text, integer, integer, text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regexp_substr(text, text, integer, integer, text, integer) is 'extract substring that matches regexp'; + +create function pg_catalog.regnamespacein(cstring) returns regnamespace + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regnamespacein(cstring) is 'I/O'; + +create function pg_catalog.regnamespaceout(regnamespace) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regnamespaceout(regnamespace) is 'I/O'; + +create function pg_catalog.regnamespacerecv(internal) returns regnamespace + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regnamespacerecv(internal) is 'I/O'; + +create function pg_catalog.regnamespacesend(regnamespace) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regnamespacesend(regnamespace) is 'I/O'; + +create function pg_catalog.regoperatorin(cstring) returns regoperator + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperatorin(cstring) is 'I/O'; + +create function pg_catalog.regoperatorout(regoperator) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperatorout(regoperator) is 'I/O'; + +create function pg_catalog.regoperatorrecv(internal) returns regoperator + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperatorrecv(internal) is 'I/O'; + +create function pg_catalog.regoperatorsend(regoperator) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperatorsend(regoperator) is 'I/O'; + +create function pg_catalog.regoperin(cstring) returns regoper + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperin(cstring) is 'I/O'; + +create function pg_catalog.regoperout(regoper) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperout(regoper) is 'I/O'; + +create function pg_catalog.regoperrecv(internal) returns regoper + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regoperrecv(internal) is 'I/O'; + +create function pg_catalog.regopersend(regoper) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regopersend(regoper) is 'I/O'; + +create function pg_catalog.regprocedurein(cstring) returns regprocedure + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocedurein(cstring) is 'I/O'; + +create function pg_catalog.regprocedureout(regprocedure) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocedureout(regprocedure) is 'I/O'; + +create function pg_catalog.regprocedurerecv(internal) returns regprocedure + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocedurerecv(internal) is 'I/O'; + +create function pg_catalog.regproceduresend(regprocedure) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regproceduresend(regprocedure) is 'I/O'; + +create function pg_catalog.regprocin(cstring) returns regproc + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocin(cstring) is 'I/O'; + +create function pg_catalog.regprocout(regproc) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocout(regproc) is 'I/O'; + +create function pg_catalog.regprocrecv(internal) returns regproc + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocrecv(internal) is 'I/O'; + +create function pg_catalog.regprocsend(regproc) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regprocsend(regproc) is 'I/O'; + +create function pg_catalog.regrolein(cstring) returns regrole + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regrolein(cstring) is 'I/O'; + +create function pg_catalog.regroleout(regrole) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regroleout(regrole) is 'I/O'; + +create function pg_catalog.regrolerecv(internal) returns regrole + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regrolerecv(internal) is 'I/O'; + +create function pg_catalog.regrolesend(regrole) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regrolesend(regrole) is 'I/O'; + +create function pg_catalog.regtypein(cstring) returns regtype + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regtypein(cstring) is 'I/O'; + +create function pg_catalog.regtypeout(regtype) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regtypeout(regtype) is 'I/O'; + +create function pg_catalog.regtyperecv(internal) returns regtype + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regtyperecv(internal) is 'I/O'; + +create function pg_catalog.regtypesend(regtype) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.regtypesend(regtype) is 'I/O'; + +create function pg_catalog.repeat(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.repeat(text, integer) is 'replicate string n times'; + +create function pg_catalog.replace(text, text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.replace(text, text, text) is 'replace all occurrences in string of old_substr with new_substr'; + +create function pg_catalog.reverse(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.reverse(text) is 'reverse text'; + +create function pg_catalog."right"(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."right"(text, integer) is 'extract the last n characters'; + +create function pg_catalog.round(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.round(double precision) is 'round to nearest integer'; + +create function pg_catalog.round(numeric) returns numeric + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.round(numeric) is 'value rounded to ''scale'' of zero'; + +create function pg_catalog.round(numeric, integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.round(numeric, integer) is 'value rounded to ''scale'''; + +create function pg_catalog.row_number() returns bigint + immutable + window + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.row_number() is 'row number within partition'; + +create function pg_catalog.row_security_active(oid) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.row_security_active(oid) is 'row security for current context active on table by table oid'; + +create function pg_catalog.row_security_active(text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.row_security_active(text) is 'row security for current context active on table by table name'; + +create function pg_catalog.row_to_json(record) returns json + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.row_to_json(record) is 'map row to json'; + +create function pg_catalog.row_to_json(record, boolean) returns json + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.row_to_json(record, boolean) is 'map row to json with optional pretty printing'; + +create function pg_catalog.rpad(text, integer) returns text + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rpad(text, integer) is 'right-pad string to length'; + +create function pg_catalog.rpad(text, integer, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rpad(text, integer, text) is 'right-pad string to length'; + +create function pg_catalog.rtrim(bytea, bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rtrim(bytea, bytea) is 'trim selected bytes from right end of string'; + +create function pg_catalog.rtrim(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rtrim(text) is 'trim spaces from right end of string'; + +create function pg_catalog.rtrim(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.rtrim(text, text) is 'trim selected characters from right end of string'; + +create function pg_catalog.satisfies_hash_partition(oid, integer, integer, "any") returns boolean + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.satisfies_hash_partition(oid, integer, integer, "any") is 'hash partition CHECK constraint'; + +create function pg_catalog.scalargejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalargejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of >= and related operators on scalar datatypes'; + +create function pg_catalog.scalargesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalargesel(internal, oid, internal, integer) is 'restriction selectivity of >= and related operators on scalar datatypes'; + +create function pg_catalog.scalargtjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalargtjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of > and related operators on scalar datatypes'; + +create function pg_catalog.scalargtsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalargtsel(internal, oid, internal, integer) is 'restriction selectivity of > and related operators on scalar datatypes'; + +create function pg_catalog.scalarlejoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalarlejoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of <= and related operators on scalar datatypes'; + +create function pg_catalog.scalarlesel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalarlesel(internal, oid, internal, integer) is 'restriction selectivity of <= and related operators on scalar datatypes'; + +create function pg_catalog.scalarltjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalarltjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of < and related operators on scalar datatypes'; + +create function pg_catalog.scalarltsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scalarltsel(internal, oid, internal, integer) is 'restriction selectivity of < and related operators on scalar datatypes'; + +create function pg_catalog.scale(numeric) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.scale(numeric) is 'number of decimal digits in the fractional part'; + +create function pg_catalog.schema_to_xml(schema name, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.schema_to_xml(name, boolean, boolean, text) is 'map schema contents to XML'; + +create function pg_catalog.schema_to_xml_and_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.schema_to_xml_and_xmlschema(name, boolean, boolean, text) is 'map schema contents and structure to XML and XML Schema'; + +create function pg_catalog.schema_to_xmlschema(schema name, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.schema_to_xmlschema(name, boolean, boolean, text) is 'map schema structure to XML Schema'; + +create function pg_catalog."session_user"() returns name + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog."session_user"() is 'session user name'; + +create function pg_catalog.set_bit(bit, integer, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_bit(bit, integer, integer) is 'set bit'; + +create function pg_catalog.set_bit(bytea, bigint, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_bit(bytea, bigint, integer) is 'set bit'; + +create function pg_catalog.set_byte(bytea, integer, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_byte(bytea, integer, integer) is 'set byte'; + +create function pg_catalog.set_config(text, text, boolean) returns text + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_config(text, text, boolean) is 'SET X as a function'; + +create function pg_catalog.set_masklen(cidr, integer) returns cidr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_masklen(cidr, integer) is 'change netmask of cidr'; + +create function pg_catalog.set_masklen(inet, integer) returns inet + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.set_masklen(inet, integer) is 'change netmask of inet'; + +create function pg_catalog.setseed(double precision) returns void + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.setseed(double precision) is 'set random seed'; + +create function pg_catalog.setval(regclass, bigint) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.setval(regclass, bigint) is 'set sequence value'; + +create function pg_catalog.setval(regclass, bigint, boolean) returns bigint + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.setval(regclass, bigint, boolean) is 'set sequence value and is_called status'; + +create function pg_catalog.setweight(tsvector, "char") returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.setweight(tsvector, "char") is 'set given weight for whole tsvector'; + +create function pg_catalog.setweight(tsvector, "char", text[]) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.setweight(tsvector, "char", text[]) is 'set given weight for given lexemes'; + +create function pg_catalog.sha224(bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sha224(bytea) is 'SHA-224 hash'; + +create function pg_catalog.sha256(bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sha256(bytea) is 'SHA-256 hash'; + +create function pg_catalog.sha384(bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sha384(bytea) is 'SHA-384 hash'; + +create function pg_catalog.sha512(bytea) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sha512(bytea) is 'SHA-512 hash'; + +create function pg_catalog.shell_in(cstring) returns void + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.shell_in(cstring) is 'I/O'; + +create function pg_catalog.shell_out(void) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.shell_out(void) is 'I/O'; + +create function pg_catalog.shift_jis_2004_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.shift_jis_2004_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for SHIFT_JIS_2004 to EUC_JIS_2004'; + +create function pg_catalog.shift_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.shift_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for SHIFT_JIS_2004 to UTF8'; + +create function pg_catalog.shobj_description(oid, name) returns text + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.shobj_description(oid, name) is 'get description for object id and shared catalog name'; + +create function pg_catalog.sign(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sign(double precision) is 'sign of value'; + +create function pg_catalog.sign(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sign(numeric) is 'sign of value'; + +create function pg_catalog.similar_escape(text, text) returns text + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.similar_escape(text, text) is 'convert SQL regexp pattern to POSIX style'; + +create function pg_catalog.similar_to_escape(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.similar_to_escape(text) is 'convert SQL regexp pattern to POSIX style'; + +create function pg_catalog.similar_to_escape(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.similar_to_escape(text, text) is 'convert SQL regexp pattern to POSIX style'; + +create function pg_catalog.sin(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sin(double precision) is 'sine'; + +create function pg_catalog.sind(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sind(double precision) is 'sine, degrees'; + +create function pg_catalog.sinh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sinh(double precision) is 'hyperbolic sine'; + +create function pg_catalog.sjis_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sjis_to_euc_jp(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for SJIS to EUC_JP'; + +create function pg_catalog.sjis_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sjis_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for SJIS to MULE_INTERNAL'; + +create function pg_catalog.sjis_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sjis_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for SJIS to UTF8'; + +create function pg_catalog.slope(point, point) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.slope(point, point) is 'slope between points'; + +create function pg_catalog.spg_bbox_quad_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_bbox_quad_config(internal, internal) is 'SP-GiST support for quad tree over 2-D types represented by their bounding boxes'; + +create function pg_catalog.spg_box_quad_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_box_quad_choose(internal, internal) is 'SP-GiST support for quad tree over box'; + +create function pg_catalog.spg_box_quad_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_box_quad_config(internal, internal) is 'SP-GiST support for quad tree over box'; + +create function pg_catalog.spg_box_quad_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_box_quad_inner_consistent(internal, internal) is 'SP-GiST support for quad tree over box'; + +create function pg_catalog.spg_box_quad_leaf_consistent(internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_box_quad_leaf_consistent(internal, internal) is 'SP-GiST support for quad tree over box'; + +create function pg_catalog.spg_box_quad_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_box_quad_picksplit(internal, internal) is 'SP-GiST support for quad tree over box'; + +create function pg_catalog.spg_kd_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_kd_choose(internal, internal) is 'SP-GiST support for k-d tree over point'; + +create function pg_catalog.spg_kd_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_kd_config(internal, internal) is 'SP-GiST support for k-d tree over point'; + +create function pg_catalog.spg_kd_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_kd_inner_consistent(internal, internal) is 'SP-GiST support for k-d tree over point'; + +create function pg_catalog.spg_kd_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_kd_picksplit(internal, internal) is 'SP-GiST support for k-d tree over point'; + +create function pg_catalog.spg_poly_quad_compress(polygon) returns box + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_poly_quad_compress(polygon) is 'SP-GiST support for quad tree over polygons'; + +create function pg_catalog.spg_quad_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_quad_choose(internal, internal) is 'SP-GiST support for quad tree over point'; + +create function pg_catalog.spg_quad_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_quad_config(internal, internal) is 'SP-GiST support for quad tree over point'; + +create function pg_catalog.spg_quad_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_quad_inner_consistent(internal, internal) is 'SP-GiST support for quad tree over point'; + +create function pg_catalog.spg_quad_leaf_consistent(internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_quad_leaf_consistent(internal, internal) is 'SP-GiST support for quad tree and k-d tree over point'; + +create function pg_catalog.spg_quad_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_quad_picksplit(internal, internal) is 'SP-GiST support for quad tree over point'; + +create function pg_catalog.spg_range_quad_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_range_quad_choose(internal, internal) is 'SP-GiST support for quad tree over range'; + +create function pg_catalog.spg_range_quad_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_range_quad_config(internal, internal) is 'SP-GiST support for quad tree over range'; + +create function pg_catalog.spg_range_quad_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_range_quad_inner_consistent(internal, internal) is 'SP-GiST support for quad tree over range'; + +create function pg_catalog.spg_range_quad_leaf_consistent(internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_range_quad_leaf_consistent(internal, internal) is 'SP-GiST support for quad tree over range'; + +create function pg_catalog.spg_range_quad_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_range_quad_picksplit(internal, internal) is 'SP-GiST support for quad tree over range'; + +create function pg_catalog.spg_text_choose(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_text_choose(internal, internal) is 'SP-GiST support for radix tree over text'; + +create function pg_catalog.spg_text_config(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_text_config(internal, internal) is 'SP-GiST support for radix tree over text'; + +create function pg_catalog.spg_text_inner_consistent(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_text_inner_consistent(internal, internal) is 'SP-GiST support for radix tree over text'; + +create function pg_catalog.spg_text_leaf_consistent(internal, internal) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_text_leaf_consistent(internal, internal) is 'SP-GiST support for radix tree over text'; + +create function pg_catalog.spg_text_picksplit(internal, internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spg_text_picksplit(internal, internal) is 'SP-GiST support for radix tree over text'; + +create function pg_catalog.spghandler(internal) returns index_am_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.spghandler(internal) is 'spgist index access method handler'; + +create function pg_catalog.split_part(text, text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.split_part(text, text, integer) is 'split string by field_sep and return field_num'; + +create function pg_catalog.sqrt(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sqrt(double precision) is 'square root'; + +create function pg_catalog.sqrt(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.sqrt(numeric) is 'square root'; + +create function pg_catalog.starts_with(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.starts_with(text, text) is 'implementation of ^@ operator'; + +create function pg_catalog.statement_timestamp() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.statement_timestamp() is 'current statement time'; + +create function pg_catalog.string_agg_combine(internal, internal) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_agg_combine(internal, internal) is 'aggregate combine function'; + +create function pg_catalog.string_agg_deserialize(bytea, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_agg_deserialize(bytea, internal) is 'aggregate deserial function'; + +create function pg_catalog.string_agg_finalfn(internal) returns text + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_agg_finalfn(internal) is 'aggregate final function'; + +create function pg_catalog.string_agg_serialize(internal) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_agg_serialize(internal) is 'aggregate serial function'; + +create function pg_catalog.string_agg_transfn(internal, text, text) returns internal + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_agg_transfn(internal, text, text) is 'aggregate transition function'; + +create function pg_catalog.string_to_array(text, text) returns text[] + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_to_array(text, text) is 'split delimited text'; + +create function pg_catalog.string_to_array(text, text, text) returns text[] + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_to_array(text, text, text) is 'split delimited text, with null string'; + +create function pg_catalog.string_to_table(text, text) returns setof text + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_to_table(text, text) is 'split delimited text'; + +create function pg_catalog.string_to_table(text, text, text) returns setof text + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.string_to_table(text, text, text) is 'split delimited text, with null string'; + +create function pg_catalog.strip(tsvector) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.strip(tsvector) is 'strip position information'; + +create function pg_catalog.strpos(text, text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.strpos(text, text) is 'position of substring'; + +create function pg_catalog.substr(bytea, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substr(bytea, integer) is 'extract portion of string'; + +create function pg_catalog.substr(bytea, integer, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substr(bytea, integer, integer) is 'extract portion of string'; + +create function pg_catalog.substr(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substr(text, integer) is 'extract portion of string'; + +create function pg_catalog.substr(text, integer, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substr(text, integer, integer) is 'extract portion of string'; + +create function pg_catalog.substring(bit, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(bit, integer) is 'extract portion of bitstring'; + +create function pg_catalog.substring(bit, integer, integer) returns bit + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(bit, integer, integer) is 'extract portion of bitstring'; + +create function pg_catalog.substring(bytea, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(bytea, integer) is 'extract portion of string'; + +create function pg_catalog.substring(bytea, integer, integer) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(bytea, integer, integer) is 'extract portion of string'; + +create function pg_catalog.substring(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(text, integer) is 'extract portion of string'; + +create function pg_catalog.substring(text, integer, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(text, integer, integer) is 'extract portion of string'; + +create function pg_catalog.substring(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(text, text) is 'extract text matching regular expression'; + +create function pg_catalog.substring(text, text, text) returns text + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.substring(text, text, text) is 'extract text matching SQL regular expression'; + +create function pg_catalog.suppress_redundant_updates_trigger() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.suppress_redundant_updates_trigger() is 'trigger to suppress updates when new and old records match'; + +create function pg_catalog.system(internal) returns tsm_handler + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.system(internal) is 'SYSTEM tablesample method handler'; + +create function pg_catalog.system_user() returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.system_user() is 'system user name'; + +create function pg_catalog.table_am_handler_in(cstring) returns table_am_handler + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.table_am_handler_in(cstring) is 'I/O'; + +create function pg_catalog.table_am_handler_out(table_am_handler) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.table_am_handler_out(table_am_handler) is 'I/O'; + +create function pg_catalog.table_to_xml(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.table_to_xml(regclass, boolean, boolean, text) is 'map table contents to XML'; + +create function pg_catalog.table_to_xml_and_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.table_to_xml_and_xmlschema(regclass, boolean, boolean, text) is 'map table contents and structure to XML and XML Schema'; + +create function pg_catalog.table_to_xmlschema(tbl regclass, nulls boolean, tableforest boolean, targetns text) returns xml + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.table_to_xmlschema(regclass, boolean, boolean, text) is 'map table structure to XML Schema'; + +create function pg_catalog.tan(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tan(double precision) is 'tangent'; + +create function pg_catalog.tand(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tand(double precision) is 'tangent, degrees'; + +create function pg_catalog.tanh(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tanh(double precision) is 'hyperbolic tangent'; + +create function pg_catalog.text("char") returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text("char") is 'convert char to text'; + +create function pg_catalog.text(boolean) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text(boolean) is 'convert boolean to text'; + +create function pg_catalog.text(char) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text(char) is 'convert char(n) to text'; + +create function pg_catalog.text(inet) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text(inet) is 'show all parts of inet/cidr value'; + +create function pg_catalog.text(name) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text(name) is 'convert name to text'; + +create function pg_catalog.text(xml) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text(xml) is 'serialize an XML value to a character string'; + +create function pg_catalog.text_ge(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_ge(text, text) is 'implementation of >= operator'; + +create function pg_catalog.text_gt(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_gt(text, text) is 'implementation of > operator'; + +create function pg_catalog.text_larger(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_larger(text, text) is 'larger of two'; + +create function pg_catalog.text_le(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_le(text, text) is 'implementation of <= operator'; + +create function pg_catalog.text_lt(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_lt(text, text) is 'implementation of < operator'; + +create function pg_catalog.text_pattern_ge(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_pattern_ge(text, text) is 'implementation of ~>=~ operator'; + +create function pg_catalog.text_pattern_gt(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_pattern_gt(text, text) is 'implementation of ~>~ operator'; + +create function pg_catalog.text_pattern_le(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_pattern_le(text, text) is 'implementation of ~<=~ operator'; + +create function pg_catalog.text_pattern_lt(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_pattern_lt(text, text) is 'implementation of ~<~ operator'; + +create function pg_catalog.text_smaller(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_smaller(text, text) is 'smaller of two'; + +create function pg_catalog.text_starts_with_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.text_starts_with_support(internal) is 'planner support for text_starts_with'; + +create function pg_catalog.textanycat(text, anynonarray) returns text + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textanycat(text, anynonarray) is 'implementation of || operator'; + +create function pg_catalog.textcat(text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textcat(text, text) is 'implementation of || operator'; + +create function pg_catalog.texteq(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texteq(text, text) is 'implementation of = operator'; + +create function pg_catalog.texteqname(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texteqname(text, name) is 'implementation of = operator'; + +create function pg_catalog.textgename(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textgename(text, name) is 'implementation of >= operator'; + +create function pg_catalog.textgtname(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textgtname(text, name) is 'implementation of > operator'; + +create function pg_catalog.texticlike(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticlike(text, text) is 'implementation of ~~* operator'; + +create function pg_catalog.texticlike_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticlike_support(internal) is 'planner support for texticlike'; + +create function pg_catalog.texticnlike(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticnlike(text, text) is 'implementation of !~~* operator'; + +create function pg_catalog.texticregexeq(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticregexeq(text, text) is 'implementation of ~* operator'; + +create function pg_catalog.texticregexeq_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticregexeq_support(internal) is 'planner support for texticregexeq'; + +create function pg_catalog.texticregexne(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.texticregexne(text, text) is 'implementation of !~* operator'; + +create function pg_catalog.textin(cstring) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textin(cstring) is 'I/O'; + +create function pg_catalog.textlen(text) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textlen(text) is 'length'; + +create function pg_catalog.textlename(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textlename(text, name) is 'implementation of <= operator'; + +create function pg_catalog.textlike(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textlike(text, text) is 'implementation of ~~ operator'; + +create function pg_catalog.textlike_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textlike_support(internal) is 'planner support for textlike'; + +create function pg_catalog.textltname(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textltname(text, name) is 'implementation of < operator'; + +create function pg_catalog.textne(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textne(text, text) is 'implementation of <> operator'; + +create function pg_catalog.textnename(text, name) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textnename(text, name) is 'implementation of <> operator'; + +create function pg_catalog.textnlike(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textnlike(text, text) is 'implementation of !~~ operator'; + +create function pg_catalog.textout(text) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textout(text) is 'I/O'; + +create function pg_catalog.textrecv(internal) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textrecv(internal) is 'I/O'; + +create function pg_catalog.textregexeq(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textregexeq(text, text) is 'implementation of ~ operator'; + +create function pg_catalog.textregexeq_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textregexeq_support(internal) is 'planner support for textregexeq'; + +create function pg_catalog.textregexne(text, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textregexne(text, text) is 'implementation of !~ operator'; + +create function pg_catalog.textsend(text) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.textsend(text) is 'I/O'; + +create function pg_catalog.thesaurus_init(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.thesaurus_init(internal) is '(internal)'; + +create function pg_catalog.thesaurus_lexize(internal, internal, internal, internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.thesaurus_lexize(internal, internal, internal, internal) is '(internal)'; + +create function pg_catalog.tideq(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tideq(tid, tid) is 'implementation of = operator'; + +create function pg_catalog.tidge(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidge(tid, tid) is 'implementation of >= operator'; + +create function pg_catalog.tidgt(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidgt(tid, tid) is 'implementation of > operator'; + +create function pg_catalog.tidin(cstring) returns tid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidin(cstring) is 'I/O'; + +create function pg_catalog.tidlarger(tid, tid) returns tid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidlarger(tid, tid) is 'larger of two'; + +create function pg_catalog.tidle(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidle(tid, tid) is 'implementation of <= operator'; + +create function pg_catalog.tidlt(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidlt(tid, tid) is 'implementation of < operator'; + +create function pg_catalog.tidne(tid, tid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidne(tid, tid) is 'implementation of <> operator'; + +create function pg_catalog.tidout(tid) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidout(tid) is 'I/O'; + +create function pg_catalog.tidrecv(internal) returns tid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidrecv(internal) is 'I/O'; + +create function pg_catalog.tidsend(tid) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidsend(tid) is 'I/O'; + +create function pg_catalog.tidsmaller(tid, tid) returns tid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tidsmaller(tid, tid) is 'smaller of two'; + +create function pg_catalog.time(interval) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time(interval) is 'convert interval to time'; + +create function pg_catalog.time(time with time zone) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time(time with time zone) is 'convert time with time zone to time'; + +create function pg_catalog.time(time, integer) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time(time, integer) is 'adjust time precision'; + +create function pg_catalog.time(timestamp with time zone) returns time + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time(timestamp with time zone) is 'convert timestamp with time zone to time'; + +create function pg_catalog.time(timestamp) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time(timestamp) is 'convert timestamp to time'; + +create function pg_catalog.time_cmp(time, time) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_cmp(time, time) is 'less-equal-greater'; + +create function pg_catalog.time_eq(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_eq(time, time) is 'implementation of = operator'; + +create function pg_catalog.time_ge(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_ge(time, time) is 'implementation of >= operator'; + +create function pg_catalog.time_gt(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_gt(time, time) is 'implementation of > operator'; + +create function pg_catalog.time_hash(time) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_hash(time) is 'hash'; + +create function pg_catalog.time_hash_extended(time, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_hash_extended(time, bigint) is 'hash'; + +create function pg_catalog.time_in(cstring, oid, integer) returns time + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.time_larger(time, time) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_larger(time, time) is 'larger of two'; + +create function pg_catalog.time_le(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_le(time, time) is 'implementation of <= operator'; + +create function pg_catalog.time_lt(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_lt(time, time) is 'implementation of < operator'; + +create function pg_catalog.time_mi_interval(time, interval) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_mi_interval(time, interval) is 'implementation of - operator'; + +create function pg_catalog.time_mi_time(time, time) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_mi_time(time, time) is 'implementation of - operator'; + +create function pg_catalog.time_ne(time, time) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_ne(time, time) is 'implementation of <> operator'; + +create function pg_catalog.time_out(time) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_out(time) is 'I/O'; + +create function pg_catalog.time_pl_interval(time, interval) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_pl_interval(time, interval) is 'implementation of + operator'; + +create function pg_catalog.time_recv(internal, oid, integer) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.time_send(time) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_send(time) is 'I/O'; + +create function pg_catalog.time_smaller(time, time) returns time + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_smaller(time, time) is 'smaller of two'; + +create function pg_catalog.time_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.time_support(internal) is 'planner support for time length coercion'; + +create function pg_catalog.timedate_pl(time, date) returns timestamp + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timedate_pl(time, date) is 'implementation of + operator'; + +create function pg_catalog.timeofday() returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timeofday() is 'current date and time - increments during transactions'; + +create function pg_catalog.timestamp(date) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp(date) is 'convert date to timestamp'; + +create function pg_catalog.timestamp(date, time) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp(date, time) is 'convert date and time to timestamp'; + +create function pg_catalog.timestamp(timestamp with time zone) returns timestamp + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp(timestamp with time zone) is 'convert timestamp with time zone to timestamp'; + +create function pg_catalog.timestamp(timestamp, integer) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp(timestamp, integer) is 'adjust timestamp precision'; + +create function pg_catalog.timestamp_cmp(timestamp, timestamp) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_cmp(timestamp, timestamp) is 'less-equal-greater'; + +create function pg_catalog.timestamp_cmp_date(timestamp, date) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_cmp_date(timestamp, date) is 'less-equal-greater'; + +create function pg_catalog.timestamp_cmp_timestamptz(timestamp, timestamp with time zone) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_cmp_timestamptz(timestamp, timestamp with time zone) is 'less-equal-greater'; + +create function pg_catalog.timestamp_eq(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_eq(timestamp, timestamp) is 'implementation of = operator'; + +create function pg_catalog.timestamp_eq_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_eq_date(timestamp, date) is 'implementation of = operator'; + +create function pg_catalog.timestamp_eq_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_eq_timestamptz(timestamp, timestamp with time zone) is 'implementation of = operator'; + +create function pg_catalog.timestamp_ge(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ge(timestamp, timestamp) is 'implementation of >= operator'; + +create function pg_catalog.timestamp_ge_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ge_date(timestamp, date) is 'implementation of >= operator'; + +create function pg_catalog.timestamp_ge_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ge_timestamptz(timestamp, timestamp with time zone) is 'implementation of >= operator'; + +create function pg_catalog.timestamp_gt(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_gt(timestamp, timestamp) is 'implementation of > operator'; + +create function pg_catalog.timestamp_gt_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_gt_date(timestamp, date) is 'implementation of > operator'; + +create function pg_catalog.timestamp_gt_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_gt_timestamptz(timestamp, timestamp with time zone) is 'implementation of > operator'; + +create function pg_catalog.timestamp_hash(timestamp) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_hash(timestamp) is 'hash'; + +create function pg_catalog.timestamp_hash_extended(timestamp, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_hash_extended(timestamp, bigint) is 'hash'; + +create function pg_catalog.timestamp_in(cstring, oid, integer) returns timestamp + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.timestamp_larger(timestamp, timestamp) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_larger(timestamp, timestamp) is 'larger of two'; + +create function pg_catalog.timestamp_le(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_le(timestamp, timestamp) is 'implementation of <= operator'; + +create function pg_catalog.timestamp_le_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_le_date(timestamp, date) is 'implementation of <= operator'; + +create function pg_catalog.timestamp_le_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_le_timestamptz(timestamp, timestamp with time zone) is 'implementation of <= operator'; + +create function pg_catalog.timestamp_lt(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_lt(timestamp, timestamp) is 'implementation of < operator'; + +create function pg_catalog.timestamp_lt_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_lt_date(timestamp, date) is 'implementation of < operator'; + +create function pg_catalog.timestamp_lt_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_lt_timestamptz(timestamp, timestamp with time zone) is 'implementation of < operator'; + +create function pg_catalog.timestamp_mi(timestamp, timestamp) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_mi(timestamp, timestamp) is 'implementation of - operator'; + +create function pg_catalog.timestamp_mi_interval(timestamp, interval) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_mi_interval(timestamp, interval) is 'implementation of - operator'; + +create function pg_catalog.timestamp_ne(timestamp, timestamp) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ne(timestamp, timestamp) is 'implementation of <> operator'; + +create function pg_catalog.timestamp_ne_date(timestamp, date) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ne_date(timestamp, date) is 'implementation of <> operator'; + +create function pg_catalog.timestamp_ne_timestamptz(timestamp, timestamp with time zone) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_ne_timestamptz(timestamp, timestamp with time zone) is 'implementation of <> operator'; + +create function pg_catalog.timestamp_out(timestamp) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_out(timestamp) is 'I/O'; + +create function pg_catalog.timestamp_pl_interval(timestamp, interval) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_pl_interval(timestamp, interval) is 'implementation of + operator'; + +create function pg_catalog.timestamp_recv(internal, oid, integer) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.timestamp_send(timestamp) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_send(timestamp) is 'I/O'; + +create function pg_catalog.timestamp_smaller(timestamp, timestamp) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_smaller(timestamp, timestamp) is 'smaller of two'; + +create function pg_catalog.timestamp_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_sortsupport(internal) is 'sort support'; + +create function pg_catalog.timestamp_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamp_support(internal) is 'planner support for timestamp length coercion'; + +create function pg_catalog.timestamptypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.timestamptypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.timestamptz(date) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz(date) is 'convert date to timestamp with time zone'; + +create function pg_catalog.timestamptz(date, time with time zone) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz(date, time with time zone) is 'convert date and time with time zone to timestamp with time zone'; + +create function pg_catalog.timestamptz(date, time) returns timestamp with time zone + stable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz(date, time) is 'convert date and time to timestamp with time zone'; + +create function pg_catalog.timestamptz(timestamp with time zone, integer) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz(timestamp with time zone, integer) is 'adjust timestamptz precision'; + +create function pg_catalog.timestamptz(timestamp) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz(timestamp) is 'convert timestamp to timestamp with time zone'; + +create function pg_catalog.timestamptz_cmp(timestamp with time zone, timestamp with time zone) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_cmp(timestamp with time zone, timestamp with time zone) is 'less-equal-greater'; + +create function pg_catalog.timestamptz_cmp_date(timestamp with time zone, date) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_cmp_date(timestamp with time zone, date) is 'less-equal-greater'; + +create function pg_catalog.timestamptz_cmp_timestamp(timestamp with time zone, timestamp) returns integer + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_cmp_timestamp(timestamp with time zone, timestamp) is 'less-equal-greater'; + +create function pg_catalog.timestamptz_eq(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_eq(timestamp with time zone, timestamp with time zone) is 'implementation of = operator'; + +create function pg_catalog.timestamptz_eq_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_eq_date(timestamp with time zone, date) is 'implementation of = operator'; + +create function pg_catalog.timestamptz_eq_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_eq_timestamp(timestamp with time zone, timestamp) is 'implementation of = operator'; + +create function pg_catalog.timestamptz_ge(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ge(timestamp with time zone, timestamp with time zone) is 'implementation of >= operator'; + +create function pg_catalog.timestamptz_ge_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ge_date(timestamp with time zone, date) is 'implementation of >= operator'; + +create function pg_catalog.timestamptz_ge_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ge_timestamp(timestamp with time zone, timestamp) is 'implementation of >= operator'; + +create function pg_catalog.timestamptz_gt(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_gt(timestamp with time zone, timestamp with time zone) is 'implementation of > operator'; + +create function pg_catalog.timestamptz_gt_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_gt_date(timestamp with time zone, date) is 'implementation of > operator'; + +create function pg_catalog.timestamptz_gt_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_gt_timestamp(timestamp with time zone, timestamp) is 'implementation of > operator'; + +create function pg_catalog.timestamptz_in(cstring, oid, integer) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.timestamptz_larger(timestamp with time zone, timestamp with time zone) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_larger(timestamp with time zone, timestamp with time zone) is 'larger of two'; + +create function pg_catalog.timestamptz_le(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_le(timestamp with time zone, timestamp with time zone) is 'implementation of <= operator'; + +create function pg_catalog.timestamptz_le_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_le_date(timestamp with time zone, date) is 'implementation of <= operator'; + +create function pg_catalog.timestamptz_le_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_le_timestamp(timestamp with time zone, timestamp) is 'implementation of <= operator'; + +create function pg_catalog.timestamptz_lt(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_lt(timestamp with time zone, timestamp with time zone) is 'implementation of < operator'; + +create function pg_catalog.timestamptz_lt_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_lt_date(timestamp with time zone, date) is 'implementation of < operator'; + +create function pg_catalog.timestamptz_lt_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_lt_timestamp(timestamp with time zone, timestamp) is 'implementation of < operator'; + +create function pg_catalog.timestamptz_mi(timestamp with time zone, timestamp with time zone) returns interval + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_mi(timestamp with time zone, timestamp with time zone) is 'implementation of - operator'; + +create function pg_catalog.timestamptz_mi_interval(timestamp with time zone, interval) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_mi_interval(timestamp with time zone, interval) is 'implementation of - operator'; + +create function pg_catalog.timestamptz_ne(timestamp with time zone, timestamp with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ne(timestamp with time zone, timestamp with time zone) is 'implementation of <> operator'; + +create function pg_catalog.timestamptz_ne_date(timestamp with time zone, date) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ne_date(timestamp with time zone, date) is 'implementation of <> operator'; + +create function pg_catalog.timestamptz_ne_timestamp(timestamp with time zone, timestamp) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_ne_timestamp(timestamp with time zone, timestamp) is 'implementation of <> operator'; + +create function pg_catalog.timestamptz_out(timestamp with time zone) returns cstring + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_out(timestamp with time zone) is 'I/O'; + +create function pg_catalog.timestamptz_pl_interval(timestamp with time zone, interval) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_pl_interval(timestamp with time zone, interval) is 'implementation of + operator'; + +create function pg_catalog.timestamptz_recv(internal, oid, integer) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.timestamptz_send(timestamp with time zone) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_send(timestamp with time zone) is 'I/O'; + +create function pg_catalog.timestamptz_smaller(timestamp with time zone, timestamp with time zone) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptz_smaller(timestamp with time zone, timestamp with time zone) is 'smaller of two'; + +create function pg_catalog.timestamptztypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptztypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.timestamptztypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timestamptztypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.timetypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.timetypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.timetz(time with time zone, integer) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz(time with time zone, integer) is 'adjust time with time zone precision'; + +create function pg_catalog.timetz(time) returns time with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz(time) is 'convert time to time with time zone'; + +create function pg_catalog.timetz(timestamp with time zone) returns time with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz(timestamp with time zone) is 'convert timestamp with time zone to time with time zone'; + +create function pg_catalog.timetz_cmp(time with time zone, time with time zone) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_cmp(time with time zone, time with time zone) is 'less-equal-greater'; + +create function pg_catalog.timetz_eq(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_eq(time with time zone, time with time zone) is 'implementation of = operator'; + +create function pg_catalog.timetz_ge(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_ge(time with time zone, time with time zone) is 'implementation of >= operator'; + +create function pg_catalog.timetz_gt(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_gt(time with time zone, time with time zone) is 'implementation of > operator'; + +create function pg_catalog.timetz_hash(time with time zone) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_hash(time with time zone) is 'hash'; + +create function pg_catalog.timetz_hash_extended(time with time zone, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_hash_extended(time with time zone, bigint) is 'hash'; + +create function pg_catalog.timetz_in(cstring, oid, integer) returns time with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.timetz_larger(time with time zone, time with time zone) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_larger(time with time zone, time with time zone) is 'larger of two'; + +create function pg_catalog.timetz_le(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_le(time with time zone, time with time zone) is 'implementation of <= operator'; + +create function pg_catalog.timetz_lt(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_lt(time with time zone, time with time zone) is 'implementation of < operator'; + +create function pg_catalog.timetz_mi_interval(time with time zone, interval) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_mi_interval(time with time zone, interval) is 'implementation of - operator'; + +create function pg_catalog.timetz_ne(time with time zone, time with time zone) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_ne(time with time zone, time with time zone) is 'implementation of <> operator'; + +create function pg_catalog.timetz_out(time with time zone) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_out(time with time zone) is 'I/O'; + +create function pg_catalog.timetz_pl_interval(time with time zone, interval) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_pl_interval(time with time zone, interval) is 'implementation of + operator'; + +create function pg_catalog.timetz_recv(internal, oid, integer) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.timetz_send(time with time zone) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_send(time with time zone) is 'I/O'; + +create function pg_catalog.timetz_smaller(time with time zone, time with time zone) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetz_smaller(time with time zone, time with time zone) is 'smaller of two'; + +create function pg_catalog.timetzdate_pl(time with time zone, date) returns timestamp with time zone + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetzdate_pl(time with time zone, date) is 'implementation of + operator'; + +create function pg_catalog.timetztypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetztypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.timetztypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timetztypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.timezone(interval, time with time zone) returns time with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(interval, time with time zone) is 'adjust time with time zone to new zone'; + +create function pg_catalog.timezone(interval, timestamp with time zone) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(interval, timestamp with time zone) is 'adjust timestamp to new time zone'; + +create function pg_catalog.timezone(interval, timestamp) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(interval, timestamp) is 'adjust timestamp to new time zone'; + +create function pg_catalog.timezone(text, time with time zone) returns time with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(text, time with time zone) is 'adjust time with time zone to new zone'; + +create function pg_catalog.timezone(text, timestamp with time zone) returns timestamp + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(text, timestamp with time zone) is 'adjust timestamp to new time zone'; + +create function pg_catalog.timezone(text, timestamp) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.timezone(text, timestamp) is 'adjust timestamp to new time zone'; + +create function pg_catalog.to_ascii(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_ascii(text) is 'encode text from DB encoding to ASCII text'; + +create function pg_catalog.to_ascii(text, integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_ascii(text, integer) is 'encode text from encoding to ASCII text'; + +create function pg_catalog.to_ascii(text, name) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_ascii(text, name) is 'encode text from encoding to ASCII text'; + +create function pg_catalog.to_char(bigint, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(bigint, text) is 'format int8 to text'; + +create function pg_catalog.to_char(double precision, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(double precision, text) is 'format float8 to text'; + +create function pg_catalog.to_char(integer, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(integer, text) is 'format int4 to text'; + +create function pg_catalog.to_char(interval, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(interval, text) is 'format interval to text'; + +create function pg_catalog.to_char(numeric, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(numeric, text) is 'format numeric to text'; + +create function pg_catalog.to_char(real, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(real, text) is 'format float4 to text'; + +create function pg_catalog.to_char(timestamp with time zone, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(timestamp with time zone, text) is 'format timestamp with time zone to text'; + +create function pg_catalog.to_char(timestamp, text) returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_char(timestamp, text) is 'format timestamp to text'; + +create function pg_catalog.to_date(text, text) returns date + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_date(text, text) is 'convert text to date'; + +create function pg_catalog.to_hex(bigint) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_hex(bigint) is 'convert int8 number to hex'; + +create function pg_catalog.to_hex(integer) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_hex(integer) is 'convert int4 number to hex'; + +create function pg_catalog.to_json(anyelement) returns json + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_json(anyelement) is 'map input to json'; + +create function pg_catalog.to_jsonb(anyelement) returns jsonb + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_jsonb(anyelement) is 'map input to jsonb'; + +create function pg_catalog.to_number(text, text) returns numeric + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_number(text, text) is 'convert text to numeric'; + +create function pg_catalog.to_regclass(text) returns regclass + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regclass(text) is 'convert classname to regclass'; + +create function pg_catalog.to_regcollation(text) returns regcollation + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regcollation(text) is 'convert classname to regcollation'; + +create function pg_catalog.to_regnamespace(text) returns regnamespace + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regnamespace(text) is 'convert namespace name to regnamespace'; + +create function pg_catalog.to_regoper(text) returns regoper + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regoper(text) is 'convert operator name to regoper'; + +create function pg_catalog.to_regoperator(text) returns regoperator + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regoperator(text) is 'convert operator name to regoperator'; + +create function pg_catalog.to_regproc(text) returns regproc + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regproc(text) is 'convert proname to regproc'; + +create function pg_catalog.to_regprocedure(text) returns regprocedure + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regprocedure(text) is 'convert proname to regprocedure'; + +create function pg_catalog.to_regrole(text) returns regrole + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regrole(text) is 'convert role name to regrole'; + +create function pg_catalog.to_regtype(text) returns regtype + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_regtype(text) is 'convert type name to regtype'; + +create function pg_catalog.to_timestamp(double precision) returns timestamp with time zone + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_timestamp(double precision) is 'convert UNIX epoch to timestamptz'; + +create function pg_catalog.to_timestamp(text, text) returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_timestamp(text, text) is 'convert text to timestamp with time zone'; + +create function pg_catalog.to_tsquery(regconfig, text) returns tsquery + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsquery(regconfig, text) is 'make tsquery'; + +create function pg_catalog.to_tsquery(text) returns tsquery + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsquery(text) is 'make tsquery'; + +create function pg_catalog.to_tsvector(json) returns tsvector + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(json) is 'transform string values from json to tsvector'; + +create function pg_catalog.to_tsvector(jsonb) returns tsvector + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(jsonb) is 'transform string values from jsonb to tsvector'; + +create function pg_catalog.to_tsvector(regconfig, json) returns tsvector + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(regconfig, json) is 'transform string values from json to tsvector'; + +create function pg_catalog.to_tsvector(regconfig, jsonb) returns tsvector + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(regconfig, jsonb) is 'transform string values from jsonb to tsvector'; + +create function pg_catalog.to_tsvector(regconfig, text) returns tsvector + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(regconfig, text) is 'transform to tsvector'; + +create function pg_catalog.to_tsvector(text) returns tsvector + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.to_tsvector(text) is 'transform to tsvector'; + +create function pg_catalog.transaction_timestamp() returns timestamp with time zone + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.transaction_timestamp() is 'current transaction time'; + +create function pg_catalog.translate(text, text, text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.translate(text, text, text) is 'map a set of characters appearing in string'; + +create function pg_catalog.trigger_in(cstring) returns trigger + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trigger_in(cstring) is 'I/O'; + +create function pg_catalog.trigger_out(trigger) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trigger_out(trigger) is 'I/O'; + +create function pg_catalog.trim_array(anyarray, integer) returns anyarray + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trim_array(anyarray, integer) is 'remove last N elements of array'; + +create function pg_catalog.trim_scale(numeric) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trim_scale(numeric) is 'numeric with minimum scale needed to represent the value'; + +create function pg_catalog.trunc(double precision) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trunc(double precision) is 'truncate to integer'; + +create function pg_catalog.trunc(macaddr) returns macaddr + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trunc(macaddr) is 'MACADDR manufacturer fields'; + +create function pg_catalog.trunc(macaddr8) returns macaddr8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trunc(macaddr8) is 'MACADDR8 manufacturer fields'; + +create function pg_catalog.trunc(numeric) returns numeric + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trunc(numeric) is 'value truncated to ''scale'' of zero'; + +create function pg_catalog.trunc(numeric, integer) returns numeric + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.trunc(numeric, integer) is 'value truncated to ''scale'''; + +create function pg_catalog.ts_debug(config regconfig, document text, out alias text, out description text, out token text, out dictionaries regdictionary[], out dictionary regdictionary, out lexemes text[]) returns setof record + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_debug(regconfig, text, out text, out text, out text, out regdictionary[], out regdictionary, out text[]) is 'debug function for text search configuration'; + +create function pg_catalog.ts_debug(document text, out alias text, out description text, out token text, out dictionaries regdictionary[], out dictionary regdictionary, out lexemes text[]) returns setof record + stable + strict + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_debug(text, out text, out text, out text, out regdictionary[], out regdictionary, out text[]) is 'debug function for current text search configuration'; + +create function pg_catalog.ts_delete(tsvector, text) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_delete(tsvector, text) is 'delete lexeme'; + +create function pg_catalog.ts_delete(tsvector, text[]) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_delete(tsvector, text[]) is 'delete given lexemes'; + +create function pg_catalog.ts_filter(tsvector, "char"[]) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_filter(tsvector, "char"[]) is 'delete lexemes that do not have one of the given weights'; + +create function pg_catalog.ts_headline(json, tsquery) returns json + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(json, tsquery) is 'generate headline from json'; + +create function pg_catalog.ts_headline(json, tsquery, text) returns json + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(json, tsquery, text) is 'generate headline from json'; + +create function pg_catalog.ts_headline(jsonb, tsquery) returns jsonb + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(jsonb, tsquery) is 'generate headline from jsonb'; + +create function pg_catalog.ts_headline(jsonb, tsquery, text) returns jsonb + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(jsonb, tsquery, text) is 'generate headline from jsonb'; + +create function pg_catalog.ts_headline(regconfig, json, tsquery) returns json + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, json, tsquery) is 'generate headline from json'; + +create function pg_catalog.ts_headline(regconfig, json, tsquery, text) returns json + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, json, tsquery, text) is 'generate headline from json'; + +create function pg_catalog.ts_headline(regconfig, jsonb, tsquery) returns jsonb + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, jsonb, tsquery) is 'generate headline from jsonb'; + +create function pg_catalog.ts_headline(regconfig, jsonb, tsquery, text) returns jsonb + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, jsonb, tsquery, text) is 'generate headline from jsonb'; + +create function pg_catalog.ts_headline(regconfig, text, tsquery) returns text + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, text, tsquery) is 'generate headline'; + +create function pg_catalog.ts_headline(regconfig, text, tsquery, text) returns text + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(regconfig, text, tsquery, text) is 'generate headline'; + +create function pg_catalog.ts_headline(text, tsquery) returns text + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(text, tsquery) is 'generate headline'; + +create function pg_catalog.ts_headline(text, tsquery, text) returns text + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_headline(text, tsquery, text) is 'generate headline'; + +create function pg_catalog.ts_lexize(regdictionary, text) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_lexize(regdictionary, text) is 'normalize one word by dictionary'; + +create function pg_catalog.ts_match_qv(tsquery, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_match_qv(tsquery, tsvector) is 'implementation of @@ operator'; + +create function pg_catalog.ts_match_tq(text, tsquery) returns boolean + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_match_tq(text, tsquery) is 'implementation of @@ operator'; + +create function pg_catalog.ts_match_tt(text, text) returns boolean + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_match_tt(text, text) is 'implementation of @@ operator'; + +create function pg_catalog.ts_match_vq(tsvector, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_match_vq(tsvector, tsquery) is 'implementation of @@ operator'; + +create function pg_catalog.ts_parse(parser_oid oid, txt text, out tokid integer, out token text) returns setof record + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_parse(oid, text, out integer, out text) is 'parse text to tokens'; + +create function pg_catalog.ts_parse(parser_name text, txt text, out tokid integer, out token text) returns setof record + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_parse(text, text, out integer, out text) is 'parse text to tokens'; + +create function pg_catalog.ts_rank(real[], tsvector, tsquery) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank(real[], tsvector, tsquery) is 'relevance'; + +create function pg_catalog.ts_rank(real[], tsvector, tsquery, integer) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank(real[], tsvector, tsquery, integer) is 'relevance'; + +create function pg_catalog.ts_rank(tsvector, tsquery) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank(tsvector, tsquery) is 'relevance'; + +create function pg_catalog.ts_rank(tsvector, tsquery, integer) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank(tsvector, tsquery, integer) is 'relevance'; + +create function pg_catalog.ts_rank_cd(real[], tsvector, tsquery) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank_cd(real[], tsvector, tsquery) is 'relevance'; + +create function pg_catalog.ts_rank_cd(real[], tsvector, tsquery, integer) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank_cd(real[], tsvector, tsquery, integer) is 'relevance'; + +create function pg_catalog.ts_rank_cd(tsvector, tsquery) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank_cd(tsvector, tsquery) is 'relevance'; + +create function pg_catalog.ts_rank_cd(tsvector, tsquery, integer) returns real + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rank_cd(tsvector, tsquery, integer) is 'relevance'; + +create function pg_catalog.ts_rewrite(tsquery, text) returns tsquery + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rewrite(tsquery, text) is 'rewrite tsquery'; + +create function pg_catalog.ts_rewrite(tsquery, tsquery, tsquery) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_rewrite(tsquery, tsquery, tsquery) is 'rewrite tsquery'; + +create function pg_catalog.ts_stat(query text, out word text, out ndoc integer, out nentry integer) returns setof record + strict + cost 10 + rows 10000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_stat(text, out text, out integer, out integer) is 'statistics of tsvector column'; + +create function pg_catalog.ts_stat(query text, weights text, out word text, out ndoc integer, out nentry integer) returns setof record + strict + cost 10 + rows 10000 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_stat(text, text, out text, out integer, out integer) is 'statistics of tsvector column'; + +create function pg_catalog.ts_token_type(parser_oid oid, out tokid integer, out alias text, out description text) returns setof record + immutable + strict + cost 1 + rows 16 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_token_type(oid, out integer, out text, out text) is 'get parser''s token types'; + +create function pg_catalog.ts_token_type(parser_name text, out tokid integer, out alias text, out description text) returns setof record + stable + strict + cost 1 + rows 16 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_token_type(text, out integer, out text, out text) is 'get parser''s token types'; + +create function pg_catalog.ts_typanalyze(internal) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.ts_typanalyze(internal) is 'tsvector typanalyze'; + +create function pg_catalog.tsm_handler_in(cstring) returns tsm_handler + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsm_handler_in(cstring) is 'I/O'; + +create function pg_catalog.tsm_handler_out(tsm_handler) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsm_handler_out(tsm_handler) is 'I/O'; + +create function pg_catalog.tsmatchjoinsel(internal, oid, internal, smallint, internal) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsmatchjoinsel(internal, oid, internal, smallint, internal) is 'join selectivity of tsvector @@ tsquery'; + +create function pg_catalog.tsmatchsel(internal, oid, internal, integer) returns double precision + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsmatchsel(internal, oid, internal, integer) is 'restriction selectivity of tsvector @@ tsquery'; + +create function pg_catalog.tsmultirange() returns tsmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsmultirange() is 'tsmultirange constructor'; + +create function pg_catalog.tsmultirange(tsrange) returns tsmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsmultirange(tsrange) is 'tsmultirange constructor'; + +create function pg_catalog.tsmultirange(tsrange[]) returns tsmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsmultirange(tsrange[]) is 'tsmultirange constructor'; + +create function pg_catalog.tsq_mcontained(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsq_mcontained(tsquery, tsquery) is 'implementation of <@ operator'; + +create function pg_catalog.tsq_mcontains(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsq_mcontains(tsquery, tsquery) is 'implementation of @> operator'; + +create function pg_catalog.tsquery_and(tsquery, tsquery) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_and(tsquery, tsquery) is 'implementation of && operator'; + +create function pg_catalog.tsquery_cmp(tsquery, tsquery) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_cmp(tsquery, tsquery) is 'less-equal-greater'; + +create function pg_catalog.tsquery_eq(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_eq(tsquery, tsquery) is 'implementation of = operator'; + +create function pg_catalog.tsquery_ge(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_ge(tsquery, tsquery) is 'implementation of >= operator'; + +create function pg_catalog.tsquery_gt(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_gt(tsquery, tsquery) is 'implementation of > operator'; + +create function pg_catalog.tsquery_le(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_le(tsquery, tsquery) is 'implementation of <= operator'; + +create function pg_catalog.tsquery_lt(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_lt(tsquery, tsquery) is 'implementation of < operator'; + +create function pg_catalog.tsquery_ne(tsquery, tsquery) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_ne(tsquery, tsquery) is 'implementation of <> operator'; + +create function pg_catalog.tsquery_not(tsquery) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_not(tsquery) is 'implementation of !! operator'; + +create function pg_catalog.tsquery_or(tsquery, tsquery) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_or(tsquery, tsquery) is 'implementation of || operator'; + +create function pg_catalog.tsquery_phrase(tsquery, tsquery) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_phrase(tsquery, tsquery) is 'implementation of <-> operator'; + +create function pg_catalog.tsquery_phrase(tsquery, tsquery, integer) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquery_phrase(tsquery, tsquery, integer) is 'phrase-concatenate with distance'; + +create function pg_catalog.tsqueryin(cstring) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsqueryin(cstring) is 'I/O'; + +create function pg_catalog.tsqueryout(tsquery) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsqueryout(tsquery) is 'I/O'; + +create function pg_catalog.tsqueryrecv(internal) returns tsquery + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsqueryrecv(internal) is 'I/O'; + +create function pg_catalog.tsquerysend(tsquery) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsquerysend(tsquery) is 'I/O'; + +create function pg_catalog.tsrange(timestamp, timestamp) returns tsrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsrange(timestamp, timestamp) is 'tsrange constructor'; + +create function pg_catalog.tsrange(timestamp, timestamp, text) returns tsrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsrange(timestamp, timestamp, text) is 'tsrange constructor'; + +create function pg_catalog.tsrange_subdiff(timestamp, timestamp) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsrange_subdiff(timestamp, timestamp) is 'float8 difference of two timestamp values'; + +create function pg_catalog.tstzmultirange() returns tstzmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzmultirange() is 'tstzmultirange constructor'; + +create function pg_catalog.tstzmultirange(tstzrange) returns tstzmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzmultirange(tstzrange) is 'tstzmultirange constructor'; + +create function pg_catalog.tstzmultirange(tstzrange[]) returns tstzmultirange + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzmultirange(tstzrange[]) is 'tstzmultirange constructor'; + +create function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone) returns tstzrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone) is 'tstzrange constructor'; + +create function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone, text) returns tstzrange + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzrange(timestamp with time zone, timestamp with time zone, text) is 'tstzrange constructor'; + +create function pg_catalog.tstzrange_subdiff(timestamp with time zone, timestamp with time zone) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tstzrange_subdiff(timestamp with time zone, timestamp with time zone) is 'float8 difference of two timestamp with time zone values'; + +create function pg_catalog.tsvector_cmp(tsvector, tsvector) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_cmp(tsvector, tsvector) is 'less-equal-greater'; + +create function pg_catalog.tsvector_concat(tsvector, tsvector) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_concat(tsvector, tsvector) is 'implementation of || operator'; + +create function pg_catalog.tsvector_eq(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_eq(tsvector, tsvector) is 'implementation of = operator'; + +create function pg_catalog.tsvector_ge(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_ge(tsvector, tsvector) is 'implementation of >= operator'; + +create function pg_catalog.tsvector_gt(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_gt(tsvector, tsvector) is 'implementation of > operator'; + +create function pg_catalog.tsvector_le(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_le(tsvector, tsvector) is 'implementation of <= operator'; + +create function pg_catalog.tsvector_lt(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_lt(tsvector, tsvector) is 'implementation of < operator'; + +create function pg_catalog.tsvector_ne(tsvector, tsvector) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_ne(tsvector, tsvector) is 'implementation of <> operator'; + +create function pg_catalog.tsvector_to_array(tsvector) returns text[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_to_array(tsvector) is 'convert tsvector to array of lexemes'; + +create function pg_catalog.tsvector_update_trigger() returns trigger + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_update_trigger() is 'trigger for automatic update of tsvector column'; + +create function pg_catalog.tsvector_update_trigger_column() returns trigger + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvector_update_trigger_column() is 'trigger for automatic update of tsvector column'; + +create function pg_catalog.tsvectorin(cstring) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvectorin(cstring) is 'I/O'; + +create function pg_catalog.tsvectorout(tsvector) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvectorout(tsvector) is 'I/O'; + +create function pg_catalog.tsvectorrecv(internal) returns tsvector + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvectorrecv(internal) is 'I/O'; + +create function pg_catalog.tsvectorsend(tsvector) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.tsvectorsend(tsvector) is 'I/O'; + +create function pg_catalog.txid_current() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_current() is 'get current transaction ID'; + +create function pg_catalog.txid_current_if_assigned() returns bigint + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_current_if_assigned() is 'get current transaction ID'; + +create function pg_catalog.txid_current_snapshot() returns txid_snapshot + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_current_snapshot() is 'get current snapshot'; + +create function pg_catalog.txid_snapshot_in(cstring) returns txid_snapshot + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_in(cstring) is 'I/O'; + +create function pg_catalog.txid_snapshot_out(txid_snapshot) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_out(txid_snapshot) is 'I/O'; + +create function pg_catalog.txid_snapshot_recv(internal) returns txid_snapshot + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_recv(internal) is 'I/O'; + +create function pg_catalog.txid_snapshot_send(txid_snapshot) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_send(txid_snapshot) is 'I/O'; + +create function pg_catalog.txid_snapshot_xip(txid_snapshot) returns setof bigint + immutable + strict + cost 1 + rows 50 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_xip(txid_snapshot) is 'get set of in-progress txids in snapshot'; + +create function pg_catalog.txid_snapshot_xmax(txid_snapshot) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_xmax(txid_snapshot) is 'get xmax of snapshot'; + +create function pg_catalog.txid_snapshot_xmin(txid_snapshot) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_snapshot_xmin(txid_snapshot) is 'get xmin of snapshot'; + +create function pg_catalog.txid_status(bigint) returns text + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_status(bigint) is 'commit status of transaction'; + +create function pg_catalog.txid_visible_in_snapshot(bigint, txid_snapshot) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.txid_visible_in_snapshot(bigint, txid_snapshot) is 'is txid visible in snapshot?'; + +create function pg_catalog.uhc_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uhc_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UHC to UTF8'; + +create function pg_catalog.unique_key_recheck() returns trigger + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unique_key_recheck() is 'deferred UNIQUE constraint check'; + +create function pg_catalog.unistr(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unistr(text) is 'unescape Unicode characters'; + +create function pg_catalog.unknownin(cstring) returns unknown + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unknownin(cstring) is 'I/O'; + +create function pg_catalog.unknownout(unknown) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unknownout(unknown) is 'I/O'; + +create function pg_catalog.unknownrecv(internal) returns unknown + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unknownrecv(internal) is 'I/O'; + +create function pg_catalog.unknownsend(unknown) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unknownsend(unknown) is 'I/O'; + +create function pg_catalog.unnest(anyarray) returns setof anyelement + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unnest(anyarray) is 'expand array to set of rows'; + +create function pg_catalog.unnest(anymultirange) returns setof anyrange + immutable + strict + cost 1 + rows 100 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unnest(anymultirange) is 'expand multirange to set of ranges'; + +create function pg_catalog.unnest(tsvector tsvector, out lexeme text, out positions smallint[], out weights text[]) returns setof record + immutable + strict + cost 1 + rows 10 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.unnest(tsvector, out text, out smallint[], out text[]) is 'expand tsvector to set of rows'; + +create function pg_catalog.upper(anymultirange) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper(anymultirange) is 'upper bound of multirange'; + +create function pg_catalog.upper(anyrange) returns anyelement + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper(anyrange) is 'upper bound of range'; + +create function pg_catalog.upper(text) returns text + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper(text) is 'uppercase'; + +create function pg_catalog.upper_inc(anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper_inc(anymultirange) is 'is the multirange''s upper bound inclusive?'; + +create function pg_catalog.upper_inc(anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper_inc(anyrange) is 'is the range''s upper bound inclusive?'; + +create function pg_catalog.upper_inf(anymultirange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper_inf(anymultirange) is 'is the multirange''s upper bound infinite?'; + +create function pg_catalog.upper_inf(anyrange) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.upper_inf(anyrange) is 'is the range''s upper bound infinite?'; + +create function pg_catalog.utf8_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_big5(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to BIG5'; + +create function pg_catalog.utf8_to_euc_cn(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_euc_cn(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to EUC_CN'; + +create function pg_catalog.utf8_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_euc_jis_2004(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to EUC_JIS_2004'; + +create function pg_catalog.utf8_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_euc_jp(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to EUC_JP'; + +create function pg_catalog.utf8_to_euc_kr(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_euc_kr(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to EUC_KR'; + +create function pg_catalog.utf8_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_euc_tw(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to EUC_TW'; + +create function pg_catalog.utf8_to_gb18030(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_gb18030(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to GB18030'; + +create function pg_catalog.utf8_to_gbk(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_gbk(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to GBK'; + +create function pg_catalog.utf8_to_iso8859(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_iso8859(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to ISO-8859 2-16'; + +create function pg_catalog.utf8_to_iso8859_1(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_iso8859_1(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to LATIN1'; + +create function pg_catalog.utf8_to_johab(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_johab(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to JOHAB'; + +create function pg_catalog.utf8_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_koi8r(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to KOI8R'; + +create function pg_catalog.utf8_to_koi8u(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_koi8u(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to KOI8U'; + +create function pg_catalog.utf8_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to SHIFT_JIS_2004'; + +create function pg_catalog.utf8_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_sjis(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to SJIS'; + +create function pg_catalog.utf8_to_uhc(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_uhc(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to UHC'; + +create function pg_catalog.utf8_to_win(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.utf8_to_win(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for UTF8 to WIN'; + +create function pg_catalog.uuid_cmp(uuid, uuid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_cmp(uuid, uuid) is 'less-equal-greater'; + +create function pg_catalog.uuid_eq(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_eq(uuid, uuid) is 'implementation of = operator'; + +create function pg_catalog.uuid_ge(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_ge(uuid, uuid) is 'implementation of >= operator'; + +create function pg_catalog.uuid_gt(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_gt(uuid, uuid) is 'implementation of > operator'; + +create function pg_catalog.uuid_hash(uuid) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_hash(uuid) is 'hash'; + +create function pg_catalog.uuid_hash_extended(uuid, bigint) returns bigint + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_hash_extended(uuid, bigint) is 'hash'; + +create function pg_catalog.uuid_in(cstring) returns uuid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_in(cstring) is 'I/O'; + +create function pg_catalog.uuid_le(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_le(uuid, uuid) is 'implementation of <= operator'; + +create function pg_catalog.uuid_lt(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_lt(uuid, uuid) is 'implementation of < operator'; + +create function pg_catalog.uuid_ne(uuid, uuid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_ne(uuid, uuid) is 'implementation of <> operator'; + +create function pg_catalog.uuid_out(uuid) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_out(uuid) is 'I/O'; + +create function pg_catalog.uuid_recv(internal) returns uuid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_recv(internal) is 'I/O'; + +create function pg_catalog.uuid_send(uuid) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_send(uuid) is 'I/O'; + +create function pg_catalog.uuid_sortsupport(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.uuid_sortsupport(internal) is 'sort support'; + +create function pg_catalog.varbit(bit varying, integer, boolean) returns bit varying + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit(bit varying, integer, boolean) is 'adjust varbit() to typmod length'; + +create function pg_catalog.varbit_in(cstring, oid, integer) returns bit varying + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit_in(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.varbit_out(bit varying) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit_out(bit varying) is 'I/O'; + +create function pg_catalog.varbit_recv(internal, oid, integer) returns bit varying + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit_recv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.varbit_send(bit varying) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit_send(bit varying) is 'I/O'; + +create function pg_catalog.varbit_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbit_support(internal) is 'planner support for varbit length coercion'; + +create function pg_catalog.varbitcmp(bit varying, bit varying) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitcmp(bit varying, bit varying) is 'less-equal-greater'; + +create function pg_catalog.varbiteq(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbiteq(bit varying, bit varying) is 'implementation of = operator'; + +create function pg_catalog.varbitge(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitge(bit varying, bit varying) is 'implementation of >= operator'; + +create function pg_catalog.varbitgt(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitgt(bit varying, bit varying) is 'implementation of > operator'; + +create function pg_catalog.varbitle(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitle(bit varying, bit varying) is 'implementation of <= operator'; + +create function pg_catalog.varbitlt(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitlt(bit varying, bit varying) is 'implementation of < operator'; + +create function pg_catalog.varbitne(bit varying, bit varying) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbitne(bit varying, bit varying) is 'implementation of <> operator'; + +create function pg_catalog.varbittypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbittypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.varbittypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varbittypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.varchar(name) returns varchar + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varchar(name) is 'convert name to varchar'; + +create function pg_catalog.varchar(varchar, integer, boolean) returns varchar + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varchar(varchar, integer, boolean) is 'adjust varchar() to typmod length'; + +create function pg_catalog.varchar_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varchar_support(internal) is 'planner support for varchar length coercion'; + +create function pg_catalog.varcharin(cstring, oid, integer) returns varchar + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varcharin(cstring, oid, integer) is 'I/O'; + +create function pg_catalog.varcharout(varchar) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varcharout(varchar) is 'I/O'; + +create function pg_catalog.varcharrecv(internal, oid, integer) returns varchar + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varcharrecv(internal, oid, integer) is 'I/O'; + +create function pg_catalog.varcharsend(varchar) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varcharsend(varchar) is 'I/O'; + +create function pg_catalog.varchartypmodin(cstring[]) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varchartypmodin(cstring[]) is 'I/O typmod'; + +create function pg_catalog.varchartypmodout(integer) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.varchartypmodout(integer) is 'I/O typmod'; + +create function pg_catalog.version() returns text + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.version() is 'PostgreSQL version string'; + +create function pg_catalog.void_in(cstring) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.void_in(cstring) is 'I/O'; + +create function pg_catalog.void_out(void) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.void_out(void) is 'I/O'; + +create function pg_catalog.void_recv(internal) returns void + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.void_recv(internal) is 'I/O'; + +create function pg_catalog.void_send(void) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.void_send(void) is 'I/O'; + +create function pg_catalog.websearch_to_tsquery(regconfig, text) returns tsquery + immutable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.websearch_to_tsquery(regconfig, text) is 'transform to tsquery'; + +create function pg_catalog.websearch_to_tsquery(text) returns tsquery + stable + strict + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.websearch_to_tsquery(text) is 'transform to tsquery'; + +create function pg_catalog.width(box) returns double precision + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.width(box) is 'box width'; + +create function pg_catalog.width_bucket(anycompatible, anycompatiblearray) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.width_bucket(anycompatible, anycompatiblearray) is 'bucket number of operand given a sorted array of bucket lower bounds'; + +create function pg_catalog.width_bucket(double precision, double precision, double precision, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.width_bucket(double precision, double precision, double precision, integer) is 'bucket number of operand in equal-width histogram'; + +create function pg_catalog.width_bucket(numeric, numeric, numeric, integer) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.width_bucket(numeric, numeric, numeric, integer) is 'bucket number of operand in equal-width histogram'; + +create function pg_catalog.win1250_to_latin2(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1250_to_latin2(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1250 to LATIN2'; + +create function pg_catalog.win1250_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1250_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1250 to MULE_INTERNAL'; + +create function pg_catalog.win1251_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1251_to_iso(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1251 to ISO-8859-5'; + +create function pg_catalog.win1251_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1251_to_koi8r(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1251 to KOI8R'; + +create function pg_catalog.win1251_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1251_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1251 to MULE_INTERNAL'; + +create function pg_catalog.win1251_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win1251_to_win866(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN1251 to WIN866'; + +create function pg_catalog.win866_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win866_to_iso(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN866 to ISO-8859-5'; + +create function pg_catalog.win866_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win866_to_koi8r(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN866 to KOI8R'; + +create function pg_catalog.win866_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win866_to_mic(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN866 to MULE_INTERNAL'; + +create function pg_catalog.win866_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win866_to_win1251(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN866 to WIN1251'; + +create function pg_catalog.win_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer + immutable + strict + language c +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.win_to_utf8(integer, integer, cstring, internal, integer, boolean) is 'internal conversion function for WIN to UTF8'; + +create function pg_catalog.window_cume_dist_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_cume_dist_support(internal) is 'planner support for cume_dist'; + +create function pg_catalog.window_dense_rank_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_dense_rank_support(internal) is 'planner support for dense_rank'; + +create function pg_catalog.window_ntile_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_ntile_support(internal) is 'planner support for ntile'; + +create function pg_catalog.window_percent_rank_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_percent_rank_support(internal) is 'planner support for percent_rank'; + +create function pg_catalog.window_rank_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_rank_support(internal) is 'planner support for rank'; + +create function pg_catalog.window_row_number_support(internal) returns internal + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.window_row_number_support(internal) is 'planner support for row_number'; + +create function pg_catalog.xid(xid8) returns xid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid(xid8) is 'convert xid8 to xid'; + +create function pg_catalog.xid8_larger(xid8, xid8) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8_larger(xid8, xid8) is 'larger of two'; + +create function pg_catalog.xid8_smaller(xid8, xid8) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8_smaller(xid8, xid8) is 'smaller of two'; + +create function pg_catalog.xid8cmp(xid8, xid8) returns integer + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8cmp(xid8, xid8) is 'less-equal-greater'; + +create function pg_catalog.xid8eq(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8eq(xid8, xid8) is 'implementation of = operator'; + +create function pg_catalog.xid8ge(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8ge(xid8, xid8) is 'implementation of >= operator'; + +create function pg_catalog.xid8gt(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8gt(xid8, xid8) is 'implementation of > operator'; + +create function pg_catalog.xid8in(cstring) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8in(cstring) is 'I/O'; + +create function pg_catalog.xid8le(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8le(xid8, xid8) is 'implementation of <= operator'; + +create function pg_catalog.xid8lt(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8lt(xid8, xid8) is 'implementation of < operator'; + +create function pg_catalog.xid8ne(xid8, xid8) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8ne(xid8, xid8) is 'implementation of <> operator'; + +create function pg_catalog.xid8out(xid8) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8out(xid8) is 'I/O'; + +create function pg_catalog.xid8recv(internal) returns xid8 + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8recv(internal) is 'I/O'; + +create function pg_catalog.xid8send(xid8) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xid8send(xid8) is 'I/O'; + +create function pg_catalog.xideq(xid, xid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xideq(xid, xid) is 'implementation of = operator'; + +create function pg_catalog.xideqint4(xid, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xideqint4(xid, integer) is 'implementation of = operator'; + +create function pg_catalog.xidin(cstring) returns xid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidin(cstring) is 'I/O'; + +create function pg_catalog.xidneq(xid, xid) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidneq(xid, xid) is 'implementation of <> operator'; + +create function pg_catalog.xidneqint4(xid, integer) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidneqint4(xid, integer) is 'implementation of <> operator'; + +create function pg_catalog.xidout(xid) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidout(xid) is 'I/O'; + +create function pg_catalog.xidrecv(internal) returns xid + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidrecv(internal) is 'I/O'; + +create function pg_catalog.xidsend(xid) returns bytea + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xidsend(xid) is 'I/O'; + +create function pg_catalog.xml(text) returns xml + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml(text) is 'perform a non-validating parse of a character string to produce an XML value'; + +create function pg_catalog.xml_in(cstring) returns xml + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_in(cstring) is 'I/O'; + +create function pg_catalog.xml_is_well_formed(text) returns boolean + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_is_well_formed(text) is 'determine if a string is well formed XML'; + +create function pg_catalog.xml_is_well_formed_content(text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_is_well_formed_content(text) is 'determine if a string is well formed XML content'; + +create function pg_catalog.xml_is_well_formed_document(text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_is_well_formed_document(text) is 'determine if a string is well formed XML document'; + +create function pg_catalog.xml_out(xml) returns cstring + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_out(xml) is 'I/O'; + +create function pg_catalog.xml_recv(internal) returns xml + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_recv(internal) is 'I/O'; + +create function pg_catalog.xml_send(xml) returns bytea + stable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xml_send(xml) is 'I/O'; + +create function pg_catalog.xmlcomment(text) returns xml + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xmlcomment(text) is 'generate XML comment'; + +create function pg_catalog.xmlconcat2(xml, xml) returns xml + immutable + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xmlconcat2(xml, xml) is 'aggregate transition function'; + +create function pg_catalog.xmlexists(text, xml) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xmlexists(text, xml) is 'test XML value against XPath expression'; + +create function pg_catalog.xmlvalidate(xml, text) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xmlvalidate(xml, text) is 'validate an XML value'; + +create function pg_catalog.xpath(text, xml) returns xml[] + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xpath(text, xml) is 'evaluate XPath expression'; + +create function pg_catalog.xpath(text, xml, text[]) returns xml[] + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xpath(text, xml, text[]) is 'evaluate XPath expression, with namespaces support'; + +create function pg_catalog.xpath_exists(text, xml) returns boolean + immutable + strict + cost 1 + language sql +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xpath_exists(text, xml) is 'test XML value against XPath expression'; + +create function pg_catalog.xpath_exists(text, xml, text[]) returns boolean + immutable + strict + cost 1 + language internal +as +$$ +begin +-- missing source code +end; +$$; + +comment on function pg_catalog.xpath_exists(text, xml, text[]) is 'test XML value against XPath expression, with namespace support'; + +create operator pg_catalog.!! (procedure = pg_catalog.tsquery_not, rightarg = tsquery); + +comment on operator pg_catalog.!!(none, tsquery) is 'NOT tsquery'; + +create operator pg_catalog.## (procedure = pg_catalog.close_ls, leftarg = line, rightarg = lseg); + +comment on operator pg_catalog.##(line, lseg) is 'closest point to A on B'; + +create operator pg_catalog.## (procedure = pg_catalog.close_sb, leftarg = lseg, rightarg = box); + +comment on operator pg_catalog.##(lseg, box) is 'closest point to A on B'; + +create operator pg_catalog.## (procedure = pg_catalog.close_lseg, leftarg = lseg, rightarg = lseg); + +comment on operator pg_catalog.##(lseg, lseg) is 'closest point to A on B'; + +create operator pg_catalog.## (procedure = pg_catalog.close_pb, leftarg = point, rightarg = box); + +comment on operator pg_catalog.##(point, box) is 'closest point to A on B'; + +create operator pg_catalog.## (procedure = pg_catalog.close_pl, leftarg = point, rightarg = line); + +comment on operator pg_catalog.##(point, line) is 'closest point to A on B'; + +create operator pg_catalog.## (procedure = pg_catalog.close_ps, leftarg = point, rightarg = lseg); + +comment on operator pg_catalog.##(point, lseg) is 'closest point to A on B'; + +create operator pg_catalog.# (procedure = pg_catalog.int8xor, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(bigint, bigint) is 'bitwise exclusive or'; + +create operator pg_catalog.# (procedure = pg_catalog.bitxor, leftarg = bit, rightarg = bit, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(bit, bit) is 'bitwise exclusive or'; + +create operator pg_catalog.# (procedure = pg_catalog.box_intersect, leftarg = box, rightarg = box); + +comment on operator pg_catalog.#(box, box) is 'box intersection'; + +create operator pg_catalog.# (procedure = pg_catalog.int4xor, leftarg = integer, rightarg = integer, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(integer, integer) is 'bitwise exclusive or'; + +create operator pg_catalog.# (procedure = pg_catalog.line_interpt, leftarg = line, rightarg = line, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(line, line) is 'intersection point'; + +create operator pg_catalog.# (procedure = pg_catalog.lseg_interpt, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(lseg, lseg) is 'intersection point'; + +create operator pg_catalog.# (procedure = pg_catalog.int2xor, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.#); + +comment on operator pg_catalog.#(smallint, smallint) is 'bitwise exclusive or'; + +create operator pg_catalog.# (procedure = pg_catalog.path_npoints, rightarg = path); + +comment on operator pg_catalog.#(none, path) is 'number of points'; + +create operator pg_catalog.# (procedure = pg_catalog.poly_npoints, rightarg = polygon); + +comment on operator pg_catalog.#(none, polygon) is 'number of points'; + +create operator pg_catalog.#- (procedure = pg_catalog.jsonb_delete_path, leftarg = jsonb, rightarg = text[]); + +comment on operator pg_catalog.#-(jsonb, text[]) is 'delete path'; + +create operator pg_catalog.#> (procedure = pg_catalog.json_extract_path, leftarg = json, rightarg = text[]); + +comment on operator pg_catalog.#>(json, text[]) is 'get value from json with path elements'; + +create operator pg_catalog.#> (procedure = pg_catalog.jsonb_extract_path, leftarg = jsonb, rightarg = text[]); + +comment on operator pg_catalog.#>(jsonb, text[]) is 'get value from jsonb with path elements'; + +create operator pg_catalog.#>> (procedure = pg_catalog.json_extract_path_text, leftarg = json, rightarg = text[]); + +comment on operator pg_catalog.#>>(json, text[]) is 'get value from json as text with path elements'; + +create operator pg_catalog.#>> (procedure = pg_catalog.jsonb_extract_path_text, leftarg = jsonb, rightarg = text[]); + +comment on operator pg_catalog.#>>(jsonb, text[]) is 'get value from jsonb as text with path elements'; + +create operator pg_catalog.% (procedure = pg_catalog.int8mod, leftarg = bigint, rightarg = bigint); + +comment on operator pg_catalog.%(bigint, bigint) is 'modulus'; + +create operator pg_catalog.% (procedure = pg_catalog.int4mod, leftarg = integer, rightarg = integer); + +comment on operator pg_catalog.%(integer, integer) is 'modulus'; + +create operator pg_catalog.% (procedure = pg_catalog.numeric_mod, leftarg = numeric, rightarg = numeric); + +comment on operator pg_catalog.%(numeric, numeric) is 'modulus'; + +create operator pg_catalog.% (procedure = pg_catalog.int2mod, leftarg = smallint, rightarg = smallint); + +comment on operator pg_catalog.%(smallint, smallint) is 'modulus'; + +create operator pg_catalog.&& (procedure = pg_catalog.arrayoverlap, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.&&, join = pg_catalog.arraycontjoinsel, restrict = pg_catalog.arraycontsel); + +comment on operator pg_catalog.&&(anyarray, anyarray) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.multirange_overlaps_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&&(anymultirange, anymultirange) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.multirange_overlaps_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&&(anymultirange, anyrange) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.range_overlaps_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&&(anyrange, anymultirange) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.range_overlaps, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.&&(anyrange, anyrange) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.box_overlap, leftarg = box, rightarg = box, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.&&(box, box) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.circle_overlap, leftarg = circle, rightarg = circle, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.&&(circle, circle) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.network_overlap, leftarg = inet, rightarg = inet, commutator = pg_catalog.&&, join = pg_catalog.networkjoinsel, restrict = pg_catalog.networksel); + +comment on operator pg_catalog.&&(inet, inet) is 'overlaps (is subnet or supernet)'; + +create operator pg_catalog.&& (procedure = pg_catalog.poly_overlap, leftarg = polygon, rightarg = polygon, commutator = pg_catalog.&&, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.&&(polygon, polygon) is 'overlaps'; + +create operator pg_catalog.&& (procedure = pg_catalog.tsquery_and, leftarg = tsquery, rightarg = tsquery); + +comment on operator pg_catalog.&&(tsquery, tsquery) is 'AND-concatenate'; + +create operator pg_catalog.& (procedure = pg_catalog.int8and, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.&); + +comment on operator pg_catalog.&(bigint, bigint) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.bitand, leftarg = bit, rightarg = bit, commutator = pg_catalog.&); + +comment on operator pg_catalog.&(bit, bit) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.inetand, leftarg = inet, rightarg = inet); + +comment on operator pg_catalog.&(inet, inet) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.int4and, leftarg = integer, rightarg = integer, commutator = pg_catalog.&); + +comment on operator pg_catalog.&(integer, integer) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.macaddr_and, leftarg = macaddr, rightarg = macaddr); + +comment on operator pg_catalog.&(macaddr, macaddr) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.macaddr8_and, leftarg = macaddr8, rightarg = macaddr8); + +comment on operator pg_catalog.&(macaddr8, macaddr8) is 'bitwise and'; + +create operator pg_catalog.& (procedure = pg_catalog.int2and, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.&); + +comment on operator pg_catalog.&(smallint, smallint) is 'bitwise and'; + +create operator pg_catalog.&< (procedure = pg_catalog.multirange_overleft_multirange, leftarg = anymultirange, rightarg = anymultirange, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&<(anymultirange, anymultirange) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.multirange_overleft_range, leftarg = anymultirange, rightarg = anyrange, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&<(anymultirange, anyrange) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.range_overleft_multirange, leftarg = anyrange, rightarg = anymultirange, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&<(anyrange, anymultirange) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.range_overleft, leftarg = anyrange, rightarg = anyrange, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.&<(anyrange, anyrange) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.box_overleft, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<(box, box) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.circle_overleft, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<(circle, circle) is 'overlaps or is left of'; + +create operator pg_catalog.&< (procedure = pg_catalog.poly_overleft, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<(polygon, polygon) is 'overlaps or is left of'; + +create operator pg_catalog.&<| (procedure = pg_catalog.box_overbelow, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<|(box, box) is 'overlaps or is below'; + +create operator pg_catalog.&<| (procedure = pg_catalog.circle_overbelow, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<|(circle, circle) is 'overlaps or is below'; + +create operator pg_catalog.&<| (procedure = pg_catalog.poly_overbelow, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&<|(polygon, polygon) is 'overlaps or is below'; + +create operator pg_catalog.&> (procedure = pg_catalog.multirange_overright_multirange, leftarg = anymultirange, rightarg = anymultirange, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&>(anymultirange, anymultirange) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.multirange_overright_range, leftarg = anymultirange, rightarg = anyrange, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&>(anymultirange, anyrange) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.range_overright_multirange, leftarg = anyrange, rightarg = anymultirange, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.&>(anyrange, anymultirange) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.range_overright, leftarg = anyrange, rightarg = anyrange, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.&>(anyrange, anyrange) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.box_overright, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&>(box, box) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.circle_overright, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&>(circle, circle) is 'overlaps or is right of'; + +create operator pg_catalog.&> (procedure = pg_catalog.poly_overright, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.&>(polygon, polygon) is 'overlaps or is right of'; + +create operator pg_catalog.* (procedure = pg_catalog.box_mul, leftarg = box, rightarg = point); + +comment on operator pg_catalog.*(box, point) is 'multiply box by point (scale)'; + +create operator pg_catalog.* (procedure = pg_catalog.circle_mul_pt, leftarg = circle, rightarg = point); + +comment on operator pg_catalog.*(circle, point) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.float8mul, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(double precision, double precision) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.mul_d_interval, leftarg = double precision, rightarg = interval, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(double precision, interval) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.flt8_mul_cash, leftarg = double precision, rightarg = money, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(double precision, money) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.float84mul, leftarg = double precision, rightarg = real, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(double precision, real) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int48mul, leftarg = integer, rightarg = bigint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(integer, bigint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int4mul, leftarg = integer, rightarg = integer, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(integer, integer) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int4_mul_cash, leftarg = integer, rightarg = money, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(integer, money) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int42mul, leftarg = integer, rightarg = smallint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(integer, smallint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.interval_mul, leftarg = interval, rightarg = double precision, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(interval, double precision) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.cash_mul_flt8, leftarg = money, rightarg = double precision, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(money, double precision) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.cash_mul_int4, leftarg = money, rightarg = integer, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(money, integer) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.cash_mul_flt4, leftarg = money, rightarg = real, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(money, real) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.cash_mul_int2, leftarg = money, rightarg = smallint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(money, smallint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.numeric_mul, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(numeric, numeric) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.path_mul_pt, leftarg = path, rightarg = point); + +comment on operator pg_catalog.*(path, point) is 'multiply (rotate/scale path)'; + +create operator pg_catalog.* (procedure = pg_catalog.point_mul, leftarg = point, rightarg = point, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(point, point) is 'multiply points (scale/rotate)'; + +create operator pg_catalog.* (procedure = pg_catalog.multirange_intersect, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(anymultirange, anymultirange) is 'multirange intersect'; + +create operator pg_catalog.* (procedure = pg_catalog.range_intersect, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(anyrange, anyrange) is 'range intersection'; + +create operator pg_catalog.* (procedure = pg_catalog.int8mul, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(bigint, bigint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int84mul, leftarg = bigint, rightarg = integer, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(bigint, integer) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int8_mul_cash, leftarg = bigint, rightarg = money, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(bigint, money) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int82mul, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(bigint, smallint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.cash_mul_int8, leftarg = money, rightarg = bigint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(money, bigint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.float48mul, leftarg = real, rightarg = double precision, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(real, double precision) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.flt4_mul_cash, leftarg = real, rightarg = money, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(real, money) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.float4mul, leftarg = real, rightarg = real, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(real, real) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int28mul, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(smallint, bigint) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int24mul, leftarg = smallint, rightarg = integer, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(smallint, integer) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int2_mul_cash, leftarg = smallint, rightarg = money, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(smallint, money) is 'multiply'; + +create operator pg_catalog.* (procedure = pg_catalog.int2mul, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.*); + +comment on operator pg_catalog.*(smallint, smallint) is 'multiply'; + +create operator pg_catalog.+ (procedure = pg_catalog.aclinsert, leftarg = aclitem[], rightarg = aclitem); + +comment on operator pg_catalog.+(aclitem[], aclitem) is 'add/update ACL item'; + +create operator pg_catalog.+ (procedure = pg_catalog.multirange_union, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(anymultirange, anymultirange) is 'multirange union'; + +create operator pg_catalog.+ (procedure = pg_catalog.range_union, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(anyrange, anyrange) is 'range union'; + +create operator pg_catalog.+ (procedure = pg_catalog.int8pl, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(bigint, bigint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int8pl_inet, leftarg = bigint, rightarg = inet, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(bigint, inet) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int84pl, leftarg = bigint, rightarg = integer, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(bigint, integer) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int82pl, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(bigint, smallint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.box_add, leftarg = box, rightarg = point); + +comment on operator pg_catalog.+(box, point) is 'add point to box (translate)'; + +create operator pg_catalog.+ (procedure = pg_catalog.circle_add_pt, leftarg = circle, rightarg = point); + +comment on operator pg_catalog.+(circle, point) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.integer_pl_date, leftarg = integer, rightarg = date, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(integer, date) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.date_pli, leftarg = date, rightarg = integer, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(date, integer) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.date_pl_interval, leftarg = date, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(date, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.datetimetz_pl, leftarg = date, rightarg = time with time zone, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(date, time with time zone) is 'convert date and time with time zone to timestamp with time zone'; + +create operator pg_catalog.+ (procedure = pg_catalog.datetime_pl, leftarg = date, rightarg = time, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(date, time) is 'convert date and time to timestamp'; + +create operator pg_catalog.+ (procedure = pg_catalog.float8pl, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(double precision, double precision) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.float84pl, leftarg = double precision, rightarg = real, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(double precision, real) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.inetpl, leftarg = inet, rightarg = bigint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(inet, bigint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int48pl, leftarg = integer, rightarg = bigint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(integer, bigint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int4pl, leftarg = integer, rightarg = integer, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(integer, integer) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int42pl, leftarg = integer, rightarg = smallint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(integer, smallint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl_date, leftarg = interval, rightarg = date, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, date) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl, leftarg = interval, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl_timetz, leftarg = interval, rightarg = time with time zone, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, time with time zone) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl_time, leftarg = interval, rightarg = time, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, time) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl_timestamptz, leftarg = interval, rightarg = timestamp with time zone, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, timestamp with time zone) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.interval_pl_timestamp, leftarg = interval, rightarg = timestamp, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(interval, timestamp) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.cash_pl, leftarg = money, rightarg = money, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(money, money) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.numeric_add, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(numeric, numeric) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.numeric_pl_pg_lsn, leftarg = numeric, rightarg = pg_lsn, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(numeric, pg_lsn) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.path_add, leftarg = path, rightarg = path, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(path, path) is 'concatenate'; + +create operator pg_catalog.+ (procedure = pg_catalog.path_add_pt, leftarg = path, rightarg = point); + +comment on operator pg_catalog.+(path, point) is 'add (translate path)'; + +create operator pg_catalog.+ (procedure = pg_catalog.pg_lsn_pli, leftarg = pg_lsn, rightarg = numeric, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(pg_lsn, numeric) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.point_add, leftarg = point, rightarg = point, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(point, point) is 'add points (translate)'; + +create operator pg_catalog.+ (procedure = pg_catalog.float48pl, leftarg = real, rightarg = double precision, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(real, double precision) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.float4pl, leftarg = real, rightarg = real, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(real, real) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int28pl, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(smallint, bigint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int24pl, leftarg = smallint, rightarg = integer, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(smallint, integer) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int2pl, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(smallint, smallint) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.timetzdate_pl, leftarg = time with time zone, rightarg = date, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(time with time zone, date) is 'convert time with time zone and date to timestamp with time zone'; + +create operator pg_catalog.+ (procedure = pg_catalog.timetz_pl_interval, leftarg = time with time zone, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(time with time zone, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.timedate_pl, leftarg = time, rightarg = date, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(time, date) is 'convert time and date to timestamp'; + +create operator pg_catalog.+ (procedure = pg_catalog.time_pl_interval, leftarg = time, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(time, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.timestamptz_pl_interval, leftarg = timestamp with time zone, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(timestamp with time zone, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.timestamp_pl_interval, leftarg = timestamp, rightarg = interval, commutator = pg_catalog.+); + +comment on operator pg_catalog.+(timestamp, interval) is 'add'; + +create operator pg_catalog.+ (procedure = pg_catalog.int8up, rightarg = bigint); + +comment on operator pg_catalog.+(none, bigint) is 'unary plus'; + +create operator pg_catalog.+ (procedure = pg_catalog.float8up, rightarg = double precision); + +comment on operator pg_catalog.+(none, double precision) is 'unary plus'; + +create operator pg_catalog.+ (procedure = pg_catalog.int4up, rightarg = integer); + +comment on operator pg_catalog.+(none, integer) is 'unary plus'; + +create operator pg_catalog.+ (procedure = pg_catalog.numeric_uplus, rightarg = numeric); + +comment on operator pg_catalog.+(none, numeric) is 'unary plus'; + +create operator pg_catalog.+ (procedure = pg_catalog.float4up, rightarg = real); + +comment on operator pg_catalog.+(none, real) is 'unary plus'; + +create operator pg_catalog.+ (procedure = pg_catalog.int2up, rightarg = smallint); + +comment on operator pg_catalog.+(none, smallint) is 'unary plus'; + +create operator pg_catalog.- (procedure = pg_catalog.aclremove, leftarg = aclitem[], rightarg = aclitem); + +comment on operator pg_catalog.-(aclitem[], aclitem) is 'remove ACL item'; + +create operator pg_catalog.- (procedure = pg_catalog.multirange_minus, leftarg = anymultirange, rightarg = anymultirange); + +comment on operator pg_catalog.-(anymultirange, anymultirange) is 'multirange minus'; + +create operator pg_catalog.- (procedure = pg_catalog.range_minus, leftarg = anyrange, rightarg = anyrange); + +comment on operator pg_catalog.-(anyrange, anyrange) is 'range difference'; + +create operator pg_catalog.- (procedure = pg_catalog.int8mi, leftarg = bigint, rightarg = bigint); + +comment on operator pg_catalog.-(bigint, bigint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int84mi, leftarg = bigint, rightarg = integer); + +comment on operator pg_catalog.-(bigint, integer) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int82mi, leftarg = bigint, rightarg = smallint); + +comment on operator pg_catalog.-(bigint, smallint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.box_sub, leftarg = box, rightarg = point); + +comment on operator pg_catalog.-(box, point) is 'subtract point from box (translate)'; + +create operator pg_catalog.- (procedure = pg_catalog.circle_sub_pt, leftarg = circle, rightarg = point); + +comment on operator pg_catalog.-(circle, point) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.date_mi, leftarg = date, rightarg = date); + +comment on operator pg_catalog.-(date, date) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.date_mii, leftarg = date, rightarg = integer); + +comment on operator pg_catalog.-(date, integer) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.date_mi_interval, leftarg = date, rightarg = interval); + +comment on operator pg_catalog.-(date, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.float8mi, leftarg = double precision, rightarg = double precision); + +comment on operator pg_catalog.-(double precision, double precision) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.float84mi, leftarg = double precision, rightarg = real); + +comment on operator pg_catalog.-(double precision, real) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.inetmi_int8, leftarg = inet, rightarg = bigint); + +comment on operator pg_catalog.-(inet, bigint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.inetmi, leftarg = inet, rightarg = inet); + +comment on operator pg_catalog.-(inet, inet) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int48mi, leftarg = integer, rightarg = bigint); + +comment on operator pg_catalog.-(integer, bigint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int4mi, leftarg = integer, rightarg = integer); + +comment on operator pg_catalog.-(integer, integer) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int42mi, leftarg = integer, rightarg = smallint); + +comment on operator pg_catalog.-(integer, smallint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.interval_mi, leftarg = interval, rightarg = interval); + +comment on operator pg_catalog.-(interval, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.jsonb_delete, leftarg = jsonb, rightarg = integer); + +comment on operator pg_catalog.-(jsonb, integer) is 'delete array element'; + +create operator pg_catalog.- (procedure = pg_catalog.jsonb_delete, leftarg = jsonb, rightarg = text); + +comment on operator pg_catalog.-(jsonb, text) is 'delete object field'; + +create operator pg_catalog.- (procedure = pg_catalog.jsonb_delete, leftarg = jsonb, rightarg = text[]); + +comment on operator pg_catalog.-(jsonb, text[]) is 'delete object fields'; + +create operator pg_catalog.- (procedure = pg_catalog.cash_mi, leftarg = money, rightarg = money); + +comment on operator pg_catalog.-(money, money) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.numeric_sub, leftarg = numeric, rightarg = numeric); + +comment on operator pg_catalog.-(numeric, numeric) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.path_sub_pt, leftarg = path, rightarg = point); + +comment on operator pg_catalog.-(path, point) is 'subtract (translate path)'; + +create operator pg_catalog.- (procedure = pg_catalog.pg_lsn_mii, leftarg = pg_lsn, rightarg = numeric); + +comment on operator pg_catalog.-(pg_lsn, numeric) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.pg_lsn_mi, leftarg = pg_lsn, rightarg = pg_lsn); + +comment on operator pg_catalog.-(pg_lsn, pg_lsn) is 'minus'; + +create operator pg_catalog.- (procedure = pg_catalog.point_sub, leftarg = point, rightarg = point); + +comment on operator pg_catalog.-(point, point) is 'subtract points (translate)'; + +create operator pg_catalog.- (procedure = pg_catalog.float48mi, leftarg = real, rightarg = double precision); + +comment on operator pg_catalog.-(real, double precision) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.float4mi, leftarg = real, rightarg = real); + +comment on operator pg_catalog.-(real, real) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int28mi, leftarg = smallint, rightarg = bigint); + +comment on operator pg_catalog.-(smallint, bigint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int24mi, leftarg = smallint, rightarg = integer); + +comment on operator pg_catalog.-(smallint, integer) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int2mi, leftarg = smallint, rightarg = smallint); + +comment on operator pg_catalog.-(smallint, smallint) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.timetz_mi_interval, leftarg = time with time zone, rightarg = interval); + +comment on operator pg_catalog.-(time with time zone, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.time_mi_interval, leftarg = time, rightarg = interval); + +comment on operator pg_catalog.-(time, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.time_mi_time, leftarg = time, rightarg = time); + +comment on operator pg_catalog.-(time, time) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.timestamptz_mi_interval, leftarg = timestamp with time zone, rightarg = interval); + +comment on operator pg_catalog.-(timestamp with time zone, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.timestamptz_mi, leftarg = timestamp with time zone, rightarg = timestamp with time zone); + +comment on operator pg_catalog.-(timestamp with time zone, timestamp with time zone) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.timestamp_mi_interval, leftarg = timestamp, rightarg = interval); + +comment on operator pg_catalog.-(timestamp, interval) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.timestamp_mi, leftarg = timestamp, rightarg = timestamp); + +comment on operator pg_catalog.-(timestamp, timestamp) is 'subtract'; + +create operator pg_catalog.- (procedure = pg_catalog.int8um, rightarg = bigint); + +comment on operator pg_catalog.-(none, bigint) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.float8um, rightarg = double precision); + +comment on operator pg_catalog.-(none, double precision) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.int4um, rightarg = integer); + +comment on operator pg_catalog.-(none, integer) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.interval_um, rightarg = interval); + +comment on operator pg_catalog.-(none, interval) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.numeric_uminus, rightarg = numeric); + +comment on operator pg_catalog.-(none, numeric) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.float4um, rightarg = real); + +comment on operator pg_catalog.-(none, real) is 'negate'; + +create operator pg_catalog.- (procedure = pg_catalog.int2um, rightarg = smallint); + +comment on operator pg_catalog.-(none, smallint) is 'negate'; + +create operator pg_catalog.-> (procedure = pg_catalog.json_array_element, leftarg = json, rightarg = integer); + +comment on operator pg_catalog.->(json, integer) is 'get json array element'; + +create operator pg_catalog.-> (procedure = pg_catalog.json_object_field, leftarg = json, rightarg = text); + +comment on operator pg_catalog.->(json, text) is 'get json object field'; + +create operator pg_catalog.-> (procedure = pg_catalog.jsonb_array_element, leftarg = jsonb, rightarg = integer); + +comment on operator pg_catalog.->(jsonb, integer) is 'get jsonb array element'; + +create operator pg_catalog.-> (procedure = pg_catalog.jsonb_object_field, leftarg = jsonb, rightarg = text); + +comment on operator pg_catalog.->(jsonb, text) is 'get jsonb object field'; + +create operator pg_catalog.->> (procedure = pg_catalog.json_array_element_text, leftarg = json, rightarg = integer); + +comment on operator pg_catalog.->>(json, integer) is 'get json array element as text'; + +create operator pg_catalog.->> (procedure = pg_catalog.json_object_field_text, leftarg = json, rightarg = text); + +comment on operator pg_catalog.->>(json, text) is 'get json object field as text'; + +create operator pg_catalog.->> (procedure = pg_catalog.jsonb_array_element_text, leftarg = jsonb, rightarg = integer); + +comment on operator pg_catalog.->>(jsonb, integer) is 'get jsonb array element as text'; + +create operator pg_catalog.->> (procedure = pg_catalog.jsonb_object_field_text, leftarg = jsonb, rightarg = text); + +comment on operator pg_catalog.->>(jsonb, text) is 'get jsonb object field as text'; + +create operator pg_catalog.-|- (procedure = pg_catalog.multirange_adjacent_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.-|-, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.-|-(anymultirange, anymultirange) is 'is adjacent to'; + +create operator pg_catalog.-|- (procedure = pg_catalog.multirange_adjacent_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.-|-, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.-|-(anymultirange, anyrange) is 'is adjacent to'; + +create operator pg_catalog.-|- (procedure = pg_catalog.range_adjacent_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.-|-, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.-|-(anyrange, anymultirange) is 'is adjacent to'; + +create operator pg_catalog.-|- (procedure = pg_catalog.range_adjacent, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.-|-, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.-|-(anyrange, anyrange) is 'is adjacent to'; + +create operator pg_catalog./ (procedure = pg_catalog.int8div, leftarg = bigint, rightarg = bigint); + +comment on operator pg_catalog./(bigint, bigint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int84div, leftarg = bigint, rightarg = integer); + +comment on operator pg_catalog./(bigint, integer) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int82div, leftarg = bigint, rightarg = smallint); + +comment on operator pg_catalog./(bigint, smallint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.box_div, leftarg = box, rightarg = point); + +comment on operator pg_catalog./(box, point) is 'divide box by point (scale)'; + +create operator pg_catalog./ (procedure = pg_catalog.circle_div_pt, leftarg = circle, rightarg = point); + +comment on operator pg_catalog./(circle, point) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.float8div, leftarg = double precision, rightarg = double precision); + +comment on operator pg_catalog./(double precision, double precision) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.float84div, leftarg = double precision, rightarg = real); + +comment on operator pg_catalog./(double precision, real) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int48div, leftarg = integer, rightarg = bigint); + +comment on operator pg_catalog./(integer, bigint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int4div, leftarg = integer, rightarg = integer); + +comment on operator pg_catalog./(integer, integer) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int42div, leftarg = integer, rightarg = smallint); + +comment on operator pg_catalog./(integer, smallint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.interval_div, leftarg = interval, rightarg = double precision); + +comment on operator pg_catalog./(interval, double precision) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_int8, leftarg = money, rightarg = bigint); + +comment on operator pg_catalog./(money, bigint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_flt8, leftarg = money, rightarg = double precision); + +comment on operator pg_catalog./(money, double precision) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_int4, leftarg = money, rightarg = integer); + +comment on operator pg_catalog./(money, integer) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_cash, leftarg = money, rightarg = money); + +comment on operator pg_catalog./(money, money) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_flt4, leftarg = money, rightarg = real); + +comment on operator pg_catalog./(money, real) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.cash_div_int2, leftarg = money, rightarg = smallint); + +comment on operator pg_catalog./(money, smallint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.numeric_div, leftarg = numeric, rightarg = numeric); + +comment on operator pg_catalog./(numeric, numeric) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.path_div_pt, leftarg = path, rightarg = point); + +comment on operator pg_catalog./(path, point) is 'divide (rotate/scale path)'; + +create operator pg_catalog./ (procedure = pg_catalog.point_div, leftarg = point, rightarg = point); + +comment on operator pg_catalog./(point, point) is 'divide points (scale/rotate)'; + +create operator pg_catalog./ (procedure = pg_catalog.float48div, leftarg = real, rightarg = double precision); + +comment on operator pg_catalog./(real, double precision) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.float4div, leftarg = real, rightarg = real); + +comment on operator pg_catalog./(real, real) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int28div, leftarg = smallint, rightarg = bigint); + +comment on operator pg_catalog./(smallint, bigint) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int24div, leftarg = smallint, rightarg = integer); + +comment on operator pg_catalog./(smallint, integer) is 'divide'; + +create operator pg_catalog./ (procedure = pg_catalog.int2div, leftarg = smallint, rightarg = smallint); + +comment on operator pg_catalog./(smallint, smallint) is 'divide'; + +create operator pg_catalog.<-> (procedure = pg_catalog.box_distance, leftarg = box, rightarg = box, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(box, box) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_bs, leftarg = box, rightarg = lseg, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(box, lseg) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_bp, leftarg = box, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(box, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.circle_distance, leftarg = circle, rightarg = circle, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(circle, circle) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_cpoint, leftarg = circle, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(circle, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_cpoly, leftarg = circle, rightarg = polygon, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(circle, polygon) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.line_distance, leftarg = line, rightarg = line, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(line, line) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_ls, leftarg = line, rightarg = lseg, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(line, lseg) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_lp, leftarg = line, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(line, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_sb, leftarg = lseg, rightarg = box, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(lseg, box) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_sl, leftarg = lseg, rightarg = line, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(lseg, line) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.lseg_distance, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(lseg, lseg) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_sp, leftarg = lseg, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(lseg, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.path_distance, leftarg = path, rightarg = path, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(path, path) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_pathp, leftarg = path, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(path, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_pb, leftarg = point, rightarg = box, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, box) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_pc, leftarg = point, rightarg = circle, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, circle) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_pl, leftarg = point, rightarg = line, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, line) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_ps, leftarg = point, rightarg = lseg, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, lseg) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_ppath, leftarg = point, rightarg = path, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, path) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.point_distance, leftarg = point, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_ppoly, leftarg = point, rightarg = polygon, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(point, polygon) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_polyc, leftarg = polygon, rightarg = circle, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(polygon, circle) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.dist_polyp, leftarg = polygon, rightarg = point, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(polygon, point) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.poly_distance, leftarg = polygon, rightarg = polygon, commutator = pg_catalog.<->); + +comment on operator pg_catalog.<->(polygon, polygon) is 'distance between'; + +create operator pg_catalog.<-> (procedure = pg_catalog.tsquery_phrase, leftarg = tsquery, rightarg = tsquery); + +comment on operator pg_catalog.<->(tsquery, tsquery) is 'phrase-concatenate'; + +create operator pg_catalog.<< (procedure = pg_catalog.int8shl, leftarg = bigint, rightarg = integer); + +comment on operator pg_catalog.<<(bigint, integer) is 'bitwise shift left'; + +create operator pg_catalog.<< (procedure = pg_catalog.bitshiftleft, leftarg = bit, rightarg = integer); + +comment on operator pg_catalog.<<(bit, integer) is 'bitwise shift left'; + +create operator pg_catalog.<< (procedure = pg_catalog.box_left, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<(box, box) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.circle_left, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<(circle, circle) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.int4shl, leftarg = integer, rightarg = integer); + +comment on operator pg_catalog.<<(integer, integer) is 'bitwise shift left'; + +create operator pg_catalog.<< (procedure = pg_catalog.point_left, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<(point, point) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.poly_left, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<(polygon, polygon) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.int2shl, leftarg = smallint, rightarg = integer); + +comment on operator pg_catalog.<<(smallint, integer) is 'bitwise shift left'; + +create operator pg_catalog.<<| (procedure = pg_catalog.box_below, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<|(box, box) is 'is below'; + +create operator pg_catalog.<<| (procedure = pg_catalog.circle_below, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<|(circle, circle) is 'is below'; + +create operator pg_catalog.<<| (procedure = pg_catalog.point_below, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<|(point, point) is 'is below'; + +create operator pg_catalog.<<| (procedure = pg_catalog.poly_below, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<<|(polygon, polygon) is 'is below'; + +create operator pg_catalog.<@ (procedure = pg_catalog.on_sb, leftarg = lseg, rightarg = box); + +comment on operator pg_catalog.<@(lseg, box) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.on_sl, leftarg = lseg, rightarg = line); + +comment on operator pg_catalog.<@(lseg, line) is 'lseg on line'; + +create operator pg_catalog.<@ (procedure = pg_catalog.on_pl, leftarg = point, rightarg = line); + +comment on operator pg_catalog.<@(point, line) is 'point on line'; + +create operator pg_catalog.<@ (procedure = pg_catalog.on_ps, leftarg = point, rightarg = lseg); + +comment on operator pg_catalog.<@(point, lseg) is 'is contained by'; + +create operator pg_catalog.<^ (procedure = pg_catalog.box_below_eq, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<^(box, box) is 'is below (allows touching)'; + +create operator pg_catalog.<^ (procedure = pg_catalog.point_below, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.<^(point, point) is 'deprecated, use <<| instead'; + +create operator pg_catalog.>> (procedure = pg_catalog.int8shr, leftarg = bigint, rightarg = integer); + +comment on operator pg_catalog.>>(bigint, integer) is 'bitwise shift right'; + +create operator pg_catalog.>> (procedure = pg_catalog.bitshiftright, leftarg = bit, rightarg = integer); + +comment on operator pg_catalog.>>(bit, integer) is 'bitwise shift right'; + +create operator pg_catalog.>> (procedure = pg_catalog.box_right, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>>(box, box) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.circle_right, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>>(circle, circle) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.int4shr, leftarg = integer, rightarg = integer); + +comment on operator pg_catalog.>>(integer, integer) is 'bitwise shift right'; + +create operator pg_catalog.>> (procedure = pg_catalog.point_right, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>>(point, point) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.poly_right, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>>(polygon, polygon) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.int2shr, leftarg = smallint, rightarg = integer); + +comment on operator pg_catalog.>>(smallint, integer) is 'bitwise shift right'; + +create operator pg_catalog.>^ (procedure = pg_catalog.box_above_eq, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>^(box, box) is 'is above (allows touching)'; + +create operator pg_catalog.>^ (procedure = pg_catalog.point_above, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.>^(point, point) is 'deprecated, use |>> instead'; + +create operator pg_catalog.?# (procedure = pg_catalog.box_overlap, leftarg = box, rightarg = box, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.?#(box, box) is 'deprecated, use && instead'; + +create operator pg_catalog.?# (procedure = pg_catalog.inter_lb, leftarg = line, rightarg = box); + +comment on operator pg_catalog.?#(line, box) is 'intersect'; + +create operator pg_catalog.?# (procedure = pg_catalog.line_intersect, leftarg = line, rightarg = line, commutator = pg_catalog.?#); + +comment on operator pg_catalog.?#(line, line) is 'intersect'; + +create operator pg_catalog.?# (procedure = pg_catalog.inter_sb, leftarg = lseg, rightarg = box); + +comment on operator pg_catalog.?#(lseg, box) is 'intersect'; + +create operator pg_catalog.?# (procedure = pg_catalog.inter_sl, leftarg = lseg, rightarg = line); + +comment on operator pg_catalog.?#(lseg, line) is 'intersect'; + +create operator pg_catalog.?# (procedure = pg_catalog.lseg_intersect, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.?#); + +comment on operator pg_catalog.?#(lseg, lseg) is 'intersect'; + +create operator pg_catalog.?# (procedure = pg_catalog.path_inter, leftarg = path, rightarg = path); + +comment on operator pg_catalog.?#(path, path) is 'intersect'; + +create operator pg_catalog.?& (procedure = pg_catalog.jsonb_exists_all, leftarg = jsonb, rightarg = text[], join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.?&(jsonb, text[]) is 'all keys exist'; + +create operator pg_catalog.? (procedure = pg_catalog.jsonb_exists, leftarg = jsonb, rightarg = text, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.?(jsonb, text) is 'key exists'; + +create operator pg_catalog.?- (procedure = pg_catalog.point_horiz, leftarg = point, rightarg = point, commutator = pg_catalog.?-); + +comment on operator pg_catalog.?-(point, point) is 'horizontally aligned'; + +create operator pg_catalog.?- (procedure = pg_catalog.line_horizontal, rightarg = line); + +comment on operator pg_catalog.?-(none, line) is 'horizontal'; + +create operator pg_catalog.?- (procedure = pg_catalog.lseg_horizontal, rightarg = lseg); + +comment on operator pg_catalog.?-(none, lseg) is 'horizontal'; + +create operator pg_catalog.?-| (procedure = pg_catalog.line_perp, leftarg = line, rightarg = line, commutator = pg_catalog.?-|); + +comment on operator pg_catalog.?-|(line, line) is 'perpendicular'; + +create operator pg_catalog.?-| (procedure = pg_catalog.lseg_perp, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.?-|); + +comment on operator pg_catalog.?-|(lseg, lseg) is 'perpendicular'; + +create operator pg_catalog.?| (procedure = pg_catalog.jsonb_exists_any, leftarg = jsonb, rightarg = text[], join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.?|(jsonb, text[]) is 'any key exists'; + +create operator pg_catalog.?| (procedure = pg_catalog.point_vert, leftarg = point, rightarg = point, commutator = pg_catalog.?|); + +comment on operator pg_catalog.?|(point, point) is 'vertically aligned'; + +create operator pg_catalog.?| (procedure = pg_catalog.line_vertical, rightarg = line); + +comment on operator pg_catalog.?|(none, line) is 'vertical'; + +create operator pg_catalog.?| (procedure = pg_catalog.lseg_vertical, rightarg = lseg); + +comment on operator pg_catalog.?|(none, lseg) is 'vertical'; + +create operator pg_catalog.?|| (procedure = pg_catalog.line_parallel, leftarg = line, rightarg = line, commutator = pg_catalog.?||); + +comment on operator pg_catalog.?||(line, line) is 'parallel'; + +create operator pg_catalog.?|| (procedure = pg_catalog.lseg_parallel, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.?||); + +comment on operator pg_catalog.?||(lseg, lseg) is 'parallel'; + +create operator pg_catalog.@ (procedure = pg_catalog.int8abs, rightarg = bigint); + +comment on operator pg_catalog.@(none, bigint) is 'absolute value'; + +create operator pg_catalog.@ (procedure = pg_catalog.float8abs, rightarg = double precision); + +comment on operator pg_catalog.@(none, double precision) is 'absolute value'; + +create operator pg_catalog.@ (procedure = pg_catalog.int4abs, rightarg = integer); + +comment on operator pg_catalog.@(none, integer) is 'absolute value'; + +create operator pg_catalog.@ (procedure = pg_catalog.numeric_abs, rightarg = numeric); + +comment on operator pg_catalog.@(none, numeric) is 'absolute value'; + +create operator pg_catalog.@ (procedure = pg_catalog.float4abs, rightarg = real); + +comment on operator pg_catalog.@(none, real) is 'absolute value'; + +create operator pg_catalog.@ (procedure = pg_catalog.int2abs, rightarg = smallint); + +comment on operator pg_catalog.@(none, smallint) is 'absolute value'; + +create operator pg_catalog.@-@ (procedure = pg_catalog.lseg_length, rightarg = lseg); + +comment on operator pg_catalog.@-@(none, lseg) is 'distance between endpoints'; + +create operator pg_catalog.@-@ (procedure = pg_catalog.path_length, rightarg = path); + +comment on operator pg_catalog.@-@(none, path) is 'sum of path segment lengths'; + +create operator pg_catalog.@> (procedure = pg_catalog.aclcontains, leftarg = aclitem[], rightarg = aclitem); + +comment on operator pg_catalog.@>(aclitem[], aclitem) is 'contains'; + +create operator pg_catalog.@? (procedure = pg_catalog.jsonb_path_exists_opr, leftarg = jsonb, rightarg = jsonpath, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@?(jsonb, jsonpath) is 'jsonpath exists'; + +create operator pg_catalog.@@ (procedure = pg_catalog.jsonb_path_match_opr, leftarg = jsonb, rightarg = jsonpath, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@@(jsonb, jsonpath) is 'jsonpath match'; + +create operator pg_catalog.@@ (procedure = pg_catalog.ts_match_tt, leftarg = text, rightarg = text, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@@(text, text) is 'text search match'; + +create operator pg_catalog.@@ (procedure = pg_catalog.ts_match_tq, leftarg = text, rightarg = tsquery, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@@(text, tsquery) is 'text search match'; + +create operator pg_catalog.@@ (procedure = pg_catalog.ts_match_vq, leftarg = tsvector, rightarg = tsquery, commutator = pg_catalog.@@, join = pg_catalog.tsmatchjoinsel, restrict = pg_catalog.tsmatchsel); + +comment on operator pg_catalog.@@(tsvector, tsquery) is 'text search match'; + +create operator pg_catalog.@@ (procedure = pg_catalog.ts_match_qv, leftarg = tsquery, rightarg = tsvector, commutator = pg_catalog.@@, join = pg_catalog.tsmatchjoinsel, restrict = pg_catalog.tsmatchsel); + +comment on operator pg_catalog.@@(tsquery, tsvector) is 'text search match'; + +create operator pg_catalog.@@ (procedure = pg_catalog.box_center, rightarg = box); + +comment on operator pg_catalog.@@(none, box) is 'center of'; + +create operator pg_catalog.@@ (procedure = pg_catalog.circle_center, rightarg = circle); + +comment on operator pg_catalog.@@(none, circle) is 'center of'; + +create operator pg_catalog.@@ (procedure = pg_catalog.lseg_center, rightarg = lseg); + +comment on operator pg_catalog.@@(none, lseg) is 'center of'; + +create operator pg_catalog.@@ (procedure = pg_catalog.poly_center, rightarg = polygon); + +comment on operator pg_catalog.@@(none, polygon) is 'center of'; + +create operator pg_catalog.@@@ (procedure = pg_catalog.ts_match_vq, leftarg = tsvector, rightarg = tsquery, commutator = pg_catalog.@@@, join = pg_catalog.tsmatchjoinsel, restrict = pg_catalog.tsmatchsel); + +comment on operator pg_catalog.@@@(tsvector, tsquery) is 'deprecated, use @@ instead'; + +create operator pg_catalog.@@@ (procedure = pg_catalog.ts_match_qv, leftarg = tsquery, rightarg = tsvector, commutator = pg_catalog.@@@, join = pg_catalog.tsmatchjoinsel, restrict = pg_catalog.tsmatchsel); + +comment on operator pg_catalog.@@@(tsquery, tsvector) is 'deprecated, use @@ instead'; + +create operator pg_catalog.^ (procedure = pg_catalog.dpow, leftarg = double precision, rightarg = double precision); + +comment on operator pg_catalog.^(double precision, double precision) is 'exponentiation'; + +create operator pg_catalog.^ (procedure = pg_catalog.numeric_power, leftarg = numeric, rightarg = numeric); + +comment on operator pg_catalog.^(numeric, numeric) is 'exponentiation'; + +create operator pg_catalog.^@ (procedure = pg_catalog.starts_with, leftarg = text, rightarg = text, join = pg_catalog.prefixjoinsel, restrict = pg_catalog.prefixsel); + +comment on operator pg_catalog.^@(text, text) is 'starts with'; + +create operator pg_catalog.|&> (procedure = pg_catalog.box_overabove, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|&>(box, box) is 'overlaps or is above'; + +create operator pg_catalog.|&> (procedure = pg_catalog.circle_overabove, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|&>(circle, circle) is 'overlaps or is above'; + +create operator pg_catalog.|&> (procedure = pg_catalog.poly_overabove, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|&>(polygon, polygon) is 'overlaps or is above'; + +create operator pg_catalog.| (procedure = pg_catalog.int8or, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.|); + +comment on operator pg_catalog.|(bigint, bigint) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.bitor, leftarg = bit, rightarg = bit, commutator = pg_catalog.|); + +comment on operator pg_catalog.|(bit, bit) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.inetor, leftarg = inet, rightarg = inet); + +comment on operator pg_catalog.|(inet, inet) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.int4or, leftarg = integer, rightarg = integer, commutator = pg_catalog.|); + +comment on operator pg_catalog.|(integer, integer) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.macaddr_or, leftarg = macaddr, rightarg = macaddr); + +comment on operator pg_catalog.|(macaddr, macaddr) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.macaddr8_or, leftarg = macaddr8, rightarg = macaddr8); + +comment on operator pg_catalog.|(macaddr8, macaddr8) is 'bitwise or'; + +create operator pg_catalog.| (procedure = pg_catalog.int2or, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.|); + +comment on operator pg_catalog.|(smallint, smallint) is 'bitwise or'; + +create operator pg_catalog.|/ (procedure = pg_catalog.dsqrt, rightarg = double precision); + +comment on operator pg_catalog.|/(none, double precision) is 'square root'; + +create operator pg_catalog.|>> (procedure = pg_catalog.box_above, leftarg = box, rightarg = box, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|>>(box, box) is 'is above'; + +create operator pg_catalog.|>> (procedure = pg_catalog.circle_above, leftarg = circle, rightarg = circle, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|>>(circle, circle) is 'is above'; + +create operator pg_catalog.|>> (procedure = pg_catalog.point_above, leftarg = point, rightarg = point, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|>>(point, point) is 'is above'; + +create operator pg_catalog.|>> (procedure = pg_catalog.poly_above, leftarg = polygon, rightarg = polygon, join = pg_catalog.positionjoinsel, restrict = pg_catalog.positionsel); + +comment on operator pg_catalog.|>>(polygon, polygon) is 'is above'; + +create operator pg_catalog.|| (procedure = pg_catalog.array_prepend, leftarg = anycompatible, rightarg = anycompatiblearray); + +comment on operator pg_catalog.||(anycompatible, anycompatiblearray) is 'prepend element onto front of array'; + +create operator pg_catalog.|| (procedure = pg_catalog.array_append, leftarg = anycompatiblearray, rightarg = anycompatible); + +comment on operator pg_catalog.||(anycompatiblearray, anycompatible) is 'append element onto end of array'; + +create operator pg_catalog.|| (procedure = pg_catalog.array_cat, leftarg = anycompatiblearray, rightarg = anycompatiblearray); + +comment on operator pg_catalog.||(anycompatiblearray, anycompatiblearray) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.anytextcat, leftarg = anynonarray, rightarg = text); + +comment on operator pg_catalog.||(anynonarray, text) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.bitcat, leftarg = bit varying, rightarg = bit varying); + +comment on operator pg_catalog.||(bit varying, bit varying) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.byteacat, leftarg = bytea, rightarg = bytea); + +comment on operator pg_catalog.||(bytea, bytea) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.jsonb_concat, leftarg = jsonb, rightarg = jsonb); + +comment on operator pg_catalog.||(jsonb, jsonb) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.textanycat, leftarg = text, rightarg = anynonarray); + +comment on operator pg_catalog.||(text, anynonarray) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.textcat, leftarg = text, rightarg = text); + +comment on operator pg_catalog.||(text, text) is 'concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.tsquery_or, leftarg = tsquery, rightarg = tsquery); + +comment on operator pg_catalog.||(tsquery, tsquery) is 'OR-concatenate'; + +create operator pg_catalog.|| (procedure = pg_catalog.tsvector_concat, leftarg = tsvector, rightarg = tsvector); + +comment on operator pg_catalog.||(tsvector, tsvector) is 'concatenate'; + +create operator pg_catalog.||/ (procedure = pg_catalog.dcbrt, rightarg = double precision); + +comment on operator pg_catalog.||/(none, double precision) is 'cube root'; + +create operator pg_catalog.~ (procedure = pg_catalog.int8not, rightarg = bigint); + +comment on operator pg_catalog.~(none, bigint) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.bitnot, rightarg = bit); + +comment on operator pg_catalog.~(none, bit) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.inetnot, rightarg = inet); + +comment on operator pg_catalog.~(none, inet) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.int4not, rightarg = integer); + +comment on operator pg_catalog.~(none, integer) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.macaddr_not, rightarg = macaddr); + +comment on operator pg_catalog.~(none, macaddr) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.macaddr8_not, rightarg = macaddr8); + +comment on operator pg_catalog.~(none, macaddr8) is 'bitwise not'; + +create operator pg_catalog.~ (procedure = pg_catalog.int2not, rightarg = smallint); + +comment on operator pg_catalog.~(none, smallint) is 'bitwise not'; + +create operator pg_catalog.~= (procedure = pg_catalog.box_same, leftarg = box, rightarg = box, commutator = pg_catalog.~=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.~=(box, box) is 'same as'; + +create operator pg_catalog.~= (procedure = pg_catalog.circle_same, leftarg = circle, rightarg = circle, commutator = pg_catalog.~=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.~=(circle, circle) is 'same as'; + +create operator pg_catalog.~= (procedure = pg_catalog.poly_same, leftarg = polygon, rightarg = polygon, commutator = pg_catalog.~=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.~=(polygon, polygon) is 'same as'; + +create aggregate pg_catalog.any_value(anyelement) ( + sfunc = any_value_transfn, + stype = anyelement, + combinefunc = any_value_transfn + ); + +comment on aggregate pg_catalog.any_value(anyelement) is 'arbitrary value from among input values'; + +create aggregate pg_catalog.array_agg(anyarray) ( + sfunc = array_agg_array_transfn, + stype = internal, + finalfunc = array_agg_array_finalfn, + combinefunc = array_agg_array_combine, + serialfunc = array_agg_array_serialize, + deserialfunc = array_agg_array_deserialize + ); + +comment on aggregate pg_catalog.array_agg(anyarray) is 'concatenate aggregate input into an array'; + +create aggregate pg_catalog.array_agg(anynonarray) ( + sfunc = array_agg_transfn, + stype = internal, + finalfunc = array_agg_finalfn, + combinefunc = array_agg_combine, + serialfunc = array_agg_serialize, + deserialfunc = array_agg_deserialize + ); + +comment on aggregate pg_catalog.array_agg(anynonarray) is 'concatenate aggregate input into an array'; + +create aggregate pg_catalog.avg(bigint) ( + sfunc = int8_avg_accum, + stype = internal, + finalfunc = numeric_poly_avg, + combinefunc = int8_avg_combine, + serialfunc = int8_avg_serialize, + deserialfunc = int8_avg_deserialize, + msfunc = int8_avg_accum, + minvfunc = int8_avg_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_avg + ); + +comment on aggregate pg_catalog.avg(bigint) is 'the average (arithmetic mean) as numeric of all bigint values'; + +create aggregate pg_catalog.avg(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_avg, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.avg(double precision) is 'the average (arithmetic mean) as float8 of all float8 values'; + +create aggregate pg_catalog.avg(integer) ( + sfunc = int4_avg_accum, + stype = bigint[], + finalfunc = int8_avg, + combinefunc = int4_avg_combine, + msfunc = int4_avg_accum, + minvfunc = int4_avg_accum_inv, + mstype = bigint[], + mfinalfunc = int8_avg + ); + +comment on aggregate pg_catalog.avg(integer) is 'the average (arithmetic mean) as numeric of all integer values'; + +create aggregate pg_catalog.avg(interval) ( + sfunc = interval_accum, + stype = interval[], + finalfunc = interval_avg, + combinefunc = interval_combine, + msfunc = interval_accum, + minvfunc = interval_accum_inv, + mstype = interval[], + mfinalfunc = interval_avg + ); + +comment on aggregate pg_catalog.avg(interval) is 'the average (arithmetic mean) as interval of all interval values'; + +create aggregate pg_catalog.avg(numeric) ( + sfunc = numeric_avg_accum, + stype = internal, + finalfunc = numeric_avg, + combinefunc = numeric_avg_combine, + serialfunc = numeric_avg_serialize, + deserialfunc = numeric_avg_deserialize, + msfunc = numeric_avg_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_avg + ); + +comment on aggregate pg_catalog.avg(numeric) is 'the average (arithmetic mean) as numeric of all numeric values'; + +create aggregate pg_catalog.avg(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_avg, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.avg(real) is 'the average (arithmetic mean) as float8 of all float4 values'; + +create aggregate pg_catalog.avg(smallint) ( + sfunc = int2_avg_accum, + stype = bigint[], + finalfunc = int8_avg, + combinefunc = int4_avg_combine, + msfunc = int2_avg_accum, + minvfunc = int2_avg_accum_inv, + mstype = bigint[], + mfinalfunc = int8_avg + ); + +comment on aggregate pg_catalog.avg(smallint) is 'the average (arithmetic mean) as numeric of all smallint values'; + +create aggregate pg_catalog.bit_and(bigint) ( + sfunc = int8and, + stype = bigint, + combinefunc = int8and + ); + +comment on aggregate pg_catalog.bit_and(bigint) is 'bitwise-and bigint aggregate'; + +create aggregate pg_catalog.bit_and(bit) ( + sfunc = bitand, + stype = bit, + combinefunc = bitand + ); + +comment on aggregate pg_catalog.bit_and(bit) is 'bitwise-and bit aggregate'; + +create aggregate pg_catalog.bit_and(integer) ( + sfunc = int4and, + stype = integer, + combinefunc = int4and + ); + +comment on aggregate pg_catalog.bit_and(integer) is 'bitwise-and integer aggregate'; + +create aggregate pg_catalog.bit_and(smallint) ( + sfunc = int2and, + stype = smallint, + combinefunc = int2and + ); + +comment on aggregate pg_catalog.bit_and(smallint) is 'bitwise-and smallint aggregate'; + +create aggregate pg_catalog.bit_or(bigint) ( + sfunc = int8or, + stype = bigint, + combinefunc = int8or + ); + +comment on aggregate pg_catalog.bit_or(bigint) is 'bitwise-or bigint aggregate'; + +create aggregate pg_catalog.bit_or(bit) ( + sfunc = bitor, + stype = bit, + combinefunc = bitor + ); + +comment on aggregate pg_catalog.bit_or(bit) is 'bitwise-or bit aggregate'; + +create aggregate pg_catalog.bit_or(integer) ( + sfunc = int4or, + stype = integer, + combinefunc = int4or + ); + +comment on aggregate pg_catalog.bit_or(integer) is 'bitwise-or integer aggregate'; + +create aggregate pg_catalog.bit_or(smallint) ( + sfunc = int2or, + stype = smallint, + combinefunc = int2or + ); + +comment on aggregate pg_catalog.bit_or(smallint) is 'bitwise-or smallint aggregate'; + +create aggregate pg_catalog.bit_xor(bigint) ( + sfunc = int8xor, + stype = bigint, + combinefunc = int8xor + ); + +comment on aggregate pg_catalog.bit_xor(bigint) is 'bitwise-xor bigint aggregate'; + +create aggregate pg_catalog.bit_xor(bit) ( + sfunc = bitxor, + stype = bit, + combinefunc = bitxor + ); + +comment on aggregate pg_catalog.bit_xor(bit) is 'bitwise-xor bit aggregate'; + +create aggregate pg_catalog.bit_xor(integer) ( + sfunc = int4xor, + stype = integer, + combinefunc = int4xor + ); + +comment on aggregate pg_catalog.bit_xor(integer) is 'bitwise-xor integer aggregate'; + +create aggregate pg_catalog.bit_xor(smallint) ( + sfunc = int2xor, + stype = smallint, + combinefunc = int2xor + ); + +comment on aggregate pg_catalog.bit_xor(smallint) is 'bitwise-xor smallint aggregate'; + +create aggregate pg_catalog.corr(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_corr, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.corr(double precision, double precision) is 'correlation coefficient'; + +create aggregate pg_catalog.count("any") ( + sfunc = int8inc_any, + stype = bigint, + combinefunc = int8pl, + msfunc = int8inc_any, + minvfunc = int8dec_any, + mstype = bigint + ); + +comment on aggregate pg_catalog.count("any") is 'number of input rows for which the input expression is not null'; + +create aggregate pg_catalog.count() ( + sfunc = int8inc, + stype = bigint, + combinefunc = int8pl, + msfunc = int8inc, + minvfunc = int8dec, + mstype = bigint + ); + +comment on aggregate pg_catalog.count() is 'number of input rows'; + +create aggregate pg_catalog.covar_pop(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_covar_pop, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.covar_pop(double precision, double precision) is 'population covariance'; + +create aggregate pg_catalog.covar_samp(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_covar_samp, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.covar_samp(double precision, double precision) is 'sample covariance'; + +create aggregate pg_catalog.cume_dist("any") ( + sfunc = ordered_set_transition_multi, + stype = internal, + finalfunc = cume_dist_final + ); + +comment on aggregate pg_catalog.cume_dist("any") is 'cumulative distribution of hypothetical row'; + +create aggregate pg_catalog.dense_rank("any") ( + sfunc = ordered_set_transition_multi, + stype = internal, + finalfunc = dense_rank_final + ); + +comment on aggregate pg_catalog.dense_rank("any") is 'rank of hypothetical row without gaps'; + +create aggregate pg_catalog.json_agg(anyelement) ( + sfunc = json_agg_transfn, + stype = internal, + finalfunc = json_agg_finalfn + ); + +comment on aggregate pg_catalog.json_agg(anyelement) is 'aggregate input into json'; + +create aggregate pg_catalog.json_agg_strict(anyelement) ( + sfunc = json_agg_strict_transfn, + stype = internal, + finalfunc = json_agg_finalfn + ); + +comment on aggregate pg_catalog.json_agg_strict(anyelement) is 'aggregate input into json'; + +create aggregate pg_catalog.json_object_agg("any", "any") ( + sfunc = json_object_agg_transfn, + stype = internal, + finalfunc = json_object_agg_finalfn + ); + +comment on aggregate pg_catalog.json_object_agg("any", "any") is 'aggregate input into a json object'; + +create aggregate pg_catalog.json_object_agg_strict("any", "any") ( + sfunc = json_object_agg_strict_transfn, + stype = internal, + finalfunc = json_object_agg_finalfn + ); + +comment on aggregate pg_catalog.json_object_agg_strict("any", "any") is 'aggregate non-NULL input into a json object'; + +create aggregate pg_catalog.json_object_agg_unique("any", "any") ( + sfunc = json_object_agg_unique_transfn, + stype = internal, + finalfunc = json_object_agg_finalfn + ); + +comment on aggregate pg_catalog.json_object_agg_unique("any", "any") is 'aggregate input into a json object with unique keys'; + +create aggregate pg_catalog.json_object_agg_unique_strict("any", "any") ( + sfunc = json_object_agg_unique_strict_transfn, + stype = internal, + finalfunc = json_object_agg_finalfn + ); + +comment on aggregate pg_catalog.json_object_agg_unique_strict("any", "any") is 'aggregate non-NULL input into a json object with unique keys'; + +create aggregate pg_catalog.jsonb_agg(anyelement) ( + sfunc = jsonb_agg_transfn, + stype = internal, + finalfunc = jsonb_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_agg(anyelement) is 'aggregate input into jsonb'; + +create aggregate pg_catalog.jsonb_agg_strict(anyelement) ( + sfunc = jsonb_agg_strict_transfn, + stype = internal, + finalfunc = jsonb_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_agg_strict(anyelement) is 'aggregate input into jsonb skipping nulls'; + +create aggregate pg_catalog.jsonb_object_agg("any", "any") ( + sfunc = jsonb_object_agg_transfn, + stype = internal, + finalfunc = jsonb_object_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_object_agg("any", "any") is 'aggregate inputs into jsonb object'; + +create aggregate pg_catalog.jsonb_object_agg_strict("any", "any") ( + sfunc = jsonb_object_agg_strict_transfn, + stype = internal, + finalfunc = jsonb_object_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_object_agg_strict("any", "any") is 'aggregate non-NULL inputs into jsonb object'; + +create aggregate pg_catalog.jsonb_object_agg_unique("any", "any") ( + sfunc = jsonb_object_agg_unique_transfn, + stype = internal, + finalfunc = jsonb_object_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_object_agg_unique("any", "any") is 'aggregate inputs into jsonb object checking key uniqueness'; + +create aggregate pg_catalog.jsonb_object_agg_unique_strict("any", "any") ( + sfunc = jsonb_object_agg_unique_strict_transfn, + stype = internal, + finalfunc = jsonb_object_agg_finalfn + ); + +comment on aggregate pg_catalog.jsonb_object_agg_unique_strict("any", "any") is 'aggregate non-NULL inputs into jsonb object checking key uniqueness'; + +create aggregate pg_catalog.mode(anyelement) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = mode_final + ); + +comment on aggregate pg_catalog.mode(anyelement) is 'most common value'; + +create aggregate pg_catalog.percent_rank("any") ( + sfunc = ordered_set_transition_multi, + stype = internal, + finalfunc = percent_rank_final + ); + +comment on aggregate pg_catalog.percent_rank("any") is 'fractional rank of hypothetical row'; + +create aggregate pg_catalog.percentile_cont(double precision, double precision) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_cont_float8_final + ); + +comment on aggregate pg_catalog.percentile_cont(double precision, double precision) is 'continuous distribution percentile'; + +create aggregate pg_catalog.percentile_cont(double precision, interval) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_cont_interval_final + ); + +comment on aggregate pg_catalog.percentile_cont(double precision, interval) is 'continuous distribution percentile'; + +create aggregate pg_catalog.percentile_cont(double precision[], double precision) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_cont_float8_multi_final + ); + +comment on aggregate pg_catalog.percentile_cont(double precision[], double precision) is 'multiple continuous percentiles'; + +create aggregate pg_catalog.percentile_cont(double precision[], interval) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_cont_interval_multi_final + ); + +comment on aggregate pg_catalog.percentile_cont(double precision[], interval) is 'multiple continuous percentiles'; + +create aggregate pg_catalog.percentile_disc(double precision, anyelement) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_disc_final + ); + +comment on aggregate pg_catalog.percentile_disc(double precision, anyelement) is 'discrete percentile'; + +create aggregate pg_catalog.percentile_disc(double precision[], anyelement) ( + sfunc = ordered_set_transition, + stype = internal, + finalfunc = percentile_disc_multi_final + ); + +comment on aggregate pg_catalog.percentile_disc(double precision[], anyelement) is 'multiple discrete percentiles'; + +create aggregate pg_catalog.range_agg(anymultirange) ( + sfunc = multirange_agg_transfn, + stype = internal, + finalfunc = multirange_agg_finalfn + ); + +comment on aggregate pg_catalog.range_agg(anymultirange) is 'combine aggregate input into a multirange'; + +create aggregate pg_catalog.range_agg(anyrange) ( + sfunc = range_agg_transfn, + stype = internal, + finalfunc = range_agg_finalfn + ); + +comment on aggregate pg_catalog.range_agg(anyrange) is 'combine aggregate input into a multirange'; + +create aggregate pg_catalog.range_intersect_agg(anymultirange) ( + sfunc = multirange_intersect_agg_transfn, + stype = anymultirange, + combinefunc = multirange_intersect_agg_transfn + ); + +comment on aggregate pg_catalog.range_intersect_agg(anymultirange) is 'range aggregate by intersecting'; + +create aggregate pg_catalog.range_intersect_agg(anyrange) ( + sfunc = range_intersect_agg_transfn, + stype = anyrange, + combinefunc = range_intersect_agg_transfn + ); + +comment on aggregate pg_catalog.range_intersect_agg(anyrange) is 'range aggregate by intersecting'; + +create aggregate pg_catalog.rank("any") ( + sfunc = ordered_set_transition_multi, + stype = internal, + finalfunc = rank_final + ); + +comment on aggregate pg_catalog.rank("any") is 'rank of hypothetical row'; + +create aggregate pg_catalog.regr_avgx(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_avgx, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_avgx(double precision, double precision) is 'average of the independent variable (sum(X)/N)'; + +create aggregate pg_catalog.regr_avgy(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_avgy, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_avgy(double precision, double precision) is 'average of the dependent variable (sum(Y)/N)'; + +create aggregate pg_catalog.regr_count(double precision, double precision) ( + sfunc = int8inc_float8_float8, + stype = bigint, + combinefunc = int8pl + ); + +comment on aggregate pg_catalog.regr_count(double precision, double precision) is 'number of input rows in which both expressions are not null'; + +create aggregate pg_catalog.regr_intercept(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_intercept, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_intercept(double precision, double precision) is 'y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs'; + +create aggregate pg_catalog.regr_r2(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_r2, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_r2(double precision, double precision) is 'square of the correlation coefficient'; + +create aggregate pg_catalog.regr_slope(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_slope, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_slope(double precision, double precision) is 'slope of the least-squares-fit linear equation determined by the (X, Y) pairs'; + +create aggregate pg_catalog.regr_sxx(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_sxx, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_sxx(double precision, double precision) is 'sum of squares of the independent variable (sum(X^2) - sum(X)^2/N)'; + +create aggregate pg_catalog.regr_sxy(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_sxy, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_sxy(double precision, double precision) is 'sum of products of independent times dependent variable (sum(X*Y) - sum(X) * sum(Y)/N)'; + +create aggregate pg_catalog.regr_syy(double precision, double precision) ( + sfunc = float8_regr_accum, + stype = double precision[], + finalfunc = float8_regr_syy, + combinefunc = float8_regr_combine + ); + +comment on aggregate pg_catalog.regr_syy(double precision, double precision) is 'sum of squares of the dependent variable (sum(Y^2) - sum(Y)^2/N)'; + +create aggregate pg_catalog.stddev(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_stddev_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_samp + ); + +comment on aggregate pg_catalog.stddev(bigint) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_stddev_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev(double precision) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_stddev_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_samp + ); + +comment on aggregate pg_catalog.stddev(integer) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_stddev_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_samp + ); + +comment on aggregate pg_catalog.stddev(numeric) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_stddev_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev(real) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_stddev_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_samp + ); + +comment on aggregate pg_catalog.stddev(smallint) is 'historical alias for stddev_samp'; + +create aggregate pg_catalog.stddev_pop(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_stddev_pop, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_pop + ); + +comment on aggregate pg_catalog.stddev_pop(bigint) is 'population standard deviation of bigint input values'; + +create aggregate pg_catalog.stddev_pop(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_stddev_pop, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev_pop(double precision) is 'population standard deviation of float8 input values'; + +create aggregate pg_catalog.stddev_pop(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_stddev_pop, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_pop + ); + +comment on aggregate pg_catalog.stddev_pop(integer) is 'population standard deviation of integer input values'; + +create aggregate pg_catalog.stddev_pop(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_stddev_pop, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_pop + ); + +comment on aggregate pg_catalog.stddev_pop(numeric) is 'population standard deviation of numeric input values'; + +create aggregate pg_catalog.stddev_pop(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_stddev_pop, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev_pop(real) is 'population standard deviation of float4 input values'; + +create aggregate pg_catalog.stddev_pop(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_stddev_pop, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_pop + ); + +comment on aggregate pg_catalog.stddev_pop(smallint) is 'population standard deviation of smallint input values'; + +create aggregate pg_catalog.stddev_samp(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_stddev_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_samp + ); + +comment on aggregate pg_catalog.stddev_samp(bigint) is 'sample standard deviation of bigint input values'; + +create aggregate pg_catalog.stddev_samp(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_stddev_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev_samp(double precision) is 'sample standard deviation of float8 input values'; + +create aggregate pg_catalog.stddev_samp(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_stddev_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_samp + ); + +comment on aggregate pg_catalog.stddev_samp(integer) is 'sample standard deviation of integer input values'; + +create aggregate pg_catalog.stddev_samp(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_stddev_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_stddev_samp + ); + +comment on aggregate pg_catalog.stddev_samp(numeric) is 'sample standard deviation of numeric input values'; + +create aggregate pg_catalog.stddev_samp(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_stddev_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.stddev_samp(real) is 'sample standard deviation of float4 input values'; + +create aggregate pg_catalog.stddev_samp(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_stddev_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_stddev_samp + ); + +comment on aggregate pg_catalog.stddev_samp(smallint) is 'sample standard deviation of smallint input values'; + +create aggregate pg_catalog.string_agg(bytea, bytea) ( + sfunc = bytea_string_agg_transfn, + stype = internal, + finalfunc = bytea_string_agg_finalfn, + combinefunc = string_agg_combine, + serialfunc = string_agg_serialize, + deserialfunc = string_agg_deserialize + ); + +comment on aggregate pg_catalog.string_agg(bytea, bytea) is 'concatenate aggregate input into a bytea'; + +create aggregate pg_catalog.string_agg(text, text) ( + sfunc = string_agg_transfn, + stype = internal, + finalfunc = string_agg_finalfn, + combinefunc = string_agg_combine, + serialfunc = string_agg_serialize, + deserialfunc = string_agg_deserialize + ); + +comment on aggregate pg_catalog.string_agg(text, text) is 'concatenate aggregate input into a string'; + +create aggregate pg_catalog.sum(bigint) ( + sfunc = int8_avg_accum, + stype = internal, + finalfunc = numeric_poly_sum, + combinefunc = int8_avg_combine, + serialfunc = int8_avg_serialize, + deserialfunc = int8_avg_deserialize, + msfunc = int8_avg_accum, + minvfunc = int8_avg_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_sum + ); + +comment on aggregate pg_catalog.sum(bigint) is 'sum as numeric across all bigint input values'; + +create aggregate pg_catalog.sum(double precision) ( + sfunc = float8pl, + stype = double precision, + combinefunc = float8pl + ); + +comment on aggregate pg_catalog.sum(double precision) is 'sum as float8 across all float8 input values'; + +create aggregate pg_catalog.sum(integer) ( + sfunc = int4_sum, + stype = bigint, + combinefunc = int8pl, + msfunc = int4_avg_accum, + minvfunc = int4_avg_accum_inv, + mstype = bigint[], + mfinalfunc = int2int4_sum + ); + +comment on aggregate pg_catalog.sum(integer) is 'sum as bigint across all integer input values'; + +create aggregate pg_catalog.sum(interval) ( + sfunc = interval_pl, + stype = interval, + combinefunc = interval_pl, + msfunc = interval_pl, + minvfunc = interval_mi, + mstype = interval + ); + +comment on aggregate pg_catalog.sum(interval) is 'sum as interval across all interval input values'; + +create aggregate pg_catalog.sum(money) ( + sfunc = cash_pl, + stype = money, + combinefunc = cash_pl, + msfunc = cash_pl, + minvfunc = cash_mi, + mstype = money + ); + +comment on aggregate pg_catalog.sum(money) is 'sum as money across all money input values'; + +create aggregate pg_catalog.sum(numeric) ( + sfunc = numeric_avg_accum, + stype = internal, + finalfunc = numeric_sum, + combinefunc = numeric_avg_combine, + serialfunc = numeric_avg_serialize, + deserialfunc = numeric_avg_deserialize, + msfunc = numeric_avg_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_sum + ); + +comment on aggregate pg_catalog.sum(numeric) is 'sum as numeric across all numeric input values'; + +create aggregate pg_catalog.sum(real) ( + sfunc = float4pl, + stype = real, + combinefunc = float4pl + ); + +comment on aggregate pg_catalog.sum(real) is 'sum as float4 across all float4 input values'; + +create aggregate pg_catalog.sum(smallint) ( + sfunc = int2_sum, + stype = bigint, + combinefunc = int8pl, + msfunc = int2_avg_accum, + minvfunc = int2_avg_accum_inv, + mstype = bigint[], + mfinalfunc = int2int4_sum + ); + +comment on aggregate pg_catalog.sum(smallint) is 'sum as bigint across all smallint input values'; + +create aggregate pg_catalog.var_pop(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_var_pop, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_pop + ); + +comment on aggregate pg_catalog.var_pop(bigint) is 'population variance of bigint input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_pop(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_var_pop, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.var_pop(double precision) is 'population variance of float8 input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_pop(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_var_pop, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_pop + ); + +comment on aggregate pg_catalog.var_pop(integer) is 'population variance of integer input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_pop(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_var_pop, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_pop + ); + +comment on aggregate pg_catalog.var_pop(numeric) is 'population variance of numeric input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_pop(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_var_pop, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.var_pop(real) is 'population variance of float4 input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_pop(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_var_pop, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_pop + ); + +comment on aggregate pg_catalog.var_pop(smallint) is 'population variance of smallint input values (square of the population standard deviation)'; + +create aggregate pg_catalog.var_samp(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_var_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_samp + ); + +comment on aggregate pg_catalog.var_samp(bigint) is 'sample variance of bigint input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.var_samp(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_var_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.var_samp(double precision) is 'sample variance of float8 input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.var_samp(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_var_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_samp + ); + +comment on aggregate pg_catalog.var_samp(integer) is 'sample variance of integer input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.var_samp(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_var_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_samp + ); + +comment on aggregate pg_catalog.var_samp(numeric) is 'sample variance of numeric input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.var_samp(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_var_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.var_samp(real) is 'sample variance of float4 input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.var_samp(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_var_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_samp + ); + +comment on aggregate pg_catalog.var_samp(smallint) is 'sample variance of smallint input values (square of the sample standard deviation)'; + +create aggregate pg_catalog.variance(bigint) ( + sfunc = int8_accum, + stype = internal, + finalfunc = numeric_var_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = int8_accum, + minvfunc = int8_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_samp + ); + +comment on aggregate pg_catalog.variance(bigint) is 'historical alias for var_samp'; + +create aggregate pg_catalog.variance(double precision) ( + sfunc = float8_accum, + stype = double precision[], + finalfunc = float8_var_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.variance(double precision) is 'historical alias for var_samp'; + +create aggregate pg_catalog.variance(integer) ( + sfunc = int4_accum, + stype = internal, + finalfunc = numeric_poly_var_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int4_accum, + minvfunc = int4_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_samp + ); + +comment on aggregate pg_catalog.variance(integer) is 'historical alias for var_samp'; + +create aggregate pg_catalog.variance(numeric) ( + sfunc = numeric_accum, + stype = internal, + finalfunc = numeric_var_samp, + combinefunc = numeric_combine, + serialfunc = numeric_serialize, + deserialfunc = numeric_deserialize, + msfunc = numeric_accum, + minvfunc = numeric_accum_inv, + mstype = internal, + mfinalfunc = numeric_var_samp + ); + +comment on aggregate pg_catalog.variance(numeric) is 'historical alias for var_samp'; + +create aggregate pg_catalog.variance(real) ( + sfunc = float4_accum, + stype = double precision[], + finalfunc = float8_var_samp, + combinefunc = float8_combine + ); + +comment on aggregate pg_catalog.variance(real) is 'historical alias for var_samp'; + +create aggregate pg_catalog.variance(smallint) ( + sfunc = int2_accum, + stype = internal, + finalfunc = numeric_poly_var_samp, + combinefunc = numeric_poly_combine, + serialfunc = numeric_poly_serialize, + deserialfunc = numeric_poly_deserialize, + msfunc = int2_accum, + minvfunc = int2_accum_inv, + mstype = internal, + mfinalfunc = numeric_poly_var_samp + ); + +comment on aggregate pg_catalog.variance(smallint) is 'historical alias for var_samp'; + +create aggregate pg_catalog.xmlagg(xml) ( + sfunc = xmlconcat2, + stype = xml + ); + +comment on aggregate pg_catalog.xmlagg(xml) is 'concatenate XML values'; + +create operator class pg_catalog.aclitem_ops default for type aclitem using hash as; + +create operator class pg_catalog.array_ops default for type anyarray using btree as; + +create operator class pg_catalog.array_ops default for type anyarray using gin as storage anyelement; + +create operator class pg_catalog.array_ops default for type anyarray using hash as; + +create operator class pg_catalog.bit_minmax_ops default for type bit using brin as storage bit; + +create operator class pg_catalog.bit_ops default for type bit using btree as; + +create operator class pg_catalog.bool_ops default for type boolean using btree as; + +create operator class pg_catalog.bool_ops default for type boolean using hash as; + +create operator class pg_catalog.box_inclusion_ops default for type box using brin as storage box; + +create operator class pg_catalog.box_ops default for type box using gist as; + +create operator class pg_catalog.box_ops default for type box using spgist as; + +create operator class pg_catalog.bpchar_bloom_ops for type character using brin as storage character; + +create operator class pg_catalog.bpchar_minmax_ops default for type character using brin as storage character; + +create operator class pg_catalog.bpchar_ops default for type character using btree as; + +create operator class pg_catalog.bpchar_ops default for type character using hash as; + +create operator class pg_catalog.bpchar_pattern_ops for type character using btree as; + +create operator class pg_catalog.bpchar_pattern_ops for type character using hash as; + +create operator class pg_catalog.bytea_bloom_ops for type bytea using brin as storage bytea; + +create operator class pg_catalog.bytea_minmax_ops default for type bytea using brin as storage bytea; + +create operator class pg_catalog.bytea_ops default for type bytea using btree as; + +create operator class pg_catalog.bytea_ops default for type bytea using hash as; + +create operator class pg_catalog.char_bloom_ops for type "char" using brin as storage "char"; + +create operator class pg_catalog.char_minmax_ops default for type "char" using brin as storage "char"; + +create operator class pg_catalog.char_ops default for type "char" using btree as; + +create operator class pg_catalog.char_ops default for type "char" using hash as; + +create operator class pg_catalog.cid_ops default for type cid using hash as; + +create operator class pg_catalog.circle_ops default for type circle using gist as storage box; + +create operator class pg_catalog.date_ops default for type date using hash as; + +create operator class pg_catalog.enum_ops default for type anyenum using btree as; + +create operator class pg_catalog.enum_ops default for type anyenum using hash as; + +create operator class pg_catalog.interval_bloom_ops for type interval using brin as storage interval; + +create operator class pg_catalog.interval_minmax_multi_ops for type interval using brin as storage interval; + +create operator class pg_catalog.interval_minmax_ops default for type interval using brin as storage interval; + +create operator class pg_catalog.interval_ops default for type interval using btree as; + +create operator class pg_catalog.interval_ops default for type interval using hash as; + +create operator class pg_catalog.jsonb_ops default for type jsonb using btree as; + +create operator class pg_catalog.jsonb_ops default for type jsonb using gin as storage text; + +create operator class pg_catalog.jsonb_ops default for type jsonb using hash as; + +create operator class pg_catalog.jsonb_path_ops for type jsonb using gin as storage integer; + +create operator class pg_catalog.kd_point_ops for type point using spgist as; + +create operator class pg_catalog.macaddr8_bloom_ops for type macaddr8 using brin as storage macaddr8; + +create operator class pg_catalog.macaddr8_minmax_multi_ops for type macaddr8 using brin as storage macaddr8; + +create operator class pg_catalog.macaddr8_minmax_ops default for type macaddr8 using brin as storage macaddr8; + +create operator class pg_catalog.macaddr8_ops default for type macaddr8 using btree as; + +create operator class pg_catalog.macaddr8_ops default for type macaddr8 using hash as; + +create operator class pg_catalog.macaddr_bloom_ops for type macaddr using brin as storage macaddr; + +create operator class pg_catalog.macaddr_minmax_multi_ops for type macaddr using brin as storage macaddr; + +create operator class pg_catalog.macaddr_minmax_ops default for type macaddr using brin as storage macaddr; + +create operator class pg_catalog.macaddr_ops default for type macaddr using btree as; + +create operator class pg_catalog.macaddr_ops default for type macaddr using hash as; + +create operator class pg_catalog.money_ops default for type money using btree as; + +create operator class pg_catalog.multirange_ops default for type anymultirange using btree as; + +create operator class pg_catalog.multirange_ops default for type anymultirange using gist as storage anyrange; + +create operator class pg_catalog.multirange_ops default for type anymultirange using hash as; + +create operator class pg_catalog.name_bloom_ops for type name using brin as storage name; + +create operator class pg_catalog.name_minmax_ops default for type name using brin as storage name; + +create operator class pg_catalog.numeric_bloom_ops for type numeric using brin as storage numeric; + +create operator class pg_catalog.numeric_minmax_multi_ops for type numeric using brin as storage numeric; + +create operator class pg_catalog.numeric_minmax_ops default for type numeric using brin as storage numeric; + +create operator class pg_catalog.numeric_ops default for type numeric using btree as; + +create operator class pg_catalog.numeric_ops default for type numeric using hash as; + +create operator class pg_catalog.oid_bloom_ops for type oid using brin as storage oid; + +create operator class pg_catalog.oid_minmax_multi_ops for type oid using brin as storage oid; + +create operator class pg_catalog.oid_minmax_ops default for type oid using brin as storage oid; + +create operator class pg_catalog.oid_ops default for type oid using btree as; + +create operator class pg_catalog.oid_ops default for type oid using hash as; + +create operator class pg_catalog.oidvector_ops default for type oidvector using btree as; + +create operator class pg_catalog.oidvector_ops default for type oidvector using hash as; + +create operator class pg_catalog.pg_lsn_bloom_ops for type pg_lsn using brin as storage pg_lsn; + +create operator class pg_catalog.pg_lsn_minmax_multi_ops for type pg_lsn using brin as storage pg_lsn; + +create operator class pg_catalog.pg_lsn_minmax_ops default for type pg_lsn using brin as storage pg_lsn; + +create operator class pg_catalog.pg_lsn_ops default for type pg_lsn using btree as; + +create operator class pg_catalog.pg_lsn_ops default for type pg_lsn using hash as; + +create operator class pg_catalog.point_ops default for type point using gist as storage box; + +create operator class pg_catalog.poly_ops default for type polygon using gist as storage box; + +create operator class pg_catalog.poly_ops default for type polygon using spgist as storage box; + +create operator class pg_catalog.quad_point_ops default for type point using spgist as; + +create operator class pg_catalog.range_inclusion_ops default for type anyrange using brin as storage anyrange; + +create operator class pg_catalog.range_ops default for type anyrange using btree as; + +create operator class pg_catalog.range_ops default for type anyrange using gist as; + +create operator class pg_catalog.range_ops default for type anyrange using hash as; + +create operator class pg_catalog.range_ops default for type anyrange using spgist as; + +create operator class pg_catalog.record_image_ops for type record using btree as; + +create operator class pg_catalog.record_ops default for type record using btree as; + +create operator class pg_catalog.record_ops default for type record using hash as; + +create operator class pg_catalog.text_bloom_ops for type text using brin as storage text; + +create operator class pg_catalog.text_minmax_ops default for type text using brin as storage text; + +create operator class pg_catalog.text_pattern_ops for type text using btree as; + +create operator class pg_catalog.text_pattern_ops for type text using hash as; + +create operator class pg_catalog.tid_bloom_ops for type tid using brin as storage tid; + +create operator class pg_catalog.tid_minmax_multi_ops for type tid using brin as storage tid; + +create operator class pg_catalog.tid_minmax_ops default for type tid using brin as storage tid; + +create operator class pg_catalog.tid_ops default for type tid using btree as; + +create operator class pg_catalog.tid_ops default for type tid using hash as; + +create operator class pg_catalog.time_bloom_ops for type time without time zone using brin as storage time without time zone; + +create operator class pg_catalog.time_minmax_multi_ops for type time without time zone using brin as storage time without time zone; + +create operator class pg_catalog.time_minmax_ops default for type time without time zone using brin as storage time without time zone; + +create operator class pg_catalog.time_ops default for type time without time zone using btree as; + +create operator class pg_catalog.time_ops default for type time without time zone using hash as; + +create operator class pg_catalog.timestamp_ops default for type timestamp without time zone using hash as; + +create operator class pg_catalog.timestamptz_ops default for type timestamp with time zone using hash as; + +create operator class pg_catalog.timetz_bloom_ops for type time with time zone using brin as storage time with time zone; + +create operator class pg_catalog.timetz_minmax_multi_ops for type time with time zone using brin as storage time with time zone; + +create operator class pg_catalog.timetz_minmax_ops default for type time with time zone using brin as storage time with time zone; + +create operator class pg_catalog.timetz_ops default for type time with time zone using btree as; + +create operator class pg_catalog.timetz_ops default for type time with time zone using hash as; + +create operator class pg_catalog.tsquery_ops default for type tsquery using btree as; + +create operator class pg_catalog.tsquery_ops default for type tsquery using gist as storage bigint; + +create operator class pg_catalog.tsvector_ops default for type tsvector using btree as; + +create operator class pg_catalog.tsvector_ops default for type tsvector using gin as storage text; + +create operator class pg_catalog.tsvector_ops default for type tsvector using gist as storage gtsvector; + +create operator class pg_catalog.uuid_bloom_ops for type uuid using brin as storage uuid; + +create operator class pg_catalog.uuid_minmax_multi_ops for type uuid using brin as storage uuid; + +create operator class pg_catalog.uuid_minmax_ops default for type uuid using brin as storage uuid; + +create operator class pg_catalog.uuid_ops default for type uuid using btree as; + +create operator class pg_catalog.uuid_ops default for type uuid using hash as; + +create operator class pg_catalog.varbit_minmax_ops default for type bit varying using brin as storage bit varying; + +create operator class pg_catalog.varbit_ops default for type bit varying using btree as; + +create operator class pg_catalog.varchar_pattern_ops for type text using btree family pg_catalog.text_pattern_ops as; + +create operator class pg_catalog.varchar_pattern_ops for type text using hash family pg_catalog.text_pattern_ops as; + +create operator class pg_catalog.xid8_ops default for type xid8 using btree as; + +create operator class pg_catalog.xid8_ops default for type xid8 using hash as; + +create operator class pg_catalog.xid_ops default for type xid using hash as; + +create operator family pg_catalog.array_ops using gin; + +create operator family pg_catalog.array_ops using hash; + +create operator family pg_catalog.bool_ops using hash; + +create operator family pg_catalog.box_ops using spgist; + +create operator family pg_catalog.bpchar_ops using hash; + +create operator family pg_catalog.bpchar_pattern_ops using hash; + +create operator family pg_catalog.bytea_ops using hash; + +create operator family pg_catalog.char_ops using hash; + +create operator family pg_catalog.datetime_bloom_ops using brin; + +create operator class pg_catalog.date_bloom_ops for type date using brin family pg_catalog.datetime_bloom_ops as storage date; + +create operator class pg_catalog.timestamp_bloom_ops for type timestamp without time zone using brin family pg_catalog.datetime_bloom_ops as storage timestamp without time zone; + +create operator class pg_catalog.timestamptz_bloom_ops for type timestamp with time zone using brin family pg_catalog.datetime_bloom_ops as storage timestamp with time zone; + +create operator family pg_catalog.datetime_minmax_multi_ops using brin; + +create operator class pg_catalog.date_minmax_multi_ops for type date using brin family pg_catalog.datetime_minmax_multi_ops as storage date; + +create operator class pg_catalog.timestamp_minmax_multi_ops for type timestamp without time zone using brin family pg_catalog.datetime_minmax_multi_ops as storage timestamp without time zone; + +create operator class pg_catalog.timestamptz_minmax_multi_ops for type timestamp with time zone using brin family pg_catalog.datetime_minmax_multi_ops as storage timestamp with time zone; + +create operator family pg_catalog.datetime_minmax_ops using brin; + +create operator class pg_catalog.date_minmax_ops default for type date using brin family pg_catalog.datetime_minmax_ops as storage date; + +create operator class pg_catalog.timestamp_minmax_ops default for type timestamp without time zone using brin family pg_catalog.datetime_minmax_ops as storage timestamp without time zone; + +create operator class pg_catalog.timestamptz_minmax_ops default for type timestamp with time zone using brin family pg_catalog.datetime_minmax_ops as storage timestamp with time zone; + +create operator family pg_catalog.datetime_ops using btree; + +create operator class pg_catalog.date_ops default for type date using btree family pg_catalog.datetime_ops as; + +create operator class pg_catalog.timestamp_ops default for type timestamp without time zone using btree family pg_catalog.datetime_ops as; + +create operator class pg_catalog.timestamptz_ops default for type timestamp with time zone using btree family pg_catalog.datetime_ops as; + +create operator family pg_catalog.enum_ops using hash; + +create operator family pg_catalog.float_bloom_ops using brin; + +create operator class pg_catalog.float4_bloom_ops for type real using brin family pg_catalog.float_bloom_ops as storage real; + +create operator class pg_catalog.float8_bloom_ops for type double precision using brin family pg_catalog.float_bloom_ops as storage double precision; + +create operator family pg_catalog.float_minmax_multi_ops using brin; + +create operator class pg_catalog.float4_minmax_multi_ops for type real using brin family pg_catalog.float_minmax_multi_ops as storage real; + +create operator class pg_catalog.float8_minmax_multi_ops for type double precision using brin family pg_catalog.float_minmax_multi_ops as storage double precision; + +create operator family pg_catalog.float_minmax_ops using brin; + +create operator class pg_catalog.float4_minmax_ops default for type real using brin family pg_catalog.float_minmax_ops as storage real; + +create operator class pg_catalog.float8_minmax_ops default for type double precision using brin family pg_catalog.float_minmax_ops as storage double precision; + +create operator family pg_catalog.float_ops using btree; + +create operator class pg_catalog.float4_ops default for type real using btree family pg_catalog.float_ops as; + +create operator class pg_catalog.float4_ops default for type real using hash family pg_catalog.float_ops as; + +create operator class pg_catalog.float8_ops default for type double precision using btree family pg_catalog.float_ops as; + +create operator class pg_catalog.float8_ops default for type double precision using hash family pg_catalog.float_ops as; + +create operator family pg_catalog.float_ops using hash; + +create operator family pg_catalog.integer_bloom_ops using brin; + +create operator class pg_catalog.int2_bloom_ops for type smallint using brin family pg_catalog.integer_bloom_ops as storage smallint; + +create operator class pg_catalog.int4_bloom_ops for type integer using brin family pg_catalog.integer_bloom_ops as storage integer; + +create operator class pg_catalog.int8_bloom_ops for type bigint using brin family pg_catalog.integer_bloom_ops as storage bigint; + +create operator family pg_catalog.integer_minmax_multi_ops using brin; + +create operator class pg_catalog.int2_minmax_multi_ops for type smallint using brin family pg_catalog.integer_minmax_multi_ops as storage smallint; + +create operator class pg_catalog.int4_minmax_multi_ops for type integer using brin family pg_catalog.integer_minmax_multi_ops as storage integer; + +create operator class pg_catalog.int8_minmax_multi_ops for type bigint using brin family pg_catalog.integer_minmax_multi_ops as storage bigint; + +create operator family pg_catalog.integer_minmax_ops using brin; + +create operator class pg_catalog.int2_minmax_ops default for type smallint using brin family pg_catalog.integer_minmax_ops as storage smallint; + +create operator class pg_catalog.int4_minmax_ops default for type integer using brin family pg_catalog.integer_minmax_ops as storage integer; + +create operator class pg_catalog.int8_minmax_ops default for type bigint using brin family pg_catalog.integer_minmax_ops as storage bigint; + +create operator family pg_catalog.integer_ops using btree; + +create operator class pg_catalog.int2_ops default for type smallint using btree family pg_catalog.integer_ops as; + +create operator class pg_catalog.int2_ops default for type smallint using hash family pg_catalog.integer_ops as; + +create operator class pg_catalog.int4_ops default for type integer using btree family pg_catalog.integer_ops as; + +create operator class pg_catalog.int4_ops default for type integer using hash family pg_catalog.integer_ops as; + +create operator class pg_catalog.int8_ops default for type bigint using btree family pg_catalog.integer_ops as; + +create operator class pg_catalog.int8_ops default for type bigint using hash family pg_catalog.integer_ops as; + +create operator family pg_catalog.integer_ops using hash; + +create operator family pg_catalog.interval_ops using hash; + +create operator family pg_catalog.jsonb_ops using gin; + +create operator family pg_catalog.jsonb_ops using hash; + +create operator family pg_catalog.macaddr8_ops using hash; + +create operator family pg_catalog.macaddr_ops using hash; + +create operator family pg_catalog.multirange_ops using gist; + +create operator family pg_catalog.multirange_ops using hash; + +create operator family pg_catalog.network_bloom_ops using brin; + +create operator class pg_catalog.inet_bloom_ops for type inet using brin family pg_catalog.network_bloom_ops as storage inet; + +create operator family pg_catalog.network_inclusion_ops using brin; + +create operator class pg_catalog.inet_inclusion_ops default for type inet using brin family pg_catalog.network_inclusion_ops as storage inet; + +create operator family pg_catalog.network_minmax_multi_ops using brin; + +create operator class pg_catalog.inet_minmax_multi_ops for type inet using brin family pg_catalog.network_minmax_multi_ops as storage inet; + +create operator family pg_catalog.network_minmax_ops using brin; + +create operator class pg_catalog.inet_minmax_ops for type inet using brin family pg_catalog.network_minmax_ops as storage inet; + +create operator family pg_catalog.network_ops using btree; + +create operator class pg_catalog.cidr_ops for type inet using btree family pg_catalog.network_ops as; + +create operator class pg_catalog.cidr_ops for type inet using hash family pg_catalog.network_ops as; + +create operator class pg_catalog.inet_ops default for type inet using btree family pg_catalog.network_ops as; + +create operator class pg_catalog.inet_ops for type inet using gist family pg_catalog.network_ops as; + +create operator class pg_catalog.inet_ops default for type inet using hash family pg_catalog.network_ops as; + +create operator class pg_catalog.inet_ops default for type inet using spgist family pg_catalog.network_ops as; + +create operator family pg_catalog.network_ops using gist; + +create operator family pg_catalog.network_ops using hash; + +create operator family pg_catalog.network_ops using spgist; + +create operator family pg_catalog.numeric_ops using hash; + +create operator family pg_catalog.oid_ops using hash; + +create operator family pg_catalog.oidvector_ops using hash; + +create operator family pg_catalog.pg_lsn_ops using hash; + +create operator family pg_catalog.poly_ops using spgist; + +create operator family pg_catalog.range_ops using gist; + +create operator family pg_catalog.range_ops using hash; + +create operator family pg_catalog.range_ops using spgist; + +create operator family pg_catalog.record_ops using hash; + +create operator family pg_catalog.text_ops using btree; + +create operator class pg_catalog.name_ops default for type name using btree family pg_catalog.text_ops as storage cstring; + +create operator class pg_catalog.name_ops default for type name using hash family pg_catalog.text_ops as; + +create operator class pg_catalog.text_ops default for type text using btree as; + +create operator class pg_catalog.text_ops default for type text using hash as; + +create operator class pg_catalog.text_ops default for type text using spgist as; + +create operator class pg_catalog.varchar_ops for type text using btree family pg_catalog.text_ops as; + +create operator class pg_catalog.varchar_ops for type text using hash family pg_catalog.text_ops as; + +create operator family pg_catalog.text_ops using hash; + +create operator family pg_catalog.text_ops using spgist; + +create operator family pg_catalog.text_pattern_ops using hash; + +create operator family pg_catalog.tid_ops using hash; + +create operator family pg_catalog.time_ops using hash; + +create operator family pg_catalog.timetz_ops using hash; + +create operator family pg_catalog.tsquery_ops using gist; + +create operator family pg_catalog.tsvector_ops using gin; + +create operator family pg_catalog.tsvector_ops using gist; + +create operator family pg_catalog.uuid_ops using hash; + +create operator family pg_catalog.xid8_ops using btree; + +-- Cyclic dependencies found + +create aggregate pg_catalog.bool_and(boolean) ( + sfunc = booland_statefunc, + stype = boolean, + combinefunc = booland_statefunc, + msfunc = bool_accum, + minvfunc = bool_accum_inv, + mstype = internal, + mfinalfunc = bool_alltrue, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.bool_and(boolean) is 'boolean-and aggregate'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.bool_or(boolean) ( + sfunc = boolor_statefunc, + stype = boolean, + combinefunc = boolor_statefunc, + msfunc = bool_accum, + minvfunc = bool_accum_inv, + mstype = internal, + mfinalfunc = bool_anytrue, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.bool_or(boolean) is 'boolean-or aggregate'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.every(boolean) ( + sfunc = booland_statefunc, + stype = boolean, + combinefunc = booland_statefunc, + msfunc = bool_accum, + minvfunc = bool_accum_inv, + mstype = internal, + mfinalfunc = bool_alltrue, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.every(boolean) is 'boolean-and aggregate'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(anyarray) ( + sfunc = array_larger, + stype = anyarray, + combinefunc = array_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(anyarray) is 'maximum value of all anyarray input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(bigint) ( + sfunc = int8larger, + stype = bigint, + combinefunc = int8larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(bigint) is 'maximum value of all bigint input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(char) ( + sfunc = bpchar_larger, + stype = char, + combinefunc = bpchar_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(char) is 'maximum value of all bpchar input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(date) ( + sfunc = date_larger, + stype = date, + combinefunc = date_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(date) is 'maximum value of all date input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(anyenum) ( + sfunc = enum_larger, + stype = anyenum, + combinefunc = enum_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(anyenum) is 'maximum value of all enum input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(real) ( + sfunc = float4larger, + stype = real, + combinefunc = float4larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(real) is 'maximum value of all float4 input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(double precision) ( + sfunc = float8larger, + stype = double precision, + combinefunc = float8larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(double precision) is 'maximum value of all float8 input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(inet) ( + sfunc = network_larger, + stype = inet, + combinefunc = network_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(inet) is 'maximum value of all inet input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(integer) ( + sfunc = int4larger, + stype = integer, + combinefunc = int4larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(integer) is 'maximum value of all integer input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(interval) ( + sfunc = interval_larger, + stype = interval, + combinefunc = interval_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(interval) is 'maximum value of all interval input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(money) ( + sfunc = cashlarger, + stype = money, + combinefunc = cashlarger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(money) is 'maximum value of all money input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(numeric) ( + sfunc = numeric_larger, + stype = numeric, + combinefunc = numeric_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(numeric) is 'maximum value of all numeric input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(oid) ( + sfunc = oidlarger, + stype = oid, + combinefunc = oidlarger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(oid) is 'maximum value of all oid input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(smallint) ( + sfunc = int2larger, + stype = smallint, + combinefunc = int2larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(smallint) is 'maximum value of all smallint input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(text) ( + sfunc = text_larger, + stype = text, + combinefunc = text_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(text) is 'maximum value of all text input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(tid) ( + sfunc = tidlarger, + stype = tid, + combinefunc = tidlarger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(tid) is 'maximum value of all tid input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(time) ( + sfunc = time_larger, + stype = time, + combinefunc = time_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(time) is 'maximum value of all time input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(time with time zone) ( + sfunc = timetz_larger, + stype = time with time zone, + combinefunc = timetz_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(time with time zone) is 'maximum value of all time with time zone input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(timestamp) ( + sfunc = timestamp_larger, + stype = timestamp, + combinefunc = timestamp_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(timestamp) is 'maximum value of all timestamp input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(timestamp with time zone) ( + sfunc = timestamptz_larger, + stype = timestamp with time zone, + combinefunc = timestamptz_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(timestamp with time zone) is 'maximum value of all timestamp with time zone input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(pg_lsn) ( + sfunc = pg_lsn_larger, + stype = pg_lsn, + combinefunc = pg_lsn_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(pg_lsn) is 'maximum value of all pg_lsn input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.max(xid8) ( + sfunc = xid8_larger, + stype = xid8, + combinefunc = xid8_larger, + sortop = operator (>) + ); + +comment on aggregate pg_catalog.max(xid8) is 'maximum value of all xid8 input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(anyarray) ( + sfunc = array_smaller, + stype = anyarray, + combinefunc = array_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(anyarray) is 'minimum value of all anyarray input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(bigint) ( + sfunc = int8smaller, + stype = bigint, + combinefunc = int8smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(bigint) is 'minimum value of all bigint input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(char) ( + sfunc = bpchar_smaller, + stype = char, + combinefunc = bpchar_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(char) is 'minimum value of all bpchar input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(date) ( + sfunc = date_smaller, + stype = date, + combinefunc = date_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(date) is 'minimum value of all date input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(anyenum) ( + sfunc = enum_smaller, + stype = anyenum, + combinefunc = enum_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(anyenum) is 'minimum value of all enum input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(real) ( + sfunc = float4smaller, + stype = real, + combinefunc = float4smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(real) is 'minimum value of all float4 input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(double precision) ( + sfunc = float8smaller, + stype = double precision, + combinefunc = float8smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(double precision) is 'minimum value of all float8 input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(inet) ( + sfunc = network_smaller, + stype = inet, + combinefunc = network_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(inet) is 'minimum value of all inet input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(integer) ( + sfunc = int4smaller, + stype = integer, + combinefunc = int4smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(integer) is 'minimum value of all integer input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(interval) ( + sfunc = interval_smaller, + stype = interval, + combinefunc = interval_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(interval) is 'minimum value of all interval input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(money) ( + sfunc = cashsmaller, + stype = money, + combinefunc = cashsmaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(money) is 'minimum value of all money input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(numeric) ( + sfunc = numeric_smaller, + stype = numeric, + combinefunc = numeric_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(numeric) is 'minimum value of all numeric input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(oid) ( + sfunc = oidsmaller, + stype = oid, + combinefunc = oidsmaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(oid) is 'minimum value of all oid input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(smallint) ( + sfunc = int2smaller, + stype = smallint, + combinefunc = int2smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(smallint) is 'minimum value of all smallint input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(text) ( + sfunc = text_smaller, + stype = text, + combinefunc = text_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(text) is 'minimum value of all text values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(tid) ( + sfunc = tidsmaller, + stype = tid, + combinefunc = tidsmaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(tid) is 'minimum value of all tid input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(time) ( + sfunc = time_smaller, + stype = time, + combinefunc = time_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(time) is 'minimum value of all time input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(time with time zone) ( + sfunc = timetz_smaller, + stype = time with time zone, + combinefunc = timetz_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(time with time zone) is 'minimum value of all time with time zone input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(timestamp) ( + sfunc = timestamp_smaller, + stype = timestamp, + combinefunc = timestamp_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(timestamp) is 'minimum value of all timestamp input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(timestamp with time zone) ( + sfunc = timestamptz_smaller, + stype = timestamp with time zone, + combinefunc = timestamptz_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(timestamp with time zone) is 'minimum value of all timestamp with time zone input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(pg_lsn) ( + sfunc = pg_lsn_smaller, + stype = pg_lsn, + combinefunc = pg_lsn_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(pg_lsn) is 'minimum value of all pg_lsn input values'; + +-- Cyclic dependencies found + +create aggregate pg_catalog.min(xid8) ( + sfunc = xid8_smaller, + stype = xid8, + combinefunc = xid8_smaller, + sortop = operator (<) + ); + +comment on aggregate pg_catalog.min(xid8) is 'minimum value of all xid8 input values'; + +-- Cyclic dependencies found + +create operator pg_catalog.!~ (procedure = pg_catalog.bpcharregexne, leftarg = char, rightarg = text, negator = pg_catalog.~, join = pg_catalog.regexnejoinsel, restrict = pg_catalog.regexnesel); + +comment on operator pg_catalog.!~(char, text) is 'does not match regular expression, case-sensitive'; + +create operator pg_catalog.~ (procedure = pg_catalog.bpcharregexeq, leftarg = char, rightarg = text, negator = pg_catalog.!~, join = pg_catalog.regexeqjoinsel, restrict = pg_catalog.regexeqsel); + +comment on operator pg_catalog.~(char, text) is 'matches regular expression, case-sensitive'; + +create operator pg_catalog.!~ (procedure = pg_catalog.nameregexne, leftarg = name, rightarg = text, negator = pg_catalog.~, join = pg_catalog.regexnejoinsel, restrict = pg_catalog.regexnesel); + +comment on operator pg_catalog.!~(name, text) is 'does not match regular expression, case-sensitive'; + +create operator pg_catalog.!~ (procedure = pg_catalog.textregexne, leftarg = text, rightarg = text, negator = pg_catalog.~, join = pg_catalog.regexnejoinsel, restrict = pg_catalog.regexnesel); + +comment on operator pg_catalog.!~(text, text) is 'does not match regular expression, case-sensitive'; + +create operator pg_catalog.~ (procedure = pg_catalog.nameregexeq, leftarg = name, rightarg = text, negator = pg_catalog.!~, join = pg_catalog.regexeqjoinsel, restrict = pg_catalog.regexeqsel); + +comment on operator pg_catalog.~(name, text) is 'matches regular expression, case-sensitive'; + +create operator pg_catalog.~ (procedure = pg_catalog.textregexeq, leftarg = text, rightarg = text, negator = pg_catalog.!~, join = pg_catalog.regexeqjoinsel, restrict = pg_catalog.regexeqsel); + +comment on operator pg_catalog.~(text, text) is 'matches regular expression, case-sensitive'; + +-- Cyclic dependencies found + +create operator pg_catalog.!~* (procedure = pg_catalog.bpcharicregexne, leftarg = char, rightarg = text, negator = pg_catalog.~*, join = pg_catalog.icregexnejoinsel, restrict = pg_catalog.icregexnesel); + +comment on operator pg_catalog.!~*(char, text) is 'does not match regular expression, case-insensitive'; + +create operator pg_catalog.~* (procedure = pg_catalog.bpcharicregexeq, leftarg = char, rightarg = text, negator = pg_catalog.!~*, join = pg_catalog.icregexeqjoinsel, restrict = pg_catalog.icregexeqsel); + +comment on operator pg_catalog.~*(char, text) is 'matches regular expression, case-insensitive'; + +create operator pg_catalog.!~* (procedure = pg_catalog.nameicregexne, leftarg = name, rightarg = text, negator = pg_catalog.~*, join = pg_catalog.icregexnejoinsel, restrict = pg_catalog.icregexnesel); + +comment on operator pg_catalog.!~*(name, text) is 'does not match regular expression, case-insensitive'; + +create operator pg_catalog.!~* (procedure = pg_catalog.texticregexne, leftarg = text, rightarg = text, negator = pg_catalog.~*, join = pg_catalog.icregexnejoinsel, restrict = pg_catalog.icregexnesel); + +comment on operator pg_catalog.!~*(text, text) is 'does not match regular expression, case-insensitive'; + +create operator pg_catalog.~* (procedure = pg_catalog.nameicregexeq, leftarg = name, rightarg = text, negator = pg_catalog.!~*, join = pg_catalog.icregexeqjoinsel, restrict = pg_catalog.icregexeqsel); + +comment on operator pg_catalog.~*(name, text) is 'matches regular expression, case-insensitive'; + +create operator pg_catalog.~* (procedure = pg_catalog.texticregexeq, leftarg = text, rightarg = text, negator = pg_catalog.!~*, join = pg_catalog.icregexeqjoinsel, restrict = pg_catalog.icregexeqsel); + +comment on operator pg_catalog.~*(text, text) is 'matches regular expression, case-insensitive'; + +-- Cyclic dependencies found + +create operator pg_catalog.!~~ (procedure = pg_catalog.byteanlike, leftarg = bytea, rightarg = bytea, negator = pg_catalog.~~, join = pg_catalog.nlikejoinsel, restrict = pg_catalog.nlikesel); + +comment on operator pg_catalog.!~~(bytea, bytea) is 'does not match LIKE expression'; + +create operator pg_catalog.~~ (procedure = pg_catalog.bytealike, leftarg = bytea, rightarg = bytea, negator = pg_catalog.!~~, join = pg_catalog.likejoinsel, restrict = pg_catalog.likesel); + +comment on operator pg_catalog.~~(bytea, bytea) is 'matches LIKE expression'; + +create operator pg_catalog.!~~ (procedure = pg_catalog.bpcharnlike, leftarg = char, rightarg = text, negator = pg_catalog.~~, join = pg_catalog.nlikejoinsel, restrict = pg_catalog.nlikesel); + +comment on operator pg_catalog.!~~(char, text) is 'does not match LIKE expression'; + +create operator pg_catalog.!~~ (procedure = pg_catalog.namenlike, leftarg = name, rightarg = text, negator = pg_catalog.~~, join = pg_catalog.nlikejoinsel, restrict = pg_catalog.nlikesel); + +comment on operator pg_catalog.!~~(name, text) is 'does not match LIKE expression'; + +create operator pg_catalog.!~~ (procedure = pg_catalog.textnlike, leftarg = text, rightarg = text, negator = pg_catalog.~~, join = pg_catalog.nlikejoinsel, restrict = pg_catalog.nlikesel); + +comment on operator pg_catalog.!~~(text, text) is 'does not match LIKE expression'; + +create operator pg_catalog.~~ (procedure = pg_catalog.bpcharlike, leftarg = char, rightarg = text, negator = pg_catalog.!~~, join = pg_catalog.likejoinsel, restrict = pg_catalog.likesel); + +comment on operator pg_catalog.~~(char, text) is 'matches LIKE expression'; + +create operator pg_catalog.~~ (procedure = pg_catalog.namelike, leftarg = name, rightarg = text, negator = pg_catalog.!~~, join = pg_catalog.likejoinsel, restrict = pg_catalog.likesel); + +comment on operator pg_catalog.~~(name, text) is 'matches LIKE expression'; + +create operator pg_catalog.~~ (procedure = pg_catalog.textlike, leftarg = text, rightarg = text, negator = pg_catalog.!~~, join = pg_catalog.likejoinsel, restrict = pg_catalog.likesel); + +comment on operator pg_catalog.~~(text, text) is 'matches LIKE expression'; + +-- Cyclic dependencies found + +create operator pg_catalog.!~~* (procedure = pg_catalog.bpcharicnlike, leftarg = char, rightarg = text, negator = pg_catalog.~~*, join = pg_catalog.icnlikejoinsel, restrict = pg_catalog.icnlikesel); + +comment on operator pg_catalog.!~~*(char, text) is 'does not match LIKE expression, case-insensitive'; + +create operator pg_catalog.~~* (procedure = pg_catalog.bpchariclike, leftarg = char, rightarg = text, negator = pg_catalog.!~~*, join = pg_catalog.iclikejoinsel, restrict = pg_catalog.iclikesel); + +comment on operator pg_catalog.~~*(char, text) is 'matches LIKE expression, case-insensitive'; + +create operator pg_catalog.!~~* (procedure = pg_catalog.nameicnlike, leftarg = name, rightarg = text, negator = pg_catalog.~~*, join = pg_catalog.icnlikejoinsel, restrict = pg_catalog.icnlikesel); + +comment on operator pg_catalog.!~~*(name, text) is 'does not match LIKE expression, case-insensitive'; + +create operator pg_catalog.!~~* (procedure = pg_catalog.texticnlike, leftarg = text, rightarg = text, negator = pg_catalog.~~*, join = pg_catalog.icnlikejoinsel, restrict = pg_catalog.icnlikesel); + +comment on operator pg_catalog.!~~*(text, text) is 'does not match LIKE expression, case-insensitive'; + +create operator pg_catalog.~~* (procedure = pg_catalog.nameiclike, leftarg = name, rightarg = text, negator = pg_catalog.!~~*, join = pg_catalog.iclikejoinsel, restrict = pg_catalog.iclikesel); + +comment on operator pg_catalog.~~*(name, text) is 'matches LIKE expression, case-insensitive'; + +create operator pg_catalog.~~* (procedure = pg_catalog.texticlike, leftarg = text, rightarg = text, negator = pg_catalog.!~~*, join = pg_catalog.iclikejoinsel, restrict = pg_catalog.iclikesel); + +comment on operator pg_catalog.~~*(text, text) is 'matches LIKE expression, case-insensitive'; + +-- Cyclic dependencies found + +create operator pg_catalog.*<> (procedure = pg_catalog.record_image_ne, leftarg = record, rightarg = record, commutator = pg_catalog.*<>, negator = pg_catalog.*=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.*<>(record, record) is 'not identical'; + +create operator pg_catalog.*= (procedure = pg_catalog.record_image_eq, leftarg = record, rightarg = record, commutator = pg_catalog.*=, negator = pg_catalog.*<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.*=(record, record) is 'identical'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.path_n_lt, leftarg = path, rightarg = path, commutator = pg_catalog.>); + +comment on operator pg_catalog.<(path, path) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.<< (procedure = pg_catalog.multirange_before_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.>>, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<<(anymultirange, anymultirange) is 'is left of'; + +create operator pg_catalog.>> (procedure = pg_catalog.multirange_after_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.<<, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.>>(anymultirange, anymultirange) is 'is right of'; + +create operator pg_catalog.<< (procedure = pg_catalog.multirange_before_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.>>, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<<(anymultirange, anyrange) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.range_before_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.>>, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<<(anyrange, anymultirange) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.range_before, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.>>, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.<<(anyrange, anyrange) is 'is left of'; + +create operator pg_catalog.<< (procedure = pg_catalog.network_sub, leftarg = inet, rightarg = inet, commutator = pg_catalog.>>, join = pg_catalog.networkjoinsel, restrict = pg_catalog.networksel); + +comment on operator pg_catalog.<<(inet, inet) is 'is subnet'; + +create operator pg_catalog.>> (procedure = pg_catalog.multirange_after_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.<<, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.>>(anymultirange, anyrange) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.range_after_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.<<, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.>>(anyrange, anymultirange) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.range_after, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.<<, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.>>(anyrange, anyrange) is 'is right of'; + +create operator pg_catalog.>> (procedure = pg_catalog.network_sup, leftarg = inet, rightarg = inet, commutator = pg_catalog.<<, join = pg_catalog.networkjoinsel, restrict = pg_catalog.networksel); + +comment on operator pg_catalog.>>(inet, inet) is 'is supernet'; + +-- Cyclic dependencies found + +create operator pg_catalog.<<= (procedure = pg_catalog.network_subeq, leftarg = inet, rightarg = inet, commutator = pg_catalog.>>=, join = pg_catalog.networkjoinsel, restrict = pg_catalog.networksel); + +comment on operator pg_catalog.<<=(inet, inet) is 'is subnet or equal'; + +create operator pg_catalog.>>= (procedure = pg_catalog.network_supeq, leftarg = inet, rightarg = inet, commutator = pg_catalog.<<=, join = pg_catalog.networkjoinsel, restrict = pg_catalog.networksel); + +comment on operator pg_catalog.>>=(inet, inet) is 'is supernet or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<= (procedure = pg_catalog.path_n_le, leftarg = path, rightarg = path, commutator = pg_catalog.>=); + +comment on operator pg_catalog.<=(path, path) is 'less than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.charne, leftarg = "char", rightarg = "char", commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>("char", "char") is 'not equal'; + +create operator pg_catalog.= (procedure = pg_catalog.chareq, leftarg = "char", rightarg = "char", commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=("char", "char") is 'equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.array_ne, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(anyarray, anyarray) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.enum_ne, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(anyenum, anyenum) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int8ne, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bigint, bigint) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int84ne, leftarg = bigint, rightarg = integer, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bigint, integer) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int82ne, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bigint, smallint) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.varbitne, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bit varying, bit varying) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.bitne, leftarg = bit, rightarg = bit, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bit, bit) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.boolne, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(boolean, boolean) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.byteane, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(bytea, bytea) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.bpcharne, leftarg = char, rightarg = char, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(char, char) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.date_ne, leftarg = date, rightarg = date, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(date, date) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.date_ne_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(date, timestamp with time zone) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.date_ne_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(date, timestamp) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.float8ne, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(double precision, double precision) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.float84ne, leftarg = double precision, rightarg = real, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(double precision, real) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.network_ne, leftarg = inet, rightarg = inet, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(inet, inet) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int48ne, leftarg = integer, rightarg = bigint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(integer, bigint) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int4ne, leftarg = integer, rightarg = integer, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(integer, integer) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.int42ne, leftarg = integer, rightarg = smallint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(integer, smallint) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.interval_ne, leftarg = interval, rightarg = interval, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(interval, interval) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.lseg_ne, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(lseg, lseg) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.macaddr_ne, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(macaddr, macaddr) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.cash_ne, leftarg = money, rightarg = money, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(money, money) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.namene, leftarg = name, rightarg = name, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(name, name) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.numeric_ne, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(numeric, numeric) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.oidne, leftarg = oid, rightarg = oid, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(oid, oid) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.oidvectorne, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(oidvector, oidvector) is 'not equal'; + +create operator pg_catalog.= (procedure = pg_catalog.aclitemeq, leftarg = aclitem, rightarg = aclitem, commutator = pg_catalog.=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes); + +comment on operator pg_catalog.=(aclitem, aclitem) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.array_eq, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(anyarray, anyarray) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.enum_eq, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(anyenum, anyenum) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int8eq, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(bigint, bigint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int84eq, leftarg = bigint, rightarg = integer, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(bigint, integer) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int82eq, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(bigint, smallint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.booleq, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(boolean, boolean) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.box_eq, leftarg = box, rightarg = box, commutator = pg_catalog.=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(box, box) is 'equal by area'; + +create operator pg_catalog.= (procedure = pg_catalog.cideq, leftarg = cid, rightarg = cid, commutator = pg_catalog.=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes); + +comment on operator pg_catalog.=(cid, cid) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.line_eq, leftarg = line, rightarg = line, commutator = pg_catalog.=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(line, line) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.lseg_eq, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(lseg, lseg) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.cash_eq, leftarg = money, rightarg = money, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(money, money) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.path_n_eq, leftarg = path, rightarg = path, commutator = pg_catalog.=, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(path, path) is 'equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.point_ne, leftarg = point, rightarg = point, commutator = pg_catalog.<>, negator = pg_catalog.~=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(point, point) is 'not equal'; + +create operator pg_catalog.~= (procedure = pg_catalog.point_eq, leftarg = point, rightarg = point, commutator = pg_catalog.~=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.~=(point, point) is 'same as'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.float48ne, leftarg = real, rightarg = double precision, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(real, double precision) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.float4ne, leftarg = real, rightarg = real, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(real, real) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.record_ne, leftarg = record, rightarg = record, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(record, record) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.int28ne, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(smallint, bigint) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.int24ne, leftarg = smallint, rightarg = integer, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(smallint, integer) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.int2ne, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(smallint, smallint) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.textne, leftarg = text, rightarg = text, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(text, text) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.tidne, leftarg = tid, rightarg = tid, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(tid, tid) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timetz_ne, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(time with time zone, time with time zone) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamptz_ne_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp with time zone, date) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamptz_ne, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp with time zone, timestamp with time zone) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamptz_ne_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp with time zone, timestamp) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamp_ne_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp, date) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamp_ne_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp, timestamp with time zone) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.timestamp_ne, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(timestamp, timestamp) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.time_ne, leftarg = time, rightarg = time, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(time, time) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.tsquery_ne, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(tsquery, tsquery) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.tsvector_ne, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(tsvector, tsvector) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.uuid_ne, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(uuid, uuid) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.xidneqint4, leftarg = xid, rightarg = integer, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(xid, integer) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.xidneq, leftarg = xid, rightarg = xid, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(xid, xid) is 'not equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<> (procedure = pg_catalog.circle_ne, leftarg = circle, rightarg = circle, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(circle, circle) is 'not equal by area'; + +create operator pg_catalog.= (procedure = pg_catalog.multirange_eq, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(anymultirange, anymultirange) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.range_eq, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(anyrange, anyrange) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.varbiteq, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(bit varying, bit varying) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.biteq, leftarg = bit, rightarg = bit, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(bit, bit) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.byteaeq, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(bytea, bytea) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.bpchareq, leftarg = char, rightarg = char, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(char, char) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.circle_eq, leftarg = circle, rightarg = circle, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(circle, circle) is 'equal by area'; + +create operator pg_catalog.= (procedure = pg_catalog.date_eq, leftarg = date, rightarg = date, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(date, date) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.date_eq_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(date, timestamp with time zone) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.date_eq_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(date, timestamp) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.float8eq, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(double precision, double precision) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.float84eq, leftarg = double precision, rightarg = real, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(double precision, real) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.network_eq, leftarg = inet, rightarg = inet, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(inet, inet) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int48eq, leftarg = integer, rightarg = bigint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(integer, bigint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int4eq, leftarg = integer, rightarg = integer, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(integer, integer) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int42eq, leftarg = integer, rightarg = smallint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(integer, smallint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.interval_eq, leftarg = interval, rightarg = interval, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(interval, interval) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.jsonb_eq, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(jsonb, jsonb) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.macaddr_eq, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(macaddr, macaddr) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.macaddr8_eq, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(macaddr8, macaddr8) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.nameeq, leftarg = name, rightarg = name, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(name, name) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.nameeqtext, leftarg = name, rightarg = text, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(name, text) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.numeric_eq, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(numeric, numeric) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.oideq, leftarg = oid, rightarg = oid, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(oid, oid) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.oidvectoreq, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(oidvector, oidvector) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.pg_lsn_eq, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(pg_lsn, pg_lsn) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.float48eq, leftarg = real, rightarg = double precision, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(real, double precision) is 'equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.multirange_ne, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(anymultirange, anymultirange) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.range_ne, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(anyrange, anyrange) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.jsonb_ne, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(jsonb, jsonb) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.macaddr8_ne, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(macaddr8, macaddr8) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.namenetext, leftarg = name, rightarg = text, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(name, text) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.pg_lsn_ne, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(pg_lsn, pg_lsn) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.textnename, leftarg = text, rightarg = name, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(text, name) is 'not equal'; + +create operator pg_catalog.<> (procedure = pg_catalog.xid8ne, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.<>, negator = pg_catalog.=, join = pg_catalog.neqjoinsel, restrict = pg_catalog.neqsel); + +comment on operator pg_catalog.<>(xid8, xid8) is 'not equal'; + +create operator pg_catalog.= (procedure = pg_catalog.float4eq, leftarg = real, rightarg = real, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(real, real) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.record_eq, leftarg = record, rightarg = record, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(record, record) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int28eq, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(smallint, bigint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int24eq, leftarg = smallint, rightarg = integer, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(smallint, integer) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.int2eq, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(smallint, smallint) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.texteqname, leftarg = text, rightarg = name, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(text, name) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.texteq, leftarg = text, rightarg = text, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(text, text) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.tideq, leftarg = tid, rightarg = tid, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(tid, tid) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timetz_eq, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(time with time zone, time with time zone) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.time_eq, leftarg = time, rightarg = time, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(time, time) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamptz_eq_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(timestamp with time zone, date) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamptz_eq, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(timestamp with time zone, timestamp with time zone) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamptz_eq_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(timestamp with time zone, timestamp) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamp_eq_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(timestamp, date) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamp_eq_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(timestamp, timestamp with time zone) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.timestamp_eq, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(timestamp, timestamp) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.tsquery_eq, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(tsquery, tsquery) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.tsvector_eq, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, merges); + +comment on operator pg_catalog.=(tsvector, tsvector) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.uuid_eq, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(uuid, uuid) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.xideqint4, leftarg = xid, rightarg = integer, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel); + +comment on operator pg_catalog.=(xid, integer) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.xideq, leftarg = xid, rightarg = xid, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes); + +comment on operator pg_catalog.=(xid, xid) is 'equal'; + +create operator pg_catalog.= (procedure = pg_catalog.xid8eq, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.=, negator = pg_catalog.<>, join = pg_catalog.eqjoinsel, restrict = pg_catalog.eqsel, hashes, merges); + +comment on operator pg_catalog.=(xid8, xid8) is 'equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.box_contained, leftarg = box, rightarg = box, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(box, box) is 'is contained by'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.circle_contained, leftarg = circle, rightarg = circle, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(circle, circle) is 'is contained by'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.pt_contained_circle, leftarg = point, rightarg = circle, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(point, circle) is 'is contained by'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.pt_contained_poly, leftarg = point, rightarg = polygon, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(point, polygon) is 'is contained by'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.poly_contained, leftarg = polygon, rightarg = polygon, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(polygon, polygon) is 'is contained by'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.on_pb, leftarg = point, rightarg = box, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.<@(point, box) is 'point inside box'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.on_ppath, leftarg = point, rightarg = path, commutator = pg_catalog.@>); + +comment on operator pg_catalog.<@(point, path) is 'point within closed path, or point on open path'; + +-- Cyclic dependencies found + +create operator pg_catalog.<@ (procedure = pg_catalog.arraycontained, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.@>, join = pg_catalog.arraycontjoinsel, restrict = pg_catalog.arraycontsel); + +comment on operator pg_catalog.<@(anyarray, anyarray) is 'is contained by'; + +create operator pg_catalog.@> (procedure = pg_catalog.arraycontains, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.<@, join = pg_catalog.arraycontjoinsel, restrict = pg_catalog.arraycontsel); + +comment on operator pg_catalog.@>(anyarray, anyarray) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.multirange_contains_elem, leftarg = anymultirange, rightarg = anyelement, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.@>(anymultirange, anyelement) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.multirange_contains_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.@>(anymultirange, anymultirange) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.multirange_contains_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.@>(anymultirange, anyrange) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.range_contains_elem, leftarg = anyrange, rightarg = anyelement, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.@>(anyrange, anyelement) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.range_contains_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.@>(anyrange, anymultirange) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.range_contains, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.@>(anyrange, anyrange) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.box_contain, leftarg = box, rightarg = box, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(box, box) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.box_contain_pt, leftarg = box, rightarg = point, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(box, point) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.circle_contain, leftarg = circle, rightarg = circle, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(circle, circle) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.circle_contain_pt, leftarg = circle, rightarg = point, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(circle, point) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.jsonb_contains, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.<@, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@>(jsonb, jsonb) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.path_contain_pt, leftarg = path, rightarg = point, commutator = pg_catalog.<@); + +comment on operator pg_catalog.@>(path, point) is 'contains'; + +create operator pg_catalog.<@ (procedure = pg_catalog.elem_contained_by_multirange, leftarg = anyelement, rightarg = anymultirange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<@(anyelement, anymultirange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.elem_contained_by_range, leftarg = anyelement, rightarg = anyrange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.<@(anyelement, anyrange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.multirange_contained_by_multirange, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<@(anymultirange, anymultirange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.multirange_contained_by_range, leftarg = anymultirange, rightarg = anyrange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<@(anymultirange, anyrange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.range_contained_by_multirange, leftarg = anyrange, rightarg = anymultirange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<@(anyrange, anymultirange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.range_contained_by, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.@>, join = pg_catalog.contjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.<@(anyrange, anyrange) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.jsonb_contained, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.@>, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.<@(jsonb, jsonb) is 'is contained by'; + +create operator pg_catalog.<@ (procedure = pg_catalog.tsq_mcontained, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.@>, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.<@(tsquery, tsquery) is 'is contained by'; + +create operator pg_catalog.@> (procedure = pg_catalog.poly_contain_pt, leftarg = polygon, rightarg = point, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(polygon, point) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.poly_contain, leftarg = polygon, rightarg = polygon, commutator = pg_catalog.<@, join = pg_catalog.contjoinsel, restrict = pg_catalog.contsel); + +comment on operator pg_catalog.@>(polygon, polygon) is 'contains'; + +create operator pg_catalog.@> (procedure = pg_catalog.tsq_mcontains, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.<@, join = pg_catalog.matchingjoinsel, restrict = pg_catalog.matchingsel); + +comment on operator pg_catalog.@>(tsquery, tsquery) is 'contains'; + +-- Cyclic dependencies found + +create operator pg_catalog.> (procedure = pg_catalog.path_n_gt, leftarg = path, rightarg = path, commutator = pg_catalog.<); + +comment on operator pg_catalog.>(path, path) is 'greater than'; + +-- Cyclic dependencies found + +create operator pg_catalog.>= (procedure = pg_catalog.path_n_ge, leftarg = path, rightarg = path, commutator = pg_catalog.<=); + +comment on operator pg_catalog.>=(path, path) is 'greater than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.*< (procedure = pg_catalog.record_image_lt, leftarg = record, rightarg = record, commutator = pg_catalog.*>, negator = pg_catalog.*>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.*<(record, record) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.*> (procedure = pg_catalog.record_image_gt, leftarg = record, rightarg = record, commutator = pg_catalog.*<, negator = pg_catalog.*<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.*>(record, record) is 'greater than'; + +-- Cyclic dependencies found + +create operator pg_catalog.*<= (procedure = pg_catalog.record_image_le, leftarg = record, rightarg = record, commutator = pg_catalog.*>=, negator = pg_catalog.*>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.*<=(record, record) is 'less than or equal'; + +create operator pg_catalog.*>= (procedure = pg_catalog.record_image_ge, leftarg = record, rightarg = record, commutator = pg_catalog.*<=, negator = pg_catalog.*<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.*>=(record, record) is 'greater than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.charlt, leftarg = "char", rightarg = "char", commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<("char", "char") is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.> (procedure = pg_catalog.chargt, leftarg = "char", rightarg = "char", commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>("char", "char") is 'greater than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.array_lt, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(anyarray, anyarray) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.enum_lt, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(anyenum, anyenum) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int8lt, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bigint, bigint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int84lt, leftarg = bigint, rightarg = integer, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bigint, integer) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int82lt, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bigint, smallint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.varbitlt, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bit varying, bit varying) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.bitlt, leftarg = bit, rightarg = bit, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bit, bit) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.boollt, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(boolean, boolean) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.bytealt, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(bytea, bytea) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.bpcharlt, leftarg = char, rightarg = char, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(char, char) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.date_lt, leftarg = date, rightarg = date, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(date, date) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.date_lt_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(date, timestamp with time zone) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.date_lt_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(date, timestamp) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.float8lt, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(double precision, double precision) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.float84lt, leftarg = double precision, rightarg = real, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(double precision, real) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.network_lt, leftarg = inet, rightarg = inet, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(inet, inet) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int48lt, leftarg = integer, rightarg = bigint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(integer, bigint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int4lt, leftarg = integer, rightarg = integer, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(integer, integer) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int42lt, leftarg = integer, rightarg = smallint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(integer, smallint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.interval_lt, leftarg = interval, rightarg = interval, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(interval, interval) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.macaddr_lt, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(macaddr, macaddr) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.cash_lt, leftarg = money, rightarg = money, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(money, money) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.namelt, leftarg = name, rightarg = name, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(name, name) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.numeric_lt, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(numeric, numeric) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.oidvectorlt, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(oidvector, oidvector) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.oidlt, leftarg = oid, rightarg = oid, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(oid, oid) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.range_lt, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.<(anyrange, anyrange) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.jsonb_lt, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(jsonb, jsonb) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.pg_lsn_lt, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(pg_lsn, pg_lsn) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.float48lt, leftarg = real, rightarg = double precision, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(real, double precision) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.float4lt, leftarg = real, rightarg = real, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(real, real) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.record_lt, leftarg = record, rightarg = record, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(record, record) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int28lt, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(smallint, bigint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int24lt, leftarg = smallint, rightarg = integer, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(smallint, integer) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.int2lt, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(smallint, smallint) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.text_lt, leftarg = text, rightarg = text, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(text, text) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.tidlt, leftarg = tid, rightarg = tid, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(tid, tid) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timetz_lt, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(time with time zone, time with time zone) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamptz_lt_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp with time zone, date) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamptz_lt, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp with time zone, timestamp with time zone) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamptz_lt_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp with time zone, timestamp) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamp_lt_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp, date) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamp_lt_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp, timestamp with time zone) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.timestamp_lt, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(timestamp, timestamp) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.time_lt, leftarg = time, rightarg = time, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(time, time) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.tsquery_lt, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(tsquery, tsquery) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.tsvector_lt, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(tsvector, tsvector) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.uuid_lt, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(uuid, uuid) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.box_lt, leftarg = box, rightarg = box, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.<(box, box) is 'less than by area'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.circle_lt, leftarg = circle, rightarg = circle, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.<(circle, circle) is 'less than by area'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.lseg_lt, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.>, negator = pg_catalog.>=); + +comment on operator pg_catalog.<(lseg, lseg) is 'less than by length'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.macaddr8_lt, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(macaddr8, macaddr8) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.namelttext, leftarg = name, rightarg = text, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(name, text) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.textltname, leftarg = text, rightarg = name, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(text, name) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.xid8lt, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.<(xid8, xid8) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.< (procedure = pg_catalog.multirange_lt, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.>, negator = pg_catalog.>=, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<(anymultirange, anymultirange) is 'less than'; + +-- Cyclic dependencies found + +create operator pg_catalog.<= (procedure = pg_catalog.box_le, leftarg = box, rightarg = box, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.<=(box, box) is 'less than or equal by area'; + +-- Cyclic dependencies found + +create operator pg_catalog.<= (procedure = pg_catalog.circle_le, leftarg = circle, rightarg = circle, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.<=(circle, circle) is 'less than or equal by area'; + +-- Cyclic dependencies found + +create operator pg_catalog.<= (procedure = pg_catalog.lseg_le, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.>=, negator = pg_catalog.>); + +comment on operator pg_catalog.<=(lseg, lseg) is 'less than or equal by length'; + +-- Cyclic dependencies found + +create operator pg_catalog.<= (procedure = pg_catalog.charle, leftarg = "char", rightarg = "char", commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=("char", "char") is 'less than or equal'; + +create operator pg_catalog.> (procedure = pg_catalog.array_gt, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(anyarray, anyarray) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.enum_gt, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(anyenum, anyenum) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.multirange_gt, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.>(anymultirange, anymultirange) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.range_gt, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.>(anyrange, anyrange) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int8gt, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bigint, bigint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int84gt, leftarg = bigint, rightarg = integer, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bigint, integer) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int82gt, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bigint, smallint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.varbitgt, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bit varying, bit varying) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.bitgt, leftarg = bit, rightarg = bit, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bit, bit) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.boolgt, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(boolean, boolean) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.box_gt, leftarg = box, rightarg = box, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.>(box, box) is 'greater than by area'; + +create operator pg_catalog.> (procedure = pg_catalog.byteagt, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(bytea, bytea) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.bpchargt, leftarg = char, rightarg = char, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(char, char) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.circle_gt, leftarg = circle, rightarg = circle, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.>(circle, circle) is 'greater than by area'; + +create operator pg_catalog.> (procedure = pg_catalog.date_gt, leftarg = date, rightarg = date, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(date, date) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.date_gt_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(date, timestamp with time zone) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.date_gt_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(date, timestamp) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.float8gt, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(double precision, double precision) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.float84gt, leftarg = double precision, rightarg = real, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(double precision, real) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.network_gt, leftarg = inet, rightarg = inet, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(inet, inet) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int48gt, leftarg = integer, rightarg = bigint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(integer, bigint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int4gt, leftarg = integer, rightarg = integer, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(integer, integer) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int42gt, leftarg = integer, rightarg = smallint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(integer, smallint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.interval_gt, leftarg = interval, rightarg = interval, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(interval, interval) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.jsonb_gt, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(jsonb, jsonb) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.lseg_gt, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.<, negator = pg_catalog.<=); + +comment on operator pg_catalog.>(lseg, lseg) is 'greater than by length'; + +create operator pg_catalog.> (procedure = pg_catalog.macaddr_gt, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(macaddr, macaddr) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.macaddr8_gt, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(macaddr8, macaddr8) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.cash_gt, leftarg = money, rightarg = money, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(money, money) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.namegt, leftarg = name, rightarg = name, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(name, name) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.namegttext, leftarg = name, rightarg = text, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(name, text) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.numeric_gt, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(numeric, numeric) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.oidgt, leftarg = oid, rightarg = oid, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(oid, oid) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.oidvectorgt, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(oidvector, oidvector) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.pg_lsn_gt, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(pg_lsn, pg_lsn) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.float48gt, leftarg = real, rightarg = double precision, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(real, double precision) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.float4gt, leftarg = real, rightarg = real, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(real, real) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.record_gt, leftarg = record, rightarg = record, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(record, record) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int28gt, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(smallint, bigint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int24gt, leftarg = smallint, rightarg = integer, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(smallint, integer) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.int2gt, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(smallint, smallint) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.textgtname, leftarg = text, rightarg = name, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(text, name) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.text_gt, leftarg = text, rightarg = text, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(text, text) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.tidgt, leftarg = tid, rightarg = tid, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(tid, tid) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timetz_gt, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(time with time zone, time with time zone) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.time_gt, leftarg = time, rightarg = time, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(time, time) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamptz_gt_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp with time zone, date) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamptz_gt, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp with time zone, timestamp with time zone) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamptz_gt_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp with time zone, timestamp) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamp_gt_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp, date) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamp_gt_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp, timestamp with time zone) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.timestamp_gt, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(timestamp, timestamp) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.tsquery_gt, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(tsquery, tsquery) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.tsvector_gt, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(tsvector, tsvector) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.uuid_gt, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(uuid, uuid) is 'greater than'; + +create operator pg_catalog.> (procedure = pg_catalog.xid8gt, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.<, negator = pg_catalog.<=, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.>(xid8, xid8) is 'greater than'; + +create operator pg_catalog.>= (procedure = pg_catalog.charge, leftarg = "char", rightarg = "char", commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=("char", "char") is 'greater than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.array_le, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(anyarray, anyarray) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.enum_le, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(anyenum, anyenum) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.multirange_le, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.<=(anymultirange, anymultirange) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.range_le, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.<=(anyrange, anyrange) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int8le, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bigint, bigint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int84le, leftarg = bigint, rightarg = integer, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bigint, integer) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int82le, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bigint, smallint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.varbitle, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bit varying, bit varying) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.bitle, leftarg = bit, rightarg = bit, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bit, bit) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.boolle, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(boolean, boolean) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.byteale, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(bytea, bytea) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.bpcharle, leftarg = char, rightarg = char, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(char, char) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.date_le, leftarg = date, rightarg = date, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(date, date) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.date_le_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(date, timestamp with time zone) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.date_le_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(date, timestamp) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.float8le, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(double precision, double precision) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.float84le, leftarg = double precision, rightarg = real, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(double precision, real) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.network_le, leftarg = inet, rightarg = inet, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(inet, inet) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int48le, leftarg = integer, rightarg = bigint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(integer, bigint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int4le, leftarg = integer, rightarg = integer, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(integer, integer) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int42le, leftarg = integer, rightarg = smallint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(integer, smallint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.interval_le, leftarg = interval, rightarg = interval, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(interval, interval) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.jsonb_le, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(jsonb, jsonb) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.macaddr_le, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(macaddr, macaddr) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.macaddr8_le, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(macaddr8, macaddr8) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.cash_le, leftarg = money, rightarg = money, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(money, money) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.namele, leftarg = name, rightarg = name, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(name, name) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.nameletext, leftarg = name, rightarg = text, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(name, text) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.numeric_le, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(numeric, numeric) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.oidle, leftarg = oid, rightarg = oid, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(oid, oid) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.oidvectorle, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(oidvector, oidvector) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.pg_lsn_le, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(pg_lsn, pg_lsn) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.float48le, leftarg = real, rightarg = double precision, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(real, double precision) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.float4le, leftarg = real, rightarg = real, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(real, real) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.record_le, leftarg = record, rightarg = record, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(record, record) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int28le, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(smallint, bigint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int24le, leftarg = smallint, rightarg = integer, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(smallint, integer) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.int2le, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(smallint, smallint) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.textlename, leftarg = text, rightarg = name, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(text, name) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.text_le, leftarg = text, rightarg = text, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(text, text) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.tidle, leftarg = tid, rightarg = tid, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(tid, tid) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timetz_le, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(time with time zone, time with time zone) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.time_le, leftarg = time, rightarg = time, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(time, time) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamptz_le_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp with time zone, date) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamptz_le, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp with time zone, timestamp with time zone) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamptz_le_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp with time zone, timestamp) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamp_le_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp, date) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamp_le_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp, timestamp with time zone) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.timestamp_le, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(timestamp, timestamp) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.tsquery_le, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(tsquery, tsquery) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.tsvector_le, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(tsvector, tsvector) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.uuid_le, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(uuid, uuid) is 'less than or equal'; + +create operator pg_catalog.<= (procedure = pg_catalog.xid8le, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.>=, negator = pg_catalog.>, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.<=(xid8, xid8) is 'less than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.array_ge, leftarg = anyarray, rightarg = anyarray, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(anyarray, anyarray) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.enum_ge, leftarg = anyenum, rightarg = anyenum, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(anyenum, anyenum) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.multirange_ge, leftarg = anymultirange, rightarg = anymultirange, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.multirangesel); + +comment on operator pg_catalog.>=(anymultirange, anymultirange) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.range_ge, leftarg = anyrange, rightarg = anyrange, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.rangesel); + +comment on operator pg_catalog.>=(anyrange, anyrange) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int8ge, leftarg = bigint, rightarg = bigint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bigint, bigint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int84ge, leftarg = bigint, rightarg = integer, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bigint, integer) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int82ge, leftarg = bigint, rightarg = smallint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bigint, smallint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.varbitge, leftarg = bit varying, rightarg = bit varying, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bit varying, bit varying) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.bitge, leftarg = bit, rightarg = bit, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bit, bit) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.boolge, leftarg = boolean, rightarg = boolean, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(boolean, boolean) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.box_ge, leftarg = box, rightarg = box, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.>=(box, box) is 'greater than or equal by area'; + +create operator pg_catalog.>= (procedure = pg_catalog.byteage, leftarg = bytea, rightarg = bytea, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(bytea, bytea) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.bpcharge, leftarg = char, rightarg = char, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(char, char) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.circle_ge, leftarg = circle, rightarg = circle, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.areajoinsel, restrict = pg_catalog.areasel); + +comment on operator pg_catalog.>=(circle, circle) is 'greater than or equal by area'; + +create operator pg_catalog.>= (procedure = pg_catalog.date_ge, leftarg = date, rightarg = date, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(date, date) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.date_ge_timestamptz, leftarg = date, rightarg = timestamp with time zone, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(date, timestamp with time zone) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.date_ge_timestamp, leftarg = date, rightarg = timestamp, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(date, timestamp) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.float8ge, leftarg = double precision, rightarg = double precision, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(double precision, double precision) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.float84ge, leftarg = double precision, rightarg = real, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(double precision, real) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.network_ge, leftarg = inet, rightarg = inet, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(inet, inet) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int48ge, leftarg = integer, rightarg = bigint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(integer, bigint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int4ge, leftarg = integer, rightarg = integer, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(integer, integer) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int42ge, leftarg = integer, rightarg = smallint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(integer, smallint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.interval_ge, leftarg = interval, rightarg = interval, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(interval, interval) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.jsonb_ge, leftarg = jsonb, rightarg = jsonb, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(jsonb, jsonb) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.lseg_ge, leftarg = lseg, rightarg = lseg, commutator = pg_catalog.<=, negator = pg_catalog.<); + +comment on operator pg_catalog.>=(lseg, lseg) is 'greater than or equal by length'; + +create operator pg_catalog.>= (procedure = pg_catalog.macaddr_ge, leftarg = macaddr, rightarg = macaddr, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(macaddr, macaddr) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.macaddr8_ge, leftarg = macaddr8, rightarg = macaddr8, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(macaddr8, macaddr8) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.cash_ge, leftarg = money, rightarg = money, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(money, money) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.namege, leftarg = name, rightarg = name, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(name, name) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.namegetext, leftarg = name, rightarg = text, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(name, text) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.numeric_ge, leftarg = numeric, rightarg = numeric, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(numeric, numeric) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.oidge, leftarg = oid, rightarg = oid, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(oid, oid) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.oidvectorge, leftarg = oidvector, rightarg = oidvector, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(oidvector, oidvector) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.pg_lsn_ge, leftarg = pg_lsn, rightarg = pg_lsn, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(pg_lsn, pg_lsn) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.float48ge, leftarg = real, rightarg = double precision, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(real, double precision) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.float4ge, leftarg = real, rightarg = real, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(real, real) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.record_ge, leftarg = record, rightarg = record, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(record, record) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int28ge, leftarg = smallint, rightarg = bigint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(smallint, bigint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int24ge, leftarg = smallint, rightarg = integer, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(smallint, integer) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.int2ge, leftarg = smallint, rightarg = smallint, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(smallint, smallint) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.textgename, leftarg = text, rightarg = name, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(text, name) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.text_ge, leftarg = text, rightarg = text, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(text, text) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.tidge, leftarg = tid, rightarg = tid, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(tid, tid) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timetz_ge, leftarg = time with time zone, rightarg = time with time zone, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(time with time zone, time with time zone) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.time_ge, leftarg = time, rightarg = time, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(time, time) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamptz_ge_date, leftarg = timestamp with time zone, rightarg = date, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp with time zone, date) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamptz_ge, leftarg = timestamp with time zone, rightarg = timestamp with time zone, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp with time zone, timestamp with time zone) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamptz_ge_timestamp, leftarg = timestamp with time zone, rightarg = timestamp, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp with time zone, timestamp) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamp_ge_date, leftarg = timestamp, rightarg = date, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp, date) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamp_ge_timestamptz, leftarg = timestamp, rightarg = timestamp with time zone, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp, timestamp with time zone) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.timestamp_ge, leftarg = timestamp, rightarg = timestamp, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(timestamp, timestamp) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.tsquery_ge, leftarg = tsquery, rightarg = tsquery, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(tsquery, tsquery) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.tsvector_ge, leftarg = tsvector, rightarg = tsvector, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(tsvector, tsvector) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.uuid_ge, leftarg = uuid, rightarg = uuid, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(uuid, uuid) is 'greater than or equal'; + +create operator pg_catalog.>= (procedure = pg_catalog.xid8ge, leftarg = xid8, rightarg = xid8, commutator = pg_catalog.<=, negator = pg_catalog.<, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.>=(xid8, xid8) is 'greater than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.~<=~ (procedure = pg_catalog.bpchar_pattern_le, leftarg = char, rightarg = char, commutator = pg_catalog.~>=~, negator = pg_catalog.~>~, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.~<=~(char, char) is 'less than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.~>=~ (procedure = pg_catalog.bpchar_pattern_ge, leftarg = char, rightarg = char, commutator = pg_catalog.~<=~, negator = pg_catalog.~<~, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.~>=~(char, char) is 'greater than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.~<=~ (procedure = pg_catalog.text_pattern_le, leftarg = text, rightarg = text, commutator = pg_catalog.~>=~, negator = pg_catalog.~>~, join = pg_catalog.scalarlejoinsel, restrict = pg_catalog.scalarlesel); + +comment on operator pg_catalog.~<=~(text, text) is 'less than or equal'; + +-- Cyclic dependencies found + +create operator pg_catalog.~<~ (procedure = pg_catalog.bpchar_pattern_lt, leftarg = char, rightarg = char, commutator = pg_catalog.~>~, negator = pg_catalog.~>=~, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.~<~(char, char) is 'less than'; + +create operator pg_catalog.~>=~ (procedure = pg_catalog.text_pattern_ge, leftarg = text, rightarg = text, commutator = pg_catalog.~<=~, negator = pg_catalog.~<~, join = pg_catalog.scalargejoinsel, restrict = pg_catalog.scalargesel); + +comment on operator pg_catalog.~>=~(text, text) is 'greater than or equal'; + +create operator pg_catalog.~>~ (procedure = pg_catalog.bpchar_pattern_gt, leftarg = char, rightarg = char, commutator = pg_catalog.~<~, negator = pg_catalog.~<=~, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.~>~(char, char) is 'greater than'; + +create operator pg_catalog.~<~ (procedure = pg_catalog.text_pattern_lt, leftarg = text, rightarg = text, commutator = pg_catalog.~>~, negator = pg_catalog.~>=~, join = pg_catalog.scalarltjoinsel, restrict = pg_catalog.scalarltsel); + +comment on operator pg_catalog.~<~(text, text) is 'less than'; + +create operator pg_catalog.~>~ (procedure = pg_catalog.text_pattern_gt, leftarg = text, rightarg = text, commutator = pg_catalog.~<~, negator = pg_catalog.~<=~, join = pg_catalog.scalargtjoinsel, restrict = pg_catalog.scalargtsel); + +comment on operator pg_catalog.~>~(text, text) is 'greater than'; + diff --git a/src/main/java/group/goforward/ballistic/controllers/Dockerfile b/src/main/java/group/goforward/ballistic/controllers/Dockerfile deleted file mode 100644 index a4fba4f..0000000 --- a/src/main/java/group/goforward/ballistic/controllers/Dockerfile +++ /dev/null @@ -1,17 +0,0 @@ -# Stage 1: Build the application -FROM openjdk:17-jdk-slim as build -WORKDIR /app -COPY gradlew . -COPY settings.gradle . -COPY build.gradle . -COPY src ./src -# Adjust the build command for Maven: ./mvnw package -DskipTests -RUN ./gradlew bootJar - -# Stage 2: Create the final lightweight image -FROM openjdk:17-jre-slim -WORKDIR /app -# Get the built JAR from the build stage -COPY --from=build /app/build/libs/*.jar app.jar -EXPOSE 8080 -ENTRYPOINT ["java", "-jar", "app.jar"] \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/controllers/PsaController.java b/src/main/java/group/goforward/ballistic/controllers/PsaController.java deleted file mode 100644 index bf442a9..0000000 --- a/src/main/java/group/goforward/ballistic/controllers/PsaController.java +++ /dev/null @@ -1,57 +0,0 @@ -package group.goforward.ballistic.controllers; - -import group.goforward.ballistic.model.Psa; -import group.goforward.ballistic.services.impl.PsaServiceImpl; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.http.ResponseEntity; -import org.springframework.web.bind.annotation.*; - -import java.util.List; -import java.util.Optional; -import java.util.UUID; - -@RestController -@RequestMapping("/api/psa") -public class PsaController { - - private final PsaServiceImpl psaService; - - @Autowired - public PsaController(PsaServiceImpl psaService) { - this.psaService = psaService; - } - - @GetMapping("/api/getAllPsa") - public List getAllPsa() { - return psaService.findAll(); - } - - @GetMapping("/api/getPSAById/{id}") - public ResponseEntity getPsaById(@PathVariable UUID id) { - Optional psa = psaService.findById(id); - return psa.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build()); - } - - @PostMapping - public Psa createPsa(@RequestBody Psa psa) { - return psaService.save(psa); - } - - @PutMapping("/api/updatePsa/{id}") - public ResponseEntity updatePsa(@PathVariable UUID id, @RequestBody Psa psaDetails) { - Optional psa = psaService.findById(id); - if (psa.isPresent()) { - Psa updatedPsa = psa.get(); - // Update fields of the Psa entity as needed - return ResponseEntity.ok(psaService.save(updatedPsa)); - } else { - return ResponseEntity.notFound().build(); - } - } - - @DeleteMapping("/api/deletePsa/{id}") - public ResponseEntity deletePsa(@PathVariable UUID id) { - psaService.deleteById(id); - return ResponseEntity.noContent().build(); - } -} diff --git a/src/main/java/group/goforward/ballistic/model/Account.java b/src/main/java/group/goforward/ballistic/model/Account.java index 5b7ff59..08a1562 100644 --- a/src/main/java/group/goforward/ballistic/model/Account.java +++ b/src/main/java/group/goforward/ballistic/model/Account.java @@ -6,6 +6,7 @@ import jakarta.persistence.Id; import jakarta.persistence.Table; import org.hibernate.annotations.ColumnDefault; +import java.time.OffsetDateTime; import java.util.UUID; @Entity @@ -53,6 +54,15 @@ public class Account { @Column(name = "scope", length = Integer.MAX_VALUE) private String scope; + @Column(name = "created_at") + private OffsetDateTime createdAt; + + @Column(name = "updated_at") + private OffsetDateTime updatedAt; + + @Column(name = "deleted_at") + private OffsetDateTime deletedAt; + public UUID getId() { return id; } @@ -157,4 +167,28 @@ public class Account { this.scope = scope; } + public OffsetDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(OffsetDateTime createdAt) { + this.createdAt = createdAt; + } + + public OffsetDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(OffsetDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public OffsetDateTime getDeletedAt() { + return deletedAt; + } + + public void setDeletedAt(OffsetDateTime deletedAt) { + this.deletedAt = deletedAt; + } + } \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/AeroPrecision.java b/src/main/java/group/goforward/ballistic/model/AeroPrecision.java deleted file mode 100644 index 65cd387..0000000 --- a/src/main/java/group/goforward/ballistic/model/AeroPrecision.java +++ /dev/null @@ -1,293 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.math.BigDecimal; -import java.util.UUID; - -@Entity -@Table(name = "aero_precision") -public class -AeroPrecision { - @Id - @Column(name = "sku", nullable = false, length = Integer.MAX_VALUE) - private String sku; - - @Column(name = "manufacturer_id", length = Integer.MAX_VALUE) - private String manufacturerId; - - @Column(name = "brand_name", length = Integer.MAX_VALUE) - private String brandName; - - @Column(name = "product_name", length = Integer.MAX_VALUE) - private String productName; - - @Column(name = "long_description", length = Integer.MAX_VALUE) - private String longDescription; - - @Column(name = "short_description", length = Integer.MAX_VALUE) - private String shortDescription; - - @Column(name = "department", length = Integer.MAX_VALUE) - private String department; - - @Column(name = "category", length = Integer.MAX_VALUE) - private String category; - - @Column(name = "subcategory", length = Integer.MAX_VALUE) - private String subcategory; - - @Column(name = "thumb_url", length = Integer.MAX_VALUE) - private String thumbUrl; - - @Column(name = "image_url", length = Integer.MAX_VALUE) - private String imageUrl; - - @Column(name = "buy_link", length = Integer.MAX_VALUE) - private String buyLink; - - @Column(name = "keywords", length = Integer.MAX_VALUE) - private String keywords; - - @Column(name = "reviews", length = Integer.MAX_VALUE) - private String reviews; - - @Column(name = "retail_price") - private BigDecimal retailPrice; - - @Column(name = "sale_price") - private BigDecimal salePrice; - - @Column(name = "brand_page_link", length = Integer.MAX_VALUE) - private String brandPageLink; - - @Column(name = "brand_logo_image", length = Integer.MAX_VALUE) - private String brandLogoImage; - - @Column(name = "product_page_view_tracking", length = Integer.MAX_VALUE) - private String productPageViewTracking; - - @Column(name = "variants_xml", length = Integer.MAX_VALUE) - private String variantsXml; - - @Column(name = "medium_image_url", length = Integer.MAX_VALUE) - private String mediumImageUrl; - - @Column(name = "product_content_widget", length = Integer.MAX_VALUE) - private String productContentWidget; - - @Column(name = "google_categorization", length = Integer.MAX_VALUE) - private String googleCategorization; - - @Column(name = "item_based_commission", length = Integer.MAX_VALUE) - private String itemBasedCommission; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private UUID uuid; - - public String getSku() { - return sku; - } - - public void setSku(String sku) { - this.sku = sku; - } - - public String getManufacturerId() { - return manufacturerId; - } - - public void setManufacturerId(String manufacturerId) { - this.manufacturerId = manufacturerId; - } - - public String getBrandName() { - return brandName; - } - - public void setBrandName(String brandName) { - this.brandName = brandName; - } - - public String getProductName() { - return productName; - } - - public void setProductName(String productName) { - this.productName = productName; - } - - public String getLongDescription() { - return longDescription; - } - - public void setLongDescription(String longDescription) { - this.longDescription = longDescription; - } - - public String getShortDescription() { - return shortDescription; - } - - public void setShortDescription(String shortDescription) { - this.shortDescription = shortDescription; - } - - public String getDepartment() { - return department; - } - - public void setDepartment(String department) { - this.department = department; - } - - public String getCategory() { - return category; - } - - public void setCategory(String category) { - this.category = category; - } - - public String getSubcategory() { - return subcategory; - } - - public void setSubcategory(String subcategory) { - this.subcategory = subcategory; - } - - public String getThumbUrl() { - return thumbUrl; - } - - public void setThumbUrl(String thumbUrl) { - this.thumbUrl = thumbUrl; - } - - public String getImageUrl() { - return imageUrl; - } - - public void setImageUrl(String imageUrl) { - this.imageUrl = imageUrl; - } - - public String getBuyLink() { - return buyLink; - } - - public void setBuyLink(String buyLink) { - this.buyLink = buyLink; - } - - public String getKeywords() { - return keywords; - } - - public void setKeywords(String keywords) { - this.keywords = keywords; - } - - public String getReviews() { - return reviews; - } - - public void setReviews(String reviews) { - this.reviews = reviews; - } - - public BigDecimal getRetailPrice() { - return retailPrice; - } - - public void setRetailPrice(BigDecimal retailPrice) { - this.retailPrice = retailPrice; - } - - public BigDecimal getSalePrice() { - return salePrice; - } - - public void setSalePrice(BigDecimal salePrice) { - this.salePrice = salePrice; - } - - public String getBrandPageLink() { - return brandPageLink; - } - - public void setBrandPageLink(String brandPageLink) { - this.brandPageLink = brandPageLink; - } - - public String getBrandLogoImage() { - return brandLogoImage; - } - - public void setBrandLogoImage(String brandLogoImage) { - this.brandLogoImage = brandLogoImage; - } - - public String getProductPageViewTracking() { - return productPageViewTracking; - } - - public void setProductPageViewTracking(String productPageViewTracking) { - this.productPageViewTracking = productPageViewTracking; - } - - public String getVariantsXml() { - return variantsXml; - } - - public void setVariantsXml(String variantsXml) { - this.variantsXml = variantsXml; - } - - public String getMediumImageUrl() { - return mediumImageUrl; - } - - public void setMediumImageUrl(String mediumImageUrl) { - this.mediumImageUrl = mediumImageUrl; - } - - public String getProductContentWidget() { - return productContentWidget; - } - - public void setProductContentWidget(String productContentWidget) { - this.productContentWidget = productContentWidget; - } - - public String getGoogleCategorization() { - return googleCategorization; - } - - public void setGoogleCategorization(String googleCategorization) { - this.googleCategorization = googleCategorization; - } - - public String getItemBasedCommission() { - return itemBasedCommission; - } - - public void setItemBasedCommission(String itemBasedCommission) { - this.itemBasedCommission = itemBasedCommission; - } - - public UUID getUuid() { - return uuid; - } - - public void setUuid(UUID uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/AffiliateCategoryMap.java b/src/main/java/group/goforward/ballistic/model/AffiliateCategoryMap.java index eee49ec..7d6fe26 100644 --- a/src/main/java/group/goforward/ballistic/model/AffiliateCategoryMap.java +++ b/src/main/java/group/goforward/ballistic/model/AffiliateCategoryMap.java @@ -2,6 +2,8 @@ package group.goforward.ballistic.model; import jakarta.persistence.*; +import java.time.OffsetDateTime; + @Entity @Table(name = "affiliate_category_map") public class AffiliateCategoryMap { @@ -29,6 +31,15 @@ public class AffiliateCategoryMap { @Column(name = "notes") private String notes; + @Column(name = "created_at") + private OffsetDateTime createdAt; + + @Column(name = "updated_at") + private OffsetDateTime updatedAt; + + @Column(name = "deleted_at") + private OffsetDateTime deletedAt; + // --- getters / setters --- public Integer getId() { @@ -78,4 +89,28 @@ public class AffiliateCategoryMap { public void setNotes(String notes) { this.notes = notes; } + + public OffsetDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(OffsetDateTime createdAt) { + this.createdAt = createdAt; + } + + public OffsetDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(OffsetDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public OffsetDateTime getDeletedAt() { + return deletedAt; + } + + public void setDeletedAt(OffsetDateTime deletedAt) { + this.deletedAt = deletedAt; + } } \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Authenticator.java b/src/main/java/group/goforward/ballistic/model/Authenticator.java deleted file mode 100644 index 49e4006..0000000 --- a/src/main/java/group/goforward/ballistic/model/Authenticator.java +++ /dev/null @@ -1,88 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.EmbeddedId; -import jakarta.persistence.Entity; -import jakarta.persistence.Table; - -@Entity -@Table(name = "authenticator") -public class Authenticator { - @EmbeddedId - private AuthenticatorId id; - - @Column(name = "\"providerAccountId\"", nullable = false, length = Integer.MAX_VALUE) - private String providerAccountId; - - @Column(name = "\"credentialPublicKey\"", nullable = false, length = Integer.MAX_VALUE) - private String credentialPublicKey; - - @Column(name = "counter", nullable = false) - private Integer counter; - - @Column(name = "\"credentialDeviceType\"", nullable = false, length = Integer.MAX_VALUE) - private String credentialDeviceType; - - @Column(name = "\"credentialBackedUp\"", nullable = false) - private Boolean credentialBackedUp = false; - - @Column(name = "transports", length = Integer.MAX_VALUE) - private String transports; - - public AuthenticatorId getId() { - return id; - } - - public void setId(AuthenticatorId id) { - this.id = id; - } - - public String getProviderAccountId() { - return providerAccountId; - } - - public void setProviderAccountId(String providerAccountId) { - this.providerAccountId = providerAccountId; - } - - public String getCredentialPublicKey() { - return credentialPublicKey; - } - - public void setCredentialPublicKey(String credentialPublicKey) { - this.credentialPublicKey = credentialPublicKey; - } - - public Integer getCounter() { - return counter; - } - - public void setCounter(Integer counter) { - this.counter = counter; - } - - public String getCredentialDeviceType() { - return credentialDeviceType; - } - - public void setCredentialDeviceType(String credentialDeviceType) { - this.credentialDeviceType = credentialDeviceType; - } - - public Boolean getCredentialBackedUp() { - return credentialBackedUp; - } - - public void setCredentialBackedUp(Boolean credentialBackedUp) { - this.credentialBackedUp = credentialBackedUp; - } - - public String getTransports() { - return transports; - } - - public void setTransports(String transports) { - this.transports = transports; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/AuthenticatorId.java b/src/main/java/group/goforward/ballistic/model/AuthenticatorId.java deleted file mode 100644 index b410ee2..0000000 --- a/src/main/java/group/goforward/ballistic/model/AuthenticatorId.java +++ /dev/null @@ -1,48 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Embeddable; -import org.hibernate.Hibernate; - -import java.util.Objects; - -@Embeddable -public class AuthenticatorId implements java.io.Serializable { - private static final long serialVersionUID = -4147080603801184737L; - @Column(name = "\"credentialId\"", nullable = false, length = Integer.MAX_VALUE) - private String credentialId; - - @Column(name = "\"userId\"", nullable = false, length = Integer.MAX_VALUE) - private String userId; - - public String getCredentialId() { - return credentialId; - } - - public void setCredentialId(String credentialId) { - this.credentialId = credentialId; - } - - public String getUserId() { - return userId; - } - - public void setUserId(String userId) { - this.userId = userId; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false; - AuthenticatorId entity = (AuthenticatorId) o; - return Objects.equals(this.credentialId, entity.credentialId) && - Objects.equals(this.userId, entity.userId); - } - - @Override - public int hashCode() { - return Objects.hash(credentialId, userId); - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/BalReseller.java b/src/main/java/group/goforward/ballistic/model/BalReseller.java deleted file mode 100644 index 522dcd1..0000000 --- a/src/main/java/group/goforward/ballistic/model/BalReseller.java +++ /dev/null @@ -1,107 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "bal_resellers") -public class BalReseller { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "name", nullable = false, length = 100) - private String name; - - @Column(name = "website_url") - private String websiteUrl; - - @Column(name = "contact_email", length = 100) - private String contactEmail; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private UUID uuid; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getWebsiteUrl() { - return websiteUrl; - } - - public void setWebsiteUrl(String websiteUrl) { - this.websiteUrl = websiteUrl; - } - - public String getContactEmail() { - return contactEmail; - } - - public void setContactEmail(String contactEmail) { - this.contactEmail = contactEmail; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - - public UUID getUuid() { - return uuid; - } - - public void setUuid(UUID uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/BbProduct.java b/src/main/java/group/goforward/ballistic/model/BbProduct.java deleted file mode 100644 index d813c83..0000000 --- a/src/main/java/group/goforward/ballistic/model/BbProduct.java +++ /dev/null @@ -1,393 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "bb_products") -public class BbProduct { - @Id - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid", nullable = false) - private UUID id; - - @Column(name = "\"UPC\"", length = 100) - private String upc; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - @Column(name = "\"SKU\"", length = 50) - private String sku; - - @Column(name = "\"MANUFACTURER_ID\"", length = 50) - private String manufacturerId; - - @Column(name = "\"BRAND_NAME\"", length = 50) - private String brandName; - - @Column(name = "\"PRODUCT_NAME\"") - private String productName; - - @Column(name = "\"LONG_DESCRIPTION\"", length = Integer.MAX_VALUE) - private String longDescription; - - @Column(name = "\"SHORT_DESCRIPTION\"", length = 500) - private String shortDescription; - - @Column(name = "\"DEPARTMENT\"", length = 100) - private String department; - - @Column(name = "\"CATEGORY\"", length = 100) - private String category; - - @Column(name = "\"SUBCATEGORY\"", length = 100) - private String subcategory; - - @Column(name = "\"THUMB_URL\"", length = 500) - private String thumbUrl; - - @Column(name = "\"IMAGE_URL\"", length = 500) - private String imageUrl; - - @Column(name = "\"BUY_LINK\"", length = 500) - private String buyLink; - - @Column(name = "\"KEYWORDS\"", length = 500) - private String keywords; - - @Column(name = "\"REVIEWS\"", length = 500) - private String reviews; - - @Column(name = "\"RETAIL_PRICE\"", length = 50) - private String retailPrice; - - @Column(name = "\"SALE_PRICE\"", length = 50) - private String salePrice; - - @Column(name = "\"BRAND_PAGE_LINK\"", length = 500) - private String brandPageLink; - - @Column(name = "\"BRAND_LOGO_IMAGE\"", length = 500) - private String brandLogoImage; - - @Column(name = "\"PRODUCT_PAGE_VIEW_TRACKING\"", length = 500) - private String productPageViewTracking; - - @Column(name = "\"PARENT_GROUP_ID\"", length = 200) - private String parentGroupId; - - @Column(name = "\"FINELINE\"", length = 200) - private String fineline; - - @Column(name = "\"SUPERFINELINE\"", length = 200) - private String superfineline; - - @Column(name = "\"MODELNUMBER\"", length = 100) - private String modelnumber; - - @Column(name = "\"CALIBER\"", length = 200) - private String caliber; - - @Column(name = "\"MEDIUM_IMAGE_URL\"", length = 500) - private String mediumImageUrl; - - @Column(name = "\"PRODUCT_CONTENT_WIDGET\"", length = 500) - private String productContentWidget; - - @Column(name = "\"GOOGLE_CATEGORIZATION\"", length = 500) - private String googleCategorization; - - @Column(name = "\"ITEM_BASED_COMMISSION\"", length = 500) - private String itemBasedCommission; - - @Column(name = "\"ITEM_BASED_COMMISSION RATE\"", length = 50) - private String itemBasedCommissionRate; - - public UUID getId() { - return id; - } - - public void setId(UUID id) { - this.id = id; - } - - public String getUpc() { - return upc; - } - - public void setUpc(String upc) { - this.upc = upc; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - - public String getSku() { - return sku; - } - - public void setSku(String sku) { - this.sku = sku; - } - - public String getManufacturerId() { - return manufacturerId; - } - - public void setManufacturerId(String manufacturerId) { - this.manufacturerId = manufacturerId; - } - - public String getBrandName() { - return brandName; - } - - public void setBrandName(String brandName) { - this.brandName = brandName; - } - - public String getProductName() { - return productName; - } - - public void setProductName(String productName) { - this.productName = productName; - } - - public String getLongDescription() { - return longDescription; - } - - public void setLongDescription(String longDescription) { - this.longDescription = longDescription; - } - - public String getShortDescription() { - return shortDescription; - } - - public void setShortDescription(String shortDescription) { - this.shortDescription = shortDescription; - } - - public String getDepartment() { - return department; - } - - public void setDepartment(String department) { - this.department = department; - } - - public String getCategory() { - return category; - } - - public void setCategory(String category) { - this.category = category; - } - - public String getSubcategory() { - return subcategory; - } - - public void setSubcategory(String subcategory) { - this.subcategory = subcategory; - } - - public String getThumbUrl() { - return thumbUrl; - } - - public void setThumbUrl(String thumbUrl) { - this.thumbUrl = thumbUrl; - } - - public String getImageUrl() { - return imageUrl; - } - - public void setImageUrl(String imageUrl) { - this.imageUrl = imageUrl; - } - - public String getBuyLink() { - return buyLink; - } - - public void setBuyLink(String buyLink) { - this.buyLink = buyLink; - } - - public String getKeywords() { - return keywords; - } - - public void setKeywords(String keywords) { - this.keywords = keywords; - } - - public String getReviews() { - return reviews; - } - - public void setReviews(String reviews) { - this.reviews = reviews; - } - - public String getRetailPrice() { - return retailPrice; - } - - public void setRetailPrice(String retailPrice) { - this.retailPrice = retailPrice; - } - - public String getSalePrice() { - return salePrice; - } - - public void setSalePrice(String salePrice) { - this.salePrice = salePrice; - } - - public String getBrandPageLink() { - return brandPageLink; - } - - public void setBrandPageLink(String brandPageLink) { - this.brandPageLink = brandPageLink; - } - - public String getBrandLogoImage() { - return brandLogoImage; - } - - public void setBrandLogoImage(String brandLogoImage) { - this.brandLogoImage = brandLogoImage; - } - - public String getProductPageViewTracking() { - return productPageViewTracking; - } - - public void setProductPageViewTracking(String productPageViewTracking) { - this.productPageViewTracking = productPageViewTracking; - } - - public String getParentGroupId() { - return parentGroupId; - } - - public void setParentGroupId(String parentGroupId) { - this.parentGroupId = parentGroupId; - } - - public String getFineline() { - return fineline; - } - - public void setFineline(String fineline) { - this.fineline = fineline; - } - - public String getSuperfineline() { - return superfineline; - } - - public void setSuperfineline(String superfineline) { - this.superfineline = superfineline; - } - - public String getModelnumber() { - return modelnumber; - } - - public void setModelnumber(String modelnumber) { - this.modelnumber = modelnumber; - } - - public String getCaliber() { - return caliber; - } - - public void setCaliber(String caliber) { - this.caliber = caliber; - } - - public String getMediumImageUrl() { - return mediumImageUrl; - } - - public void setMediumImageUrl(String mediumImageUrl) { - this.mediumImageUrl = mediumImageUrl; - } - - public String getProductContentWidget() { - return productContentWidget; - } - - public void setProductContentWidget(String productContentWidget) { - this.productContentWidget = productContentWidget; - } - - public String getGoogleCategorization() { - return googleCategorization; - } - - public void setGoogleCategorization(String googleCategorization) { - this.googleCategorization = googleCategorization; - } - - public String getItemBasedCommission() { - return itemBasedCommission; - } - - public void setItemBasedCommission(String itemBasedCommission) { - this.itemBasedCommission = itemBasedCommission; - } - - public String getItemBasedCommissionRate() { - return itemBasedCommissionRate; - } - - public void setItemBasedCommissionRate(String itemBasedCommissionRate) { - this.itemBasedCommissionRate = itemBasedCommissionRate; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/BuildItem.java b/src/main/java/group/goforward/ballistic/model/BuildItem.java new file mode 100644 index 0000000..7f35568 --- /dev/null +++ b/src/main/java/group/goforward/ballistic/model/BuildItem.java @@ -0,0 +1,143 @@ +package group.goforward.ballistic.model; + +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import org.hibernate.annotations.ColumnDefault; +import org.hibernate.annotations.OnDelete; +import org.hibernate.annotations.OnDeleteAction; + +import java.time.OffsetDateTime; +import java.util.UUID; + +@Entity +@Table(name = "build_items") +public class BuildItem { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "id", nullable = false) + private Integer id; + + @NotNull + @ColumnDefault("gen_random_uuid()") + @Column(name = "uuid", nullable = false) + private UUID uuid; + + @NotNull + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @OnDelete(action = OnDeleteAction.CASCADE) + @JoinColumn(name = "build_id", nullable = false) + private Build build; + + @NotNull + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @OnDelete(action = OnDeleteAction.CASCADE) + @JoinColumn(name = "product_id", nullable = false) + private Product product; + + @NotNull + @Column(name = "slot", nullable = false, length = Integer.MAX_VALUE) + private String slot; + + @NotNull + @ColumnDefault("0") + @Column(name = "\"position\"", nullable = false) + private Integer position; + + @NotNull + @ColumnDefault("1") + @Column(name = "quantity", nullable = false) + private Integer quantity; + + @NotNull + @ColumnDefault("now()") + @Column(name = "created_at", nullable = false) + private OffsetDateTime createdAt; + + @ColumnDefault("CURRENT_TIMESTAMP") + @Column(name = "updated_at") + private OffsetDateTime updatedAt; + + @Column(name = "deleted_at") + private OffsetDateTime deletedAt; + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public UUID getUuid() { + return uuid; + } + + public void setUuid(UUID uuid) { + this.uuid = uuid; + } + + public Build getBuild() { + return build; + } + + public void setBuild(Build build) { + this.build = build; + } + + public Product getProduct() { + return product; + } + + public void setProduct(Product product) { + this.product = product; + } + + public String getSlot() { + return slot; + } + + public void setSlot(String slot) { + this.slot = slot; + } + + public Integer getPosition() { + return position; + } + + public void setPosition(Integer position) { + this.position = position; + } + + public Integer getQuantity() { + return quantity; + } + + public void setQuantity(Integer quantity) { + this.quantity = quantity; + } + + public OffsetDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(OffsetDateTime createdAt) { + this.createdAt = createdAt; + } + + public OffsetDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(OffsetDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public OffsetDateTime getDeletedAt() { + return deletedAt; + } + + public void setDeletedAt(OffsetDateTime deletedAt) { + this.deletedAt = deletedAt; + } + +} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Category.java b/src/main/java/group/goforward/ballistic/model/Category.java deleted file mode 100644 index 37a40b7..0000000 --- a/src/main/java/group/goforward/ballistic/model/Category.java +++ /dev/null @@ -1,96 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "categories") -public class Category { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "name", nullable = false, length = 100) - private String name; - - @Column(name = "parent_category_id") - private Integer parentCategoryId; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private UUID uuid; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public Integer getParentCategoryId() { - return parentCategoryId; - } - - public void setParentCategoryId(Integer parentCategoryId) { - this.parentCategoryId = parentCategoryId; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - - public UUID getUuid() { - return uuid; - } - - public void setUuid(UUID uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Compartment.java b/src/main/java/group/goforward/ballistic/model/Compartment.java deleted file mode 100644 index c5f838e..0000000 --- a/src/main/java/group/goforward/ballistic/model/Compartment.java +++ /dev/null @@ -1,85 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "compartment") -public class Compartment { - @Id - @ColumnDefault("gen_random_uuid()") - @Column(name = "id", nullable = false) - private UUID id; - - @Column(name = "name", nullable = false, length = 100) - private String name; - - @Column(name = "description", length = 300) - private String description; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - public UUID getId() { - return id; - } - - public void setId(UUID id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getDescription() { - return description; - } - - public void setDescription(String description) { - this.description = description; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/EmailVerificationCode.java b/src/main/java/group/goforward/ballistic/model/EmailVerificationCode.java deleted file mode 100644 index d735503..0000000 --- a/src/main/java/group/goforward/ballistic/model/EmailVerificationCode.java +++ /dev/null @@ -1,71 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.OffsetDateTime; - -@Entity -@Table(name = "email_verification_codes") -public class EmailVerificationCode { - @Id - @ColumnDefault("nextval('email_verification_codes_id_seq')") - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "user_id", nullable = false, length = 21) - private String userId; - - @Column(name = "email", nullable = false) - private String email; - - @Column(name = "code", nullable = false, length = 8) - private String code; - - @Column(name = "expires_at", nullable = false) - private OffsetDateTime expiresAt; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getUserId() { - return userId; - } - - public void setUserId(String userId) { - this.userId = userId; - } - - public String getEmail() { - return email; - } - - public void setEmail(String email) { - this.email = email; - } - - public String getCode() { - return code; - } - - public void setCode(String code) { - this.code = code; - } - - public OffsetDateTime getExpiresAt() { - return expiresAt; - } - - public void setExpiresAt(OffsetDateTime expiresAt) { - this.expiresAt = expiresAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Lipseycatalog.java b/src/main/java/group/goforward/ballistic/model/Lipseycatalog.java deleted file mode 100644 index 5a7fb20..0000000 --- a/src/main/java/group/goforward/ballistic/model/Lipseycatalog.java +++ /dev/null @@ -1,909 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; - -@Entity -@Table(name = "lipseycatalog") -public class Lipseycatalog { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "itemno", nullable = false, length = 20) - private String itemno; - - @Column(name = "description1", length = Integer.MAX_VALUE) - private String description1; - - @Column(name = "description2", length = Integer.MAX_VALUE) - private String description2; - - @Column(name = "upc", length = 20) - private String upc; - - @Column(name = "manufacturermodelno", length = 30) - private String manufacturermodelno; - - @Column(name = "msrp") - private Double msrp; - - @Column(name = "model", length = Integer.MAX_VALUE) - private String model; - - @Column(name = "calibergauge", length = Integer.MAX_VALUE) - private String calibergauge; - - @Column(name = "manufacturer", length = Integer.MAX_VALUE) - private String manufacturer; - - @Column(name = "type", length = Integer.MAX_VALUE) - private String type; - - @Column(name = "action", length = Integer.MAX_VALUE) - private String action; - - @Column(name = "barrellength", length = Integer.MAX_VALUE) - private String barrellength; - - @Column(name = "capacity", length = Integer.MAX_VALUE) - private String capacity; - - @Column(name = "finish", length = Integer.MAX_VALUE) - private String finish; - - @Column(name = "overalllength", length = Integer.MAX_VALUE) - private String overalllength; - - @Column(name = "receiver", length = Integer.MAX_VALUE) - private String receiver; - - @Column(name = "safety", length = Integer.MAX_VALUE) - private String safety; - - @Column(name = "sights", length = Integer.MAX_VALUE) - private String sights; - - @Column(name = "stockframegrips", length = Integer.MAX_VALUE) - private String stockframegrips; - - @Column(name = "magazine", length = Integer.MAX_VALUE) - private String magazine; - - @Column(name = "weight", length = Integer.MAX_VALUE) - private String weight; - - @Column(name = "imagename", length = Integer.MAX_VALUE) - private String imagename; - - @Column(name = "chamber", length = Integer.MAX_VALUE) - private String chamber; - - @Column(name = "drilledandtapped", length = Integer.MAX_VALUE) - private String drilledandtapped; - - @Column(name = "rateoftwist", length = Integer.MAX_VALUE) - private String rateoftwist; - - @Column(name = "itemtype", length = Integer.MAX_VALUE) - private String itemtype; - - @Column(name = "additionalfeature1", length = Integer.MAX_VALUE) - private String additionalfeature1; - - @Column(name = "additionalfeature2", length = Integer.MAX_VALUE) - private String additionalfeature2; - - @Column(name = "additionalfeature3", length = Integer.MAX_VALUE) - private String additionalfeature3; - - @Column(name = "shippingweight", length = Integer.MAX_VALUE) - private String shippingweight; - - @Column(name = "boundbookmanufacturer", length = Integer.MAX_VALUE) - private String boundbookmanufacturer; - - @Column(name = "boundbookmodel", length = Integer.MAX_VALUE) - private String boundbookmodel; - - @Column(name = "boundbooktype", length = Integer.MAX_VALUE) - private String boundbooktype; - - @Column(name = "nfathreadpattern", length = Integer.MAX_VALUE) - private String nfathreadpattern; - - @Column(name = "nfaattachmentmethod", length = Integer.MAX_VALUE) - private String nfaattachmentmethod; - - @Column(name = "nfabaffletype", length = Integer.MAX_VALUE) - private String nfabaffletype; - - @Column(name = "silencercanbedisassembled", length = Integer.MAX_VALUE) - private String silencercanbedisassembled; - - @Column(name = "silencerconstructionmaterial", length = Integer.MAX_VALUE) - private String silencerconstructionmaterial; - - @Column(name = "nfadbreduction", length = Integer.MAX_VALUE) - private String nfadbreduction; - - @Column(name = "silenceroutsidediameter", length = Integer.MAX_VALUE) - private String silenceroutsidediameter; - - @Column(name = "\"nfaform3Caliber\"", length = Integer.MAX_VALUE) - private String nfaform3Caliber; - - @Column(name = "opticmagnification", length = Integer.MAX_VALUE) - private String opticmagnification; - - @Column(name = "maintubesize", length = Integer.MAX_VALUE) - private String maintubesize; - - @Column(name = "adjustableobjective", length = Integer.MAX_VALUE) - private String adjustableobjective; - - @Column(name = "objectivesize", length = Integer.MAX_VALUE) - private String objectivesize; - - @Column(name = "opticadjustments", length = Integer.MAX_VALUE) - private String opticadjustments; - - @Column(name = "illuminatedreticle", length = Integer.MAX_VALUE) - private String illuminatedreticle; - - @Column(name = "reticle", length = Integer.MAX_VALUE) - private String reticle; - - @Column(name = "exclusive", length = Integer.MAX_VALUE) - private String exclusive; - - @ColumnDefault("NULL") - @Column(name = "quantity", length = 10) - private String quantity; - - @Column(name = "allocated", length = Integer.MAX_VALUE) - private String allocated; - - @Column(name = "onsale", length = Integer.MAX_VALUE) - private String onsale; - - @Column(name = "price") - private Double price; - - @Column(name = "currentprice") - private Double currentprice; - - @Column(name = "retailmap") - private Double retailmap; - - @Column(name = "fflrequired", length = Integer.MAX_VALUE) - private String fflrequired; - - @Column(name = "sotrequired", length = Integer.MAX_VALUE) - private String sotrequired; - - @Column(name = "exclusivetype", length = Integer.MAX_VALUE) - private String exclusivetype; - - @Column(name = "scopecoverincluded", length = Integer.MAX_VALUE) - private String scopecoverincluded; - - @Column(name = "special", length = Integer.MAX_VALUE) - private String special; - - @Column(name = "sightstype", length = Integer.MAX_VALUE) - private String sightstype; - - @Column(name = "\"case\"", length = Integer.MAX_VALUE) - private String caseField; - - @Column(name = "choke", length = Integer.MAX_VALUE) - private String choke; - - @Column(name = "dbreduction", length = Integer.MAX_VALUE) - private String dbreduction; - - @Column(name = "family", length = Integer.MAX_VALUE) - private String family; - - @Column(name = "finishtype", length = Integer.MAX_VALUE) - private String finishtype; - - @Column(name = "frame", length = Integer.MAX_VALUE) - private String frame; - - @Column(name = "griptype", length = 30) - private String griptype; - - @Column(name = "handgunslidematerial", length = Integer.MAX_VALUE) - private String handgunslidematerial; - - @Column(name = "countryoforigin", length = 4) - private String countryoforigin; - - @Column(name = "itemlength", length = Integer.MAX_VALUE) - private String itemlength; - - @Column(name = "itemwidth", length = Integer.MAX_VALUE) - private String itemwidth; - - @Column(name = "itemheight", length = Integer.MAX_VALUE) - private String itemheight; - - @Column(name = "packagelength") - private Double packagelength; - - @Column(name = "packagewidth") - private Double packagewidth; - - @Column(name = "packageheight") - private Double packageheight; - - @Column(name = "itemgroup", length = 40) - private String itemgroup; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getItemno() { - return itemno; - } - - public void setItemno(String itemno) { - this.itemno = itemno; - } - - public String getDescription1() { - return description1; - } - - public void setDescription1(String description1) { - this.description1 = description1; - } - - public String getDescription2() { - return description2; - } - - public void setDescription2(String description2) { - this.description2 = description2; - } - - public String getUpc() { - return upc; - } - - public void setUpc(String upc) { - this.upc = upc; - } - - public String getManufacturermodelno() { - return manufacturermodelno; - } - - public void setManufacturermodelno(String manufacturermodelno) { - this.manufacturermodelno = manufacturermodelno; - } - - public Double getMsrp() { - return msrp; - } - - public void setMsrp(Double msrp) { - this.msrp = msrp; - } - - public String getModel() { - return model; - } - - public void setModel(String model) { - this.model = model; - } - - public String getCalibergauge() { - return calibergauge; - } - - public void setCalibergauge(String calibergauge) { - this.calibergauge = calibergauge; - } - - public String getManufacturer() { - return manufacturer; - } - - public void setManufacturer(String manufacturer) { - this.manufacturer = manufacturer; - } - - public String getType() { - return type; - } - - public void setType(String type) { - this.type = type; - } - - public String getAction() { - return action; - } - - public void setAction(String action) { - this.action = action; - } - - public String getBarrellength() { - return barrellength; - } - - public void setBarrellength(String barrellength) { - this.barrellength = barrellength; - } - - public String getCapacity() { - return capacity; - } - - public void setCapacity(String capacity) { - this.capacity = capacity; - } - - public String getFinish() { - return finish; - } - - public void setFinish(String finish) { - this.finish = finish; - } - - public String getOveralllength() { - return overalllength; - } - - public void setOveralllength(String overalllength) { - this.overalllength = overalllength; - } - - public String getReceiver() { - return receiver; - } - - public void setReceiver(String receiver) { - this.receiver = receiver; - } - - public String getSafety() { - return safety; - } - - public void setSafety(String safety) { - this.safety = safety; - } - - public String getSights() { - return sights; - } - - public void setSights(String sights) { - this.sights = sights; - } - - public String getStockframegrips() { - return stockframegrips; - } - - public void setStockframegrips(String stockframegrips) { - this.stockframegrips = stockframegrips; - } - - public String getMagazine() { - return magazine; - } - - public void setMagazine(String magazine) { - this.magazine = magazine; - } - - public String getWeight() { - return weight; - } - - public void setWeight(String weight) { - this.weight = weight; - } - - public String getImagename() { - return imagename; - } - - public void setImagename(String imagename) { - this.imagename = imagename; - } - - public String getChamber() { - return chamber; - } - - public void setChamber(String chamber) { - this.chamber = chamber; - } - - public String getDrilledandtapped() { - return drilledandtapped; - } - - public void setDrilledandtapped(String drilledandtapped) { - this.drilledandtapped = drilledandtapped; - } - - public String getRateoftwist() { - return rateoftwist; - } - - public void setRateoftwist(String rateoftwist) { - this.rateoftwist = rateoftwist; - } - - public String getItemtype() { - return itemtype; - } - - public void setItemtype(String itemtype) { - this.itemtype = itemtype; - } - - public String getAdditionalfeature1() { - return additionalfeature1; - } - - public void setAdditionalfeature1(String additionalfeature1) { - this.additionalfeature1 = additionalfeature1; - } - - public String getAdditionalfeature2() { - return additionalfeature2; - } - - public void setAdditionalfeature2(String additionalfeature2) { - this.additionalfeature2 = additionalfeature2; - } - - public String getAdditionalfeature3() { - return additionalfeature3; - } - - public void setAdditionalfeature3(String additionalfeature3) { - this.additionalfeature3 = additionalfeature3; - } - - public String getShippingweight() { - return shippingweight; - } - - public void setShippingweight(String shippingweight) { - this.shippingweight = shippingweight; - } - - public String getBoundbookmanufacturer() { - return boundbookmanufacturer; - } - - public void setBoundbookmanufacturer(String boundbookmanufacturer) { - this.boundbookmanufacturer = boundbookmanufacturer; - } - - public String getBoundbookmodel() { - return boundbookmodel; - } - - public void setBoundbookmodel(String boundbookmodel) { - this.boundbookmodel = boundbookmodel; - } - - public String getBoundbooktype() { - return boundbooktype; - } - - public void setBoundbooktype(String boundbooktype) { - this.boundbooktype = boundbooktype; - } - - public String getNfathreadpattern() { - return nfathreadpattern; - } - - public void setNfathreadpattern(String nfathreadpattern) { - this.nfathreadpattern = nfathreadpattern; - } - - public String getNfaattachmentmethod() { - return nfaattachmentmethod; - } - - public void setNfaattachmentmethod(String nfaattachmentmethod) { - this.nfaattachmentmethod = nfaattachmentmethod; - } - - public String getNfabaffletype() { - return nfabaffletype; - } - - public void setNfabaffletype(String nfabaffletype) { - this.nfabaffletype = nfabaffletype; - } - - public String getSilencercanbedisassembled() { - return silencercanbedisassembled; - } - - public void setSilencercanbedisassembled(String silencercanbedisassembled) { - this.silencercanbedisassembled = silencercanbedisassembled; - } - - public String getSilencerconstructionmaterial() { - return silencerconstructionmaterial; - } - - public void setSilencerconstructionmaterial(String silencerconstructionmaterial) { - this.silencerconstructionmaterial = silencerconstructionmaterial; - } - - public String getNfadbreduction() { - return nfadbreduction; - } - - public void setNfadbreduction(String nfadbreduction) { - this.nfadbreduction = nfadbreduction; - } - - public String getSilenceroutsidediameter() { - return silenceroutsidediameter; - } - - public void setSilenceroutsidediameter(String silenceroutsidediameter) { - this.silenceroutsidediameter = silenceroutsidediameter; - } - - public String getNfaform3Caliber() { - return nfaform3Caliber; - } - - public void setNfaform3Caliber(String nfaform3Caliber) { - this.nfaform3Caliber = nfaform3Caliber; - } - - public String getOpticmagnification() { - return opticmagnification; - } - - public void setOpticmagnification(String opticmagnification) { - this.opticmagnification = opticmagnification; - } - - public String getMaintubesize() { - return maintubesize; - } - - public void setMaintubesize(String maintubesize) { - this.maintubesize = maintubesize; - } - - public String getAdjustableobjective() { - return adjustableobjective; - } - - public void setAdjustableobjective(String adjustableobjective) { - this.adjustableobjective = adjustableobjective; - } - - public String getObjectivesize() { - return objectivesize; - } - - public void setObjectivesize(String objectivesize) { - this.objectivesize = objectivesize; - } - - public String getOpticadjustments() { - return opticadjustments; - } - - public void setOpticadjustments(String opticadjustments) { - this.opticadjustments = opticadjustments; - } - - public String getIlluminatedreticle() { - return illuminatedreticle; - } - - public void setIlluminatedreticle(String illuminatedreticle) { - this.illuminatedreticle = illuminatedreticle; - } - - public String getReticle() { - return reticle; - } - - public void setReticle(String reticle) { - this.reticle = reticle; - } - - public String getExclusive() { - return exclusive; - } - - public void setExclusive(String exclusive) { - this.exclusive = exclusive; - } - - public String getQuantity() { - return quantity; - } - - public void setQuantity(String quantity) { - this.quantity = quantity; - } - - public String getAllocated() { - return allocated; - } - - public void setAllocated(String allocated) { - this.allocated = allocated; - } - - public String getOnsale() { - return onsale; - } - - public void setOnsale(String onsale) { - this.onsale = onsale; - } - - public Double getPrice() { - return price; - } - - public void setPrice(Double price) { - this.price = price; - } - - public Double getCurrentprice() { - return currentprice; - } - - public void setCurrentprice(Double currentprice) { - this.currentprice = currentprice; - } - - public Double getRetailmap() { - return retailmap; - } - - public void setRetailmap(Double retailmap) { - this.retailmap = retailmap; - } - - public String getFflrequired() { - return fflrequired; - } - - public void setFflrequired(String fflrequired) { - this.fflrequired = fflrequired; - } - - public String getSotrequired() { - return sotrequired; - } - - public void setSotrequired(String sotrequired) { - this.sotrequired = sotrequired; - } - - public String getExclusivetype() { - return exclusivetype; - } - - public void setExclusivetype(String exclusivetype) { - this.exclusivetype = exclusivetype; - } - - public String getScopecoverincluded() { - return scopecoverincluded; - } - - public void setScopecoverincluded(String scopecoverincluded) { - this.scopecoverincluded = scopecoverincluded; - } - - public String getSpecial() { - return special; - } - - public void setSpecial(String special) { - this.special = special; - } - - public String getSightstype() { - return sightstype; - } - - public void setSightstype(String sightstype) { - this.sightstype = sightstype; - } - - public String getCaseField() { - return caseField; - } - - public void setCaseField(String caseField) { - this.caseField = caseField; - } - - public String getChoke() { - return choke; - } - - public void setChoke(String choke) { - this.choke = choke; - } - - public String getDbreduction() { - return dbreduction; - } - - public void setDbreduction(String dbreduction) { - this.dbreduction = dbreduction; - } - - public String getFamily() { - return family; - } - - public void setFamily(String family) { - this.family = family; - } - - public String getFinishtype() { - return finishtype; - } - - public void setFinishtype(String finishtype) { - this.finishtype = finishtype; - } - - public String getFrame() { - return frame; - } - - public void setFrame(String frame) { - this.frame = frame; - } - - public String getGriptype() { - return griptype; - } - - public void setGriptype(String griptype) { - this.griptype = griptype; - } - - public String getHandgunslidematerial() { - return handgunslidematerial; - } - - public void setHandgunslidematerial(String handgunslidematerial) { - this.handgunslidematerial = handgunslidematerial; - } - - public String getCountryoforigin() { - return countryoforigin; - } - - public void setCountryoforigin(String countryoforigin) { - this.countryoforigin = countryoforigin; - } - - public String getItemlength() { - return itemlength; - } - - public void setItemlength(String itemlength) { - this.itemlength = itemlength; - } - - public String getItemwidth() { - return itemwidth; - } - - public void setItemwidth(String itemwidth) { - this.itemwidth = itemwidth; - } - - public String getItemheight() { - return itemheight; - } - - public void setItemheight(String itemheight) { - this.itemheight = itemheight; - } - - public Double getPackagelength() { - return packagelength; - } - - public void setPackagelength(Double packagelength) { - this.packagelength = packagelength; - } - - public Double getPackagewidth() { - return packagewidth; - } - - public void setPackagewidth(Double packagewidth) { - this.packagewidth = packagewidth; - } - - public Double getPackageheight() { - return packageheight; - } - - public void setPackageheight(Double packageheight) { - this.packageheight = packageheight; - } - - public String getItemgroup() { - return itemgroup; - } - - public void setItemgroup(String itemgroup) { - this.itemgroup = itemgroup; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Manufacturer.java b/src/main/java/group/goforward/ballistic/model/Manufacturer.java deleted file mode 100644 index f7f0639..0000000 --- a/src/main/java/group/goforward/ballistic/model/Manufacturer.java +++ /dev/null @@ -1,85 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "manufacturer") -public class Manufacturer { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "name", nullable = false, length = 100) - private String name; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private UUID uuid; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - - public UUID getUuid() { - return uuid; - } - - public void setUuid(UUID uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/MerchantCategoryMap.java b/src/main/java/group/goforward/ballistic/model/MerchantCategoryMap.java new file mode 100644 index 0000000..d319ab5 --- /dev/null +++ b/src/main/java/group/goforward/ballistic/model/MerchantCategoryMap.java @@ -0,0 +1,174 @@ +package group.goforward.ballistic.model; + +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Size; +import org.hibernate.annotations.ColumnDefault; +import org.hibernate.annotations.OnDelete; +import org.hibernate.annotations.OnDeleteAction; + +import java.math.BigDecimal; +import java.time.OffsetDateTime; + +@Entity +@Table(name = "merchant_category_map") +public class MerchantCategoryMap { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "id", nullable = false) + private Integer id; + + @NotNull + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @OnDelete(action = OnDeleteAction.CASCADE) + @JoinColumn(name = "merchant_id", nullable = false) + private Merchant merchant; + + @NotNull + @Column(name = "raw_category", nullable = false, length = Integer.MAX_VALUE) + private String rawCategory; + + @Column(name = "canonical_part_role", length = Integer.MAX_VALUE) + private String canonicalPartRole; + + @Column(name = "confidence", precision = 5, scale = 2) + private BigDecimal confidence; + + @Column(name = "notes", length = Integer.MAX_VALUE) + private String notes; + + @NotNull + @ColumnDefault("now()") + @Column(name = "created_at", nullable = false) + private OffsetDateTime createdAt; + + @NotNull + @ColumnDefault("now()") + @Column(name = "updated_at", nullable = false) + private OffsetDateTime updatedAt; + + @Size(max = 255) + @Column(name = "canonical_category") + private String canonicalCategory; + + @NotNull + @ColumnDefault("true") + @Column(name = "enabled", nullable = false) + private Boolean enabled = false; + + @Size(max = 100) + @Column(name = "platform", length = 100) + private String platform; + + @Size(max = 100) + @Column(name = "part_role", length = 100) + private String partRole; + + @Column(name = "deleted_at") + private OffsetDateTime deletedAt; + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public Merchant getMerchant() { + return merchant; + } + + public void setMerchant(Merchant merchant) { + this.merchant = merchant; + } + + public String getRawCategory() { + return rawCategory; + } + + public void setRawCategory(String rawCategory) { + this.rawCategory = rawCategory; + } + + public String getCanonicalPartRole() { + return canonicalPartRole; + } + + public void setCanonicalPartRole(String canonicalPartRole) { + this.canonicalPartRole = canonicalPartRole; + } + + public BigDecimal getConfidence() { + return confidence; + } + + public void setConfidence(BigDecimal confidence) { + this.confidence = confidence; + } + + public String getNotes() { + return notes; + } + + public void setNotes(String notes) { + this.notes = notes; + } + + public OffsetDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(OffsetDateTime createdAt) { + this.createdAt = createdAt; + } + + public OffsetDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(OffsetDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public String getCanonicalCategory() { + return canonicalCategory; + } + + public void setCanonicalCategory(String canonicalCategory) { + this.canonicalCategory = canonicalCategory; + } + + public Boolean getEnabled() { + return enabled; + } + + public void setEnabled(Boolean enabled) { + this.enabled = enabled; + } + + public String getPlatform() { + return platform; + } + + public void setPlatform(String platform) { + this.platform = platform; + } + + public String getPartRole() { + return partRole; + } + + public void setPartRole(String partRole) { + this.partRole = partRole; + } + + public OffsetDateTime getDeletedAt() { + return deletedAt; + } + + public void setDeletedAt(OffsetDateTime deletedAt) { + this.deletedAt = deletedAt; + } + +} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/PasswordResetToken.java b/src/main/java/group/goforward/ballistic/model/PasswordResetToken.java deleted file mode 100644 index 3996494..0000000 --- a/src/main/java/group/goforward/ballistic/model/PasswordResetToken.java +++ /dev/null @@ -1,47 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; - -import java.time.OffsetDateTime; - -@Entity -@Table(name = "password_reset_tokens") -public class PasswordResetToken { - @Id - @Column(name = "id", nullable = false, length = 40) - private String id; - - @Column(name = "user_id", nullable = false, length = 21) - private String userId; - - @Column(name = "expires_at", nullable = false) - private OffsetDateTime expiresAt; - - public String getId() { - return id; - } - - public void setId(String id) { - this.id = id; - } - - public String getUserId() { - return userId; - } - - public void setUserId(String userId) { - this.userId = userId; - } - - public OffsetDateTime getExpiresAt() { - return expiresAt; - } - - public void setExpiresAt(OffsetDateTime expiresAt) { - this.expiresAt = expiresAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Platform.java b/src/main/java/group/goforward/ballistic/model/Platform.java new file mode 100644 index 0000000..f2d826b --- /dev/null +++ b/src/main/java/group/goforward/ballistic/model/Platform.java @@ -0,0 +1,84 @@ +package group.goforward.ballistic.model; + +import jakarta.persistence.*; +import jakarta.validation.constraints.NotNull; +import org.hibernate.annotations.ColumnDefault; + +import java.time.OffsetDateTime; + +@Entity +@Table(name = "platforms") +public class Platform { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "id", nullable = false) + private Integer id; + + @NotNull + @Column(name = "key", nullable = false, length = Integer.MAX_VALUE) + private String key; + + @NotNull + @Column(name = "label", nullable = false, length = Integer.MAX_VALUE) + private String label; + + @ColumnDefault("CURRENT_TIMESTAMP") + @Column(name = "created_at") + private OffsetDateTime createdAt; + + @ColumnDefault("CURRENT_TIMESTAMP") + @Column(name = "updated_at") + private OffsetDateTime updatedAt; + + @Column(name = "deleted_at") + private OffsetDateTime deletedAt; + + public Integer getId() { + return id; + } + + public void setId(Integer id) { + this.id = id; + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getLabel() { + return label; + } + + public void setLabel(String label) { + this.label = label; + } + + public OffsetDateTime getCreatedAt() { + return createdAt; + } + + public void setCreatedAt(OffsetDateTime createdAt) { + this.createdAt = createdAt; + } + + public OffsetDateTime getUpdatedAt() { + return updatedAt; + } + + public void setUpdatedAt(OffsetDateTime updatedAt) { + this.updatedAt = updatedAt; + } + + public OffsetDateTime getDeletedAt() { + return deletedAt; + } + + public void setDeletedAt(OffsetDateTime deletedAt) { + this.deletedAt = deletedAt; + } + +} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Post.java b/src/main/java/group/goforward/ballistic/model/Post.java deleted file mode 100644 index b1b63cd..0000000 --- a/src/main/java/group/goforward/ballistic/model/Post.java +++ /dev/null @@ -1,116 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; - -@Entity -@Table(name = "posts") -public class Post { - @Id - @Column(name = "id", nullable = false, length = 15) - private String id; - - @Column(name = "user_id", nullable = false) - private String userId; - - @Column(name = "title", nullable = false) - private String title; - - @Column(name = "excerpt", nullable = false) - private String excerpt; - - @Column(name = "content", nullable = false, length = Integer.MAX_VALUE) - private String content; - - @ColumnDefault("'draft'") - @Column(name = "status", nullable = false, length = 10) - private String status; - - @Column(name = "tags") - private String tags; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "updated_at") - private Instant updatedAt; - - public String getId() { - return id; - } - - public void setId(String id) { - this.id = id; - } - - public String getUserId() { - return userId; - } - - public void setUserId(String userId) { - this.userId = userId; - } - - public String getTitle() { - return title; - } - - public void setTitle(String title) { - this.title = title; - } - - public String getExcerpt() { - return excerpt; - } - - public void setExcerpt(String excerpt) { - this.excerpt = excerpt; - } - - public String getContent() { - return content; - } - - public void setContent(String content) { - this.content = content; - } - - public String getStatus() { - return status; - } - - public void setStatus(String status) { - this.status = status; - } - - public String getTags() { - return tags; - } - - public void setTags(String tags) { - this.tags = tags; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/ProductCategory.java b/src/main/java/group/goforward/ballistic/model/ProductCategory.java deleted file mode 100644 index c21d12c..0000000 --- a/src/main/java/group/goforward/ballistic/model/ProductCategory.java +++ /dev/null @@ -1,93 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.*; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; - -@Entity -@Table(name = "product_categories") -public class ProductCategory { - @Id - @GeneratedValue(strategy = GenerationType.IDENTITY) - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "name", nullable = false, length = 100) - private String name; - - @ManyToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "parent_category_id") - private ProductCategory parentCategory; - - @Column(name = "type", length = 50) - private String type; - - @Column(name = "sort_order") - private Integer sortOrder; - - @ColumnDefault("now()") - @Column(name = "created_at") - private Instant createdAt; - - @ColumnDefault("now()") - @Column(name = "updated_at") - private Instant updatedAt; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public ProductCategory getParentCategory() { - return parentCategory; - } - - public void setParentCategory(ProductCategory parentCategory) { - this.parentCategory = parentCategory; - } - - public String getType() { - return type; - } - - public void setType(String type) { - this.type = type; - } - - public Integer getSortOrder() { - return sortOrder; - } - - public void setSortOrder(Integer sortOrder) { - this.sortOrder = sortOrder; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/ProductFeed.java b/src/main/java/group/goforward/ballistic/model/ProductFeed.java deleted file mode 100644 index 2378bd9..0000000 --- a/src/main/java/group/goforward/ballistic/model/ProductFeed.java +++ /dev/null @@ -1,107 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.util.UUID; - -@Entity -@Table(name = "product_feeds") -public class ProductFeed { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "reseller_id", nullable = false) - private Integer resellerId; - - @Column(name = "feed_url", nullable = false) - private String feedUrl; - - @Column(name = "last_update") - private Instant lastUpdate; - - @ColumnDefault("now()") - @Column(name = "updated_at", nullable = false) - private Instant updatedAt; - - @ColumnDefault("now()") - @Column(name = "created_at", nullable = false) - private Instant createdAt; - - @Column(name = "deleted_at") - private Instant deletedAt; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private UUID uuid; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public Integer getResellerId() { - return resellerId; - } - - public void setResellerId(Integer resellerId) { - this.resellerId = resellerId; - } - - public String getFeedUrl() { - return feedUrl; - } - - public void setFeedUrl(String feedUrl) { - this.feedUrl = feedUrl; - } - - public Instant getLastUpdate() { - return lastUpdate; - } - - public void setLastUpdate(Instant lastUpdate) { - this.lastUpdate = lastUpdate; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getDeletedAt() { - return deletedAt; - } - - public void setDeletedAt(Instant deletedAt) { - this.deletedAt = deletedAt; - } - - public UUID getUuid() { - return uuid; - } - - public void setUuid(UUID uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Psa.java b/src/main/java/group/goforward/ballistic/model/Psa.java deleted file mode 100644 index 80dfa66..0000000 --- a/src/main/java/group/goforward/ballistic/model/Psa.java +++ /dev/null @@ -1,357 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -@Entity -@Table(name = "psa") -public class Psa { - @Id - @Column(name = "id", nullable = false) - private Integer id; - - @Column(name = "\"SKU\"", length = 50) - private String sku; - - @Column(name = "\"MANUFACTURER_ID\"", length = 50) - private String manufacturerId; - - @Column(name = "\"BRAND_NAME\"", length = 50) - private String brandName; - - @Column(name = "\"PRODUCT_NAME\"") - private String productName; - - @Column(name = "\"LONG_DESCRIPTION\"", length = Integer.MAX_VALUE) - private String longDescription; - - @Column(name = "\"SHORT_DESCRIPTION\"", length = 50) - private String shortDescription; - - @Column(name = "\"DEPARTMENT\"", length = 50) - private String department; - - @Column(name = "\"CATEGORY\"", length = 50) - private String category; - - @Column(name = "\"SUBCATEGORY\"", length = 50) - private String subcategory; - - @Column(name = "\"THUMB_URL\"", length = 50) - private String thumbUrl; - - @Column(name = "\"IMAGE_URL\"", length = 50) - private String imageUrl; - - @Column(name = "\"BUY_LINK\"", length = 128) - private String buyLink; - - @Column(name = "\"KEYWORDS\"", length = 50) - private String keywords; - - @Column(name = "\"REVIEWS\"", length = 50) - private String reviews; - - @Column(name = "\"RETAIL_PRICE\"") - private Float retailPrice; - - @Column(name = "\"SALE_PRICE\"") - private Float salePrice; - - @Column(name = "\"BRAND_PAGE_LINK\"", length = 50) - private String brandPageLink; - - /* @Column(name = "\"BRAND_LOGO_IMAGE\"", length = 50) - private String brandLogoImage;*/ - - @Column(name = "\"PRODUCT_PAGE_VIEW_TRACKING\"", length = 256) - private String productPageViewTracking; - - @Column(name = "\"PARENT_GROUP_ID\"", length = 50) - private String parentGroupId; - - @Column(name = "\"FINELINE\"", length = 50) - private String fineline; - - @Column(name = "\"SUPERFINELINE\"", length = 200) - private String superfineline; - - @Column(name = "\"MODELNUMBER\"", length = 50) - private String modelnumber; - - @Column(name = "\"CALIBER\"", length = 200) - private String caliber; - - @Column(name = "\"UPC\"", length = 100) - private String upc; - - @Column(name = "\"MEDIUM_IMAGE_URL\"", length = 50) - private String mediumImageUrl; - - @Column(name = "\"PRODUCT_CONTENT_WIDGET\"", length = 256) - private String productContentWidget; - - @Column(name = "\"GOOGLE_CATEGORIZATION\"", length = 50) - private String googleCategorization; - - @Column(name = "\"ITEM_BASED_COMMISSION\"", length = 50) - private String itemBasedCommission; - - @ColumnDefault("gen_random_uuid()") - @Column(name = "uuid") - private String uuid; - - public Integer getId() { - return id; - } - - public void setId(Integer id) { - this.id = id; - } - - public String getSku() { - return sku; - } - - public void setSku(String sku) { - this.sku = sku; - } - - public String getManufacturerId() { - return manufacturerId; - } - - public void setManufacturerId(String manufacturerId) { - this.manufacturerId = manufacturerId; - } - - public String getBrandName() { - return brandName; - } - - public void setBrandName(String brandName) { - this.brandName = brandName; - } - - public String getProductName() { - return productName; - } - - public void setProductName(String productName) { - this.productName = productName; - } - - public String getLongDescription() { - return longDescription; - } - - public void setLongDescription(String longDescription) { - this.longDescription = longDescription; - } - - public String getShortDescription() { - return shortDescription; - } - - public void setShortDescription(String shortDescription) { - this.shortDescription = shortDescription; - } - - public String getDepartment() { - return department; - } - - public void setDepartment(String department) { - this.department = department; - } - - public String getCategory() { - return category; - } - - public void setCategory(String category) { - this.category = category; - } - - public String getSubcategory() { - return subcategory; - } - - public void setSubcategory(String subcategory) { - this.subcategory = subcategory; - } - - public String getThumbUrl() { - return thumbUrl; - } - - public void setThumbUrl(String thumbUrl) { - this.thumbUrl = thumbUrl; - } - - public String getImageUrl() { - return imageUrl; - } - - public void setImageUrl(String imageUrl) { - this.imageUrl = imageUrl; - } - - public String getBuyLink() { - return buyLink; - } - - public void setBuyLink(String buyLink) { - this.buyLink = buyLink; - } - - public String getKeywords() { - return keywords; - } - - public void setKeywords(String keywords) { - this.keywords = keywords; - } - - public String getReviews() { - return reviews; - } - - public void setReviews(String reviews) { - this.reviews = reviews; - } - - public Float getRetailPrice() { - return retailPrice; - } - - public void setRetailPrice(Float retailPrice) { - this.retailPrice = retailPrice; - } - - public Float getSalePrice() { - return salePrice; - } - - public void setSalePrice(Float salePrice) { - this.salePrice = salePrice; - } - - public String getBrandPageLink() { - return brandPageLink; - } - - public void setBrandPageLink(String brandPageLink) { - this.brandPageLink = brandPageLink; - } -/* - - public String getBrandLogoImage() { - return brandLogoImage; - } - - public void setBrandLogoImage(String brandLogoImage) { - this.brandLogoImage = brandLogoImage; - } -*/ - - public String getProductPageViewTracking() { - return productPageViewTracking; - } - - public void setProductPageViewTracking(String productPageViewTracking) { - this.productPageViewTracking = productPageViewTracking; - } - - public String getParentGroupId() { - return parentGroupId; - } - - public void setParentGroupId(String parentGroupId) { - this.parentGroupId = parentGroupId; - } - - public String getFineline() { - return fineline; - } - - public void setFineline(String fineline) { - this.fineline = fineline; - } - - public String getSuperfineline() { - return superfineline; - } - - public void setSuperfineline(String superfineline) { - this.superfineline = superfineline; - } - - public String getModelnumber() { - return modelnumber; - } - - public void setModelnumber(String modelnumber) { - this.modelnumber = modelnumber; - } - - public String getCaliber() { - return caliber; - } - - public void setCaliber(String caliber) { - this.caliber = caliber; - } - - public String getUpc() { - return upc; - } - - public void setUpc(String upc) { - this.upc = upc; - } - - public String getMediumImageUrl() { - return mediumImageUrl; - } - - public void setMediumImageUrl(String mediumImageUrl) { - this.mediumImageUrl = mediumImageUrl; - } - - public String getProductContentWidget() { - return productContentWidget; - } - - public void setProductContentWidget(String productContentWidget) { - this.productContentWidget = productContentWidget; - } - - public String getGoogleCategorization() { - return googleCategorization; - } - - public void setGoogleCategorization(String googleCategorization) { - this.googleCategorization = googleCategorization; - } - - public String getItemBasedCommission() { - return itemBasedCommission; - } - - public void setItemBasedCommission(String itemBasedCommission) { - this.itemBasedCommission = itemBasedCommission; - } - - public String getUuid() { - return uuid; - } - - public void setUuid(String uuid) { - this.uuid = uuid; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/PsaOld.java b/src/main/java/group/goforward/ballistic/model/PsaOld.java deleted file mode 100644 index 1933174..0000000 --- a/src/main/java/group/goforward/ballistic/model/PsaOld.java +++ /dev/null @@ -1,23 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; - -@Entity -@Table(name = "psa_old") -public class PsaOld { - @Id - @Column(name = "\"SKU\"", length = 50) - private String sku; - - public String getSku() { - return sku; - } - - public void setSku(String sku) { - this.sku = sku; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/Session.java b/src/main/java/group/goforward/ballistic/model/Session.java deleted file mode 100644 index b252219..0000000 --- a/src/main/java/group/goforward/ballistic/model/Session.java +++ /dev/null @@ -1,73 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; -import org.hibernate.annotations.ColumnDefault; - -import java.time.Instant; -import java.time.OffsetDateTime; - -@Entity -@Table(name = "sessions") -public class Session { - @Id - @Column(name = "id", nullable = false) - private String id; - - @Column(name = "user_id", nullable = false, length = 21) - private String userId; - - @Column(name = "expires_at", nullable = false) - private OffsetDateTime expiresAt; - - @ColumnDefault("CURRENT_TIMESTAMP") - @Column(name = "created_at") - private Instant createdAt; - - @ColumnDefault("CURRENT_TIMESTAMP") - @Column(name = "updated_at") - private Instant updatedAt; - - public String getId() { - return id; - } - - public void setId(String id) { - this.id = id; - } - - public String getUserId() { - return userId; - } - - public void setUserId(String userId) { - this.userId = userId; - } - - public OffsetDateTime getExpiresAt() { - return expiresAt; - } - - public void setExpiresAt(OffsetDateTime expiresAt) { - this.expiresAt = expiresAt; - } - - public Instant getCreatedAt() { - return createdAt; - } - - public void setCreatedAt(Instant createdAt) { - this.createdAt = createdAt; - } - - public Instant getUpdatedAt() { - return updatedAt; - } - - public void setUpdatedAt(Instant updatedAt) { - this.updatedAt = updatedAt; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/model/VerificationToken.java b/src/main/java/group/goforward/ballistic/model/VerificationToken.java deleted file mode 100644 index def041e..0000000 --- a/src/main/java/group/goforward/ballistic/model/VerificationToken.java +++ /dev/null @@ -1,47 +0,0 @@ -package group.goforward.ballistic.model; - -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.Table; - -import java.time.Instant; - -@Entity -@Table(name = "\"verificationTokens\"") -public class VerificationToken { - @Id - @Column(name = "identifier", nullable = false, length = Integer.MAX_VALUE) - private String identifier; - - @Column(name = "token", nullable = false, length = Integer.MAX_VALUE) - private String token; - - @Column(name = "expires", nullable = false) - private Instant expires; - - public String getIdentifier() { - return identifier; - } - - public void setIdentifier(String identifier) { - this.identifier = identifier; - } - - public String getToken() { - return token; - } - - public void setToken(String token) { - this.token = token; - } - - public Instant getExpires() { - return expires; - } - - public void setExpires(Instant expires) { - this.expires = expires; - } - -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/repos/PsaRepository.java b/src/main/java/group/goforward/ballistic/repos/PsaRepository.java deleted file mode 100644 index 690fd52..0000000 --- a/src/main/java/group/goforward/ballistic/repos/PsaRepository.java +++ /dev/null @@ -1,7 +0,0 @@ -package group.goforward.ballistic.repos; -import group.goforward.ballistic.model.Psa; -import org.springframework.data.jpa.repository.JpaRepository; -import java.util.UUID; - -public interface PsaRepository extends JpaRepository { -} \ No newline at end of file diff --git a/src/main/java/group/goforward/ballistic/services/PsaService.java b/src/main/java/group/goforward/ballistic/services/PsaService.java deleted file mode 100644 index ecaa265..0000000 --- a/src/main/java/group/goforward/ballistic/services/PsaService.java +++ /dev/null @@ -1,17 +0,0 @@ -package group.goforward.ballistic.services; - -import group.goforward.ballistic.model.Psa; - -import java.util.List; -import java.util.Optional; -import java.util.UUID; - -public interface PsaService { - List findAll(); - - Optional findById(UUID id); - - Psa save(Psa psa); - - void deleteById(UUID id); -} diff --git a/src/main/java/group/goforward/ballistic/services/impl/PsaServiceImpl.java b/src/main/java/group/goforward/ballistic/services/impl/PsaServiceImpl.java deleted file mode 100644 index dddc752..0000000 --- a/src/main/java/group/goforward/ballistic/services/impl/PsaServiceImpl.java +++ /dev/null @@ -1,41 +0,0 @@ -package group.goforward.ballistic.services.impl; -import group.goforward.ballistic.model.Psa; -import group.goforward.ballistic.repos.PsaRepository; -import group.goforward.ballistic.services.PsaService; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Service; - -import java.util.List; -import java.util.Optional; -import java.util.UUID; - -@Service -public class PsaServiceImpl implements PsaService { - - private final PsaRepository psaRepository; - - @Autowired - public PsaServiceImpl(PsaRepository psaRepository) { - this.psaRepository = psaRepository; - } - - @Override - public List findAll() { - return psaRepository.findAll(); - } - - @Override - public Optional findById(UUID id) { - return psaRepository.findById(id); - } - - @Override - public Psa save(Psa psa) { - return psaRepository.save(psa); - } - - @Override - public void deleteById(UUID id) { - psaRepository.deleteById(id); - } -} diff --git a/update.sql b/update.sql new file mode 100644 index 0000000..1080894 --- /dev/null +++ b/update.sql @@ -0,0 +1,5 @@ +ALTER TABLE accounts + ADD COLUMN IF NOT EXISTS created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP WITH TIME ZONE; +