evergreen Functions

↑ evergreen schema

This page documents all 1095 function(s) in the evergreen schema.

Function Index

Function Return Type Language Volatility Security

_add(text, integer)

integer

sql

VOLATILE

_add(text, integer, text)

integer

plpgsql

VOLATILE

_agg(name)

boolean

sql

VOLATILE

_agg(name, name)

boolean

sql

VOLATILE

_agg(name, name, name[])

boolean

sql

VOLATILE

_agg(name, name[])

boolean

sql

VOLATILE

_alike(boolean, anyelement, text, text)

text

plpgsql

VOLATILE

_ancestor_of(name, name, integer)

boolean

sql

VOLATILE

_ancestor_of(name, name, name, name, integer)

boolean

sql

VOLATILE

_are(text, name[], name[], text)

text

plpgsql

VOLATILE

_areni(text, text[], text[], text)

text

plpgsql

VOLATILE

_array_to_sorted_string(name[], text)

text

sql

IMMUTABLE

_assets_are(text, text[], text[], text)

text

sql

VOLATILE

_cast_exists(name, name)

boolean

sql

VOLATILE

_cast_exists(name, name, name)

boolean

sql

VOLATILE

_cast_exists(name, name, name, name)

boolean

sql

VOLATILE

_cdi(name, name, anyelement)

text

sql

VOLATILE

_cdi(name, name, anyelement, text)

text

plpgsql

VOLATILE

_cdi(name, name, name, anyelement, text)

text

plpgsql

VOLATILE

_cexists(name, name)

boolean

sql

VOLATILE

_cexists(name, name, name)

boolean

sql

VOLATILE

_ckeys(name, character)

name[]

sql

VOLATILE

_ckeys(name, name, character)

name[]

sql

VOLATILE

_cleanup()

boolean

sql

VOLATILE

_cmp_types(oid, name)

boolean

plpgsql

VOLATILE

_col_is_null(name, name, name, text, boolean)

text

plpgsql

VOLATILE

_col_is_null(name, name, text, boolean)

text

plpgsql

VOLATILE

_constraint(name, character, name[], text, text)

text

plpgsql

VOLATILE

_constraint(name, name, character, name[], text, …​)

text

plpgsql

VOLATILE

_contract_on(text)

"char"

sql

IMMUTABLE

_currtest()

integer

plpgsql

VOLATILE

_db_privs()

name[]

plpgsql

VOLATILE

_def_is(text, text, anyelement, text)

text

plpgsql

VOLATILE

_definer(name)

boolean

sql

VOLATILE

_definer(name, name)

boolean

sql

VOLATILE

_definer(name, name, name[])

boolean

sql

VOLATILE

_definer(name, name[])

boolean

sql

VOLATILE

_dexists(name)

boolean

sql

VOLATILE

_dexists(name, name)

boolean

sql

VOLATILE

_do_ne(text, text, text, text)

text

plpgsql

VOLATILE

_docomp(text, text, text, text)

text

plpgsql

VOLATILE

_error_diag(text, text, text, text, text, text, t…​)

text

sql

IMMUTABLE

_expand_context(character)

text

sql

IMMUTABLE

_expand_on(character)

text

sql

IMMUTABLE

_expand_vol(character)

text

sql

IMMUTABLE

_ext_exists(name)

boolean

sql

VOLATILE

_ext_exists(name, name)

boolean

sql

VOLATILE

_extensions()

SETOF name

sql

VOLATILE

_extensions(name)

SETOF name

sql

VOLATILE

_extras(character, name, name[])

name[]

sql

VOLATILE

_extras(character, name[])

name[]

sql

VOLATILE

_extras(character[], name, name[])

name[]

sql

VOLATILE

_extras(character[], name[])

name[]

sql

VOLATILE

_finish(integer, integer, integer, boolean DE…​)

SETOF text

plpgsql

VOLATILE

_fkexists(name, name, name[])

boolean

sql

VOLATILE

_fkexists(name, name[])

boolean

sql

VOLATILE

_fprivs_are(text, name, name[], text)

text

plpgsql

VOLATILE

_func_compare(name, name, anyelement, anyelement, text)

text

sql

VOLATILE

_func_compare(name, name, boolean, text)

text

sql

VOLATILE

_func_compare(name, name, name[], anyelement, anyel…​)

text

sql

VOLATILE

_func_compare(name, name, name[], boolean, text)

text

sql

VOLATILE

_funkargs(name[])

text

plpgsql

STABLE

_get(text)

integer

plpgsql

VOLATILE

_get_ac_privs(name, text)

text[]

plpgsql

VOLATILE

_get_col_ns_type(name, name, name)

text

sql

VOLATILE

_get_col_privs(name, text, name)

text[]

plpgsql

VOLATILE

_get_col_type(name, name)

text

sql

VOLATILE

_get_col_type(name, name, name)

text

sql

VOLATILE

_get_context(name, name)

"char"

sql

VOLATILE

_get_db_owner(name)

name

sql

VOLATILE

_get_db_privs(name, text)

text[]

plpgsql

VOLATILE

_get_dtype(name)

text

sql

VOLATILE

_get_dtype(name, text, boolean)

text

sql

VOLATILE

_get_fdw_privs(name, text)

text[]

plpgsql

VOLATILE

_get_func_owner(name, name, name[])

name

sql

VOLATILE

_get_func_owner(name, name[])

name

sql

VOLATILE

_get_func_privs(text, text)

text[]

plpgsql

VOLATILE

_get_index_owner(name, name)

name

sql

VOLATILE

_get_index_owner(name, name, name)

name

sql

VOLATILE

_get_lang_privs(name, text)

text[]

plpgsql

VOLATILE

_get_language_owner(name)

name

sql

VOLATILE

_get_latest(text)

integer[]

plpgsql

VOLATILE

_get_latest(text, integer)

integer

plpgsql

VOLATILE

_get_note(integer)

text

plpgsql

VOLATILE

_get_note(text)

text

plpgsql

VOLATILE

_get_opclass_owner(name)

name

sql

VOLATILE

_get_opclass_owner(name, name)

name

sql

VOLATILE

_get_rel_owner(character, name)

name

sql

VOLATILE

_get_rel_owner(character, name, name)

name

sql

VOLATILE

_get_rel_owner(character[], name)

name

sql

VOLATILE

_get_rel_owner(character[], name, name)

name

sql

VOLATILE

_get_rel_owner(name)

name

sql

VOLATILE

_get_rel_owner(name, name)

name

sql

VOLATILE

_get_schema_owner(name)

name

sql

VOLATILE

_get_schema_privs(name, text)

text[]

plpgsql

VOLATILE

_get_sequence_privs(name, text)

text[]

plpgsql

VOLATILE

_get_server_privs(name, text)

text[]

plpgsql

VOLATILE

_get_table_privs(name, text)

text[]

plpgsql

VOLATILE

_get_tablespace_owner(name)

name

sql

VOLATILE

_get_tablespaceprivs(name, text)

text[]

plpgsql

VOLATILE

_get_type_owner(name)

name

sql

VOLATILE

_get_type_owner(name, name)

name

sql

VOLATILE

_got_func(name)

boolean

sql

VOLATILE

_got_func(name, name)

boolean

sql

VOLATILE

_got_func(name, name, name[])

boolean

sql

VOLATILE

_got_func(name, name[])

boolean

sql

VOLATILE

_grolist(name)

oid[]

sql

VOLATILE

_has_def(name, name)

boolean

sql

VOLATILE

_has_def(name, name, name)

boolean

sql

VOLATILE

_has_group(name)

boolean

sql

VOLATILE

_has_role(name)

boolean

sql

VOLATILE

_has_type(name, character[])

boolean

sql

VOLATILE

_has_type(name, name, character[])

boolean

sql

VOLATILE

_has_user(name)

boolean

sql

VOLATILE

_hasc(name, character)

boolean

sql

VOLATILE

_hasc(name, name, character)

boolean

sql

VOLATILE

_have_index(name, name)

boolean

sql

VOLATILE

_have_index(name, name, name)

boolean

sql

VOLATILE

_ident_array_to_sorted_string(name[], text)

text

sql

IMMUTABLE

_ident_array_to_string(name[], text)

text

sql

IMMUTABLE

_ikeys(name, name)

text[]

sql

VOLATILE

_ikeys(name, name, name)

text[]

sql

VOLATILE

_inherited(name)

boolean

sql

VOLATILE

_inherited(name, name)

boolean

sql

VOLATILE

_is_indexed(name, name, text[])

boolean

sql

VOLATILE

_is_instead(name, name)

boolean

sql

VOLATILE

_is_instead(name, name, name)

boolean

sql

VOLATILE

_is_schema(name)

boolean

sql

VOLATILE

_is_super(name)

boolean

sql

VOLATILE

_is_trusted(name)

boolean

sql

VOLATILE

_is_verbose()

boolean

sql

STABLE

_keys(name, character)

SETOF name[]

sql

VOLATILE

_keys(name, name, character)

SETOF name[]

sql

VOLATILE

_lang(name)

name

sql

VOLATILE

_lang(name, name)

name

sql

VOLATILE

_lang(name, name, name[])

name

sql

VOLATILE

_lang(name, name[])

name

sql

VOLATILE

_missing(character, name, name[])

name[]

sql

VOLATILE

_missing(character, name[])

name[]

sql

VOLATILE

_missing(character[], name, name[])

name[]

sql

VOLATILE

_missing(character[], name[])

name[]

sql

VOLATILE

_nosuch(name, name, name[])

text

sql

IMMUTABLE

_op_exists(name, name, name)

boolean

sql

VOLATILE

_op_exists(name, name, name, name)

boolean

sql

VOLATILE

_op_exists(name, name, name, name, name)

boolean

sql

VOLATILE

_opc_exists(name)

boolean

sql

VOLATILE

_opc_exists(name, name)

boolean

sql

VOLATILE

_partof(name, name)

boolean

sql

VOLATILE

_partof(name, name, name, name)

boolean

sql

VOLATILE

_parts(name)

SETOF name

sql

VOLATILE

_parts(name, name)

SETOF name

sql

VOLATILE

_pg_sv_column_array(oid, smallint[])

name[]

sql

STABLE

_pg_sv_table_accessible(oid, oid)

boolean

sql

IMMUTABLE

_pg_sv_type_array(oid[])

name[]

sql

STABLE

_prokind(p_oid oid)

"char"

plpgsql

STABLE

_query(text)

text

sql

VOLATILE

_quote_ident_like(text, text)

text

plpgsql

VOLATILE

_refine_vol(text)

text

sql

IMMUTABLE

_relcomp(text, anyarray, text, text)

text

sql

VOLATILE

_relcomp(text, text, text, text)

text

sql

VOLATILE

_relcomp(text, text, text, text, text)

text

plpgsql

VOLATILE

_relexists(name)

boolean

sql

VOLATILE

_relexists(name, name)

boolean

sql

VOLATILE

_relne(text, anyarray, text, text)

text

sql

VOLATILE

_relne(text, text, text, text)

text

sql

VOLATILE

_returns(name)

text

sql

VOLATILE

_returns(name, name)

text

sql

VOLATILE

_returns(name, name, name[])

text

sql

VOLATILE

_returns(name, name[])

text

sql

VOLATILE

_rexists(character, name)

boolean

sql

VOLATILE

_rexists(character, name, name)

boolean

sql

VOLATILE

_rexists(character[], name)

boolean

sql

VOLATILE

_rexists(character[], name, name)

boolean

sql

VOLATILE

_rule_on(name, name)

"char"

sql

VOLATILE

_rule_on(name, name, name)

"char"

sql

VOLATILE

_runem(text[], boolean)

SETOF text

plpgsql

VOLATILE

_runner(text[], text[], text[], text[], text[])

SETOF text

plpgsql

VOLATILE

_set(integer, integer)

integer

plpgsql

VOLATILE

_set(text, integer)

integer

sql

VOLATILE

_set(text, integer, text)

integer

plpgsql

VOLATILE

_strict(name)

boolean

sql

VOLATILE

_strict(name, name)

boolean

sql

VOLATILE

_strict(name, name, name[])

boolean

sql

VOLATILE

_strict(name, name[])

boolean

sql

VOLATILE

_table_privs()

name[]

plpgsql

VOLATILE

_temptable(anyarray, text)

text

plpgsql

VOLATILE

_temptable(text, text)

text

plpgsql

VOLATILE

_temptypes(text)

text

sql

VOLATILE

_time_trials(text, integer, numeric)

SETOF _time_trial_type

plpgsql

VOLATILE

_tlike(boolean, text, text, text)

text

sql

VOLATILE

_todo()

text

plpgsql

VOLATILE

_trig(name, name)

boolean

sql

VOLATILE

_trig(name, name, name)

boolean

sql

VOLATILE

_types_are(name, name[], text, character[])

text

sql

VOLATILE

_types_are(name[], text, character[])

text

sql

VOLATILE

_unalike(boolean, anyelement, text, text)

text

plpgsql

VOLATILE

_vol(name)

text

sql

VOLATILE

_vol(name, name)

text

sql

VOLATILE

_vol(name, name, name[])

text

sql

VOLATILE

_vol(name, name[])

text

sql

VOLATILE

add_result(boolean, boolean, text, text, text)

integer

plpgsql

VOLATILE

alike(anyelement, text)

text

sql

VOLATILE

alike(anyelement, text, text)

text

sql

VOLATILE

any_column_privs_are(name, name, name, name[])

text

sql

VOLATILE

any_column_privs_are(name, name, name, name[], text)

text

plpgsql

VOLATILE

any_column_privs_are(name, name, name[])

text

sql

VOLATILE

any_column_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

array_overlap_check()

trigger

plpgsql

VOLATILE

asset_copy_alert_copy_inh_fkey()

trigger

plpgsql

VOLATILE

asset_copy_inventory_copy_inh_fkey()

trigger

plpgsql

VOLATILE

asset_copy_note_owning_copy_inh_fkey()

trigger

plpgsql

VOLATILE

asset_copy_tag_copy_map_copy_inh_fkey()

trigger

plpgsql

VOLATILE

bag_eq(text, anyarray)

text

sql

VOLATILE

bag_eq(text, anyarray, text)

text

sql

VOLATILE

bag_eq(text, text)

text

sql

VOLATILE

bag_eq(text, text, text)

text

sql

VOLATILE

bag_has(text, text)

text

sql

VOLATILE

bag_has(text, text, text)

text

sql

VOLATILE

bag_hasnt(text, text)

text

sql

VOLATILE

bag_hasnt(text, text, text)

text

sql

VOLATILE

bag_ne(text, anyarray)

text

sql

VOLATILE

bag_ne(text, anyarray, text)

text

sql

VOLATILE

bag_ne(text, text)

text

sql

VOLATILE

bag_ne(text, text, text)

text

sql

VOLATILE

can(name, name[])

text

sql

VOLATILE

can(name, name[], text)

text

plpgsql

VOLATILE

can(name[])

text

sql

VOLATILE

can(name[], text)

text

plpgsql

VOLATILE

can_float(copy_floating_group integer, from_ou …​)

boolean

plpgsql

VOLATILE

cast_context_is(name, name, text)

text

sql

VOLATILE

cast_context_is(name, name, text, text)

text

plpgsql

VOLATILE

casts_are(text[])

text

sql

VOLATILE

casts_are(text[], text)

text

sql

VOLATILE

change_db_setting(setting_name text, settings text[])

void

plpgsql

VOLATILE

check_test(text, boolean)

SETOF text

sql

VOLATILE

check_test(text, boolean, text)

SETOF text

sql

VOLATILE

check_test(text, boolean, text, text)

SETOF text

sql

VOLATILE

check_test(text, boolean, text, text, text)

SETOF text

sql

VOLATILE

check_test(text, boolean, text, text, text, boolean)

SETOF text

plpgsql

VOLATILE

cmp_ok(anyelement, text, anyelement)

text

sql

VOLATILE

cmp_ok(anyelement, text, anyelement, text)

text

plpgsql

VOLATILE

coded_value_map_normalizer(input text, ctype text)

text

sql

VOLATILE

col_default_is(name, name, anyelement)

text

sql

VOLATILE

col_default_is(name, name, anyelement, text)

text

sql

VOLATILE

col_default_is(name, name, name, anyelement, text)

text

sql

VOLATILE

col_default_is(name, name, name, text, text)

text

sql

VOLATILE

col_default_is(name, name, text)

text

sql

VOLATILE

col_default_is(name, name, text, text)

text

sql

VOLATILE

col_has_check(name, name)

text

sql

VOLATILE

col_has_check(name, name, name, text)

text

sql

VOLATILE

col_has_check(name, name, name[], text)

text

sql

VOLATILE

col_has_check(name, name, text)

text

sql

VOLATILE

col_has_check(name, name[])

text

sql

VOLATILE

col_has_check(name, name[], text)

text

sql

VOLATILE

col_has_default(name, name)

text

sql

VOLATILE

col_has_default(name, name, name, text)

text

plpgsql

VOLATILE

col_has_default(name, name, text)

text

plpgsql

VOLATILE

col_hasnt_default(name, name)

text

sql

VOLATILE

col_hasnt_default(name, name, name, text)

text

plpgsql

VOLATILE

col_hasnt_default(name, name, text)

text

plpgsql

VOLATILE

col_is_fk(name, name)

text

sql

VOLATILE

col_is_fk(name, name, name, text)

text

sql

VOLATILE

col_is_fk(name, name, name[], text)

text

plpgsql

VOLATILE

col_is_fk(name, name, text)

text

sql

VOLATILE

col_is_fk(name, name[])

text

sql

VOLATILE

col_is_fk(name, name[], text)

text

plpgsql

VOLATILE

col_is_null(schema_name name, table_name name, co…​)

text

sql

VOLATILE

col_is_null(table_name name, column_name name, de…​)

text

sql

VOLATILE

col_is_pk(name, name)

text

sql

VOLATILE

col_is_pk(name, name, name, text)

text

sql

VOLATILE

col_is_pk(name, name, name[], text)

text

sql

VOLATILE

col_is_pk(name, name, text)

text

sql

VOLATILE

col_is_pk(name, name[])

text

sql

VOLATILE

col_is_pk(name, name[], text)

text

sql

VOLATILE

col_is_unique(name, name)

text

sql

VOLATILE

col_is_unique(name, name, name)

text

sql

VOLATILE

col_is_unique(name, name, name, text)

text

sql

VOLATILE

col_is_unique(name, name, name[])

text

sql

VOLATILE

col_is_unique(name, name, name[], text)

text

sql

VOLATILE

col_is_unique(name, name, text)

text

sql

VOLATILE

col_is_unique(name, name[])

text

sql

VOLATILE

col_is_unique(name, name[], text)

text

sql

VOLATILE

col_isnt_fk(name, name)

text

sql

VOLATILE

col_isnt_fk(name, name, name, text)

text

sql

VOLATILE

col_isnt_fk(name, name, name[], text)

text

sql

VOLATILE

col_isnt_fk(name, name, text)

text

sql

VOLATILE

col_isnt_fk(name, name[])

text

sql

VOLATILE

col_isnt_fk(name, name[], text)

text

sql

VOLATILE

col_isnt_pk(name, name)

text

sql

VOLATILE

col_isnt_pk(name, name, name, text)

text

sql

VOLATILE

col_isnt_pk(name, name, name[], text)

text

sql

VOLATILE

col_isnt_pk(name, name, text)

text

sql

VOLATILE

col_isnt_pk(name, name[])

text

sql

VOLATILE

col_isnt_pk(name, name[], text)

text

sql

VOLATILE

col_not_null(schema_name name, table_name name, co…​)

text

sql

VOLATILE

col_not_null(table_name name, column_name name, de…​)

text

sql

VOLATILE

col_type_is(name, name, name, name, text)

text

sql

VOLATILE

col_type_is(name, name, name, name, text, text)

text

plpgsql

VOLATILE

col_type_is(name, name, name, text)

text

sql

VOLATILE

col_type_is(name, name, name, text, text)

text

plpgsql

VOLATILE

col_type_is(name, name, text)

text

sql

VOLATILE

col_type_is(name, name, text, text)

text

sql

VOLATILE

collect_tap(VARIADIC text[])

text

sql

VOLATILE

collect_tap(character varying[])

text

sql

VOLATILE

column_privs_are(name, name, name, name, name[])

text

sql

VOLATILE

column_privs_are(name, name, name, name, name[], text)

text

plpgsql

VOLATILE

column_privs_are(name, name, name, name[])

text

sql

VOLATILE

column_privs_are(name, name, name, name[], text)

text

plpgsql

VOLATILE

columns_are(name, name, name[])

text

sql

VOLATILE

columns_are(name, name, name[], text)

text

sql

VOLATILE

columns_are(name, name[])

text

sql

VOLATILE

columns_are(name, name[], text)

text

sql

VOLATILE

composite_owner_is(name, name)

text

sql

VOLATILE

composite_owner_is(name, name, name)

text

sql

VOLATILE

composite_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

composite_owner_is(name, name, text)

text

plpgsql

VOLATILE

container_copy_bucket_item_target_copy_inh_fkey()

trigger

plpgsql

VOLATILE

could_be_serial_holding_code(text)

boolean

plperlu

VOLATILE

database_privs_are(name, name, name[])

text

sql

VOLATILE

database_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

db_owner_is(name, name)

text

sql

VOLATILE

db_owner_is(name, name, text)

text

plpgsql

VOLATILE

decode_base32(text)

text

plperlu

IMMUTABLE

diag(VARIADIC anyarray)

text

sql

VOLATILE

diag(VARIADIC text[])

text

sql

VOLATILE

diag(msg anyelement)

text

sql

VOLATILE

diag(msg text)

text

sql

VOLATILE

diag_test_name(text)

text

sql

VOLATILE

direct_opt_in_check(patron_id integer, staff_id integer, …​)

boolean

plpgsql

STABLE

display_field_force_nfc()

trigger

plpgsql

VOLATILE

display_oper(name, oid)

text

sql

VOLATILE

do_tap()

SETOF text

sql

VOLATILE

do_tap(name)

SETOF text

sql

VOLATILE

do_tap(name, text)

SETOF text

sql

VOLATILE

do_tap(text)

SETOF text

sql

VOLATILE

doesnt_imatch(anyelement, text)

text

sql

VOLATILE

doesnt_imatch(anyelement, text, text)

text

sql

VOLATILE

doesnt_match(anyelement, text)

text

sql

VOLATILE

doesnt_match(anyelement, text, text)

text

sql

VOLATILE

domain_type_is(name, text, name, text)

text

sql

VOLATILE

domain_type_is(name, text, name, text, text)

text

plpgsql

VOLATILE

domain_type_is(name, text, text)

text

sql

VOLATILE

domain_type_is(name, text, text, text)

text

plpgsql

VOLATILE

domain_type_is(text, text)

text

sql

VOLATILE

domain_type_is(text, text, text)

text

plpgsql

VOLATILE

domain_type_isnt(name, text, name, text)

text

sql

VOLATILE

domain_type_isnt(name, text, name, text, text)

text

plpgsql

VOLATILE

domain_type_isnt(name, text, text)

text

sql

VOLATILE

domain_type_isnt(name, text, text, text)

text

plpgsql

VOLATILE

domain_type_isnt(text, text)

text

sql

VOLATILE

domain_type_isnt(text, text, text)

text

plpgsql

VOLATILE

domains_are(name, name[])

text

sql

VOLATILE

domains_are(name, name[], text)

text

sql

VOLATILE

domains_are(name[])

text

sql

VOLATILE

domains_are(name[], text)

text

sql

VOLATILE

encode_base32(text)

text

plperlu

IMMUTABLE

enum_has_labels(name, name, name[])

text

sql

VOLATILE

enum_has_labels(name, name, name[], text)

text

sql

VOLATILE

enum_has_labels(name, name[])

text

sql

VOLATILE

enum_has_labels(name, name[], text)

text

sql

VOLATILE

enums_are(name, name[])

text

sql

VOLATILE

enums_are(name, name[], text)

text

sql

VOLATILE

enums_are(name[])

text

sql

VOLATILE

enums_are(name[], text)

text

sql

VOLATILE

escape_for_html(text)

text

sql

IMMUTABLE

extensions_are(name, name[])

text

sql

VOLATILE

extensions_are(name, name[], text)

text

sql

VOLATILE

extensions_are(name[])

text

sql

VOLATILE

extensions_are(name[], text)

text

sql

VOLATILE

extract_marc_field(text, bigint, text)

text

sql

IMMUTABLE

extract_marc_field(text, bigint, text, text)

text

plpgsql

IMMUTABLE

extract_marc_field_set(text, bigint, text, text)

SETOF text

plpgsql

IMMUTABLE

facet_force_nfc()

trigger

plpgsql

VOLATILE

fail()

text

sql

VOLATILE

fail(text)

text

sql

VOLATILE

fake_fkey_tgr()

trigger

plpgsql

VOLATILE

fdw_privs_are(name, name, name[])

text

sql

VOLATILE

fdw_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

find_next_open_time(circ_lib integer, initial timestamp w…​)

timestamp with time zone

plpgsql

VOLATILE

findfuncs(name, text)

text[]

sql

VOLATILE

findfuncs(name, text, text)

text[]

sql

VOLATILE

findfuncs(text)

text[]

sql

VOLATILE

findfuncs(text, text)

text[]

sql

VOLATILE

finish(exception_on_failure boolean DEFAULT …​)

SETOF text

sql

VOLATILE

fk_ok(name, name, name, name)

text

sql

VOLATILE

fk_ok(name, name, name, name, name, name, text)

text

sql

VOLATILE

fk_ok(name, name, name, name, name, text)

text

sql

VOLATILE

fk_ok(name, name, name, name, text)

text

sql

VOLATILE

fk_ok(name, name, name[], name, name, name[])

text

sql

VOLATILE

fk_ok(name, name, name[], name, name, name[…​)

text

plpgsql

VOLATILE

fk_ok(name, name[], name, name[])

text

sql

VOLATILE

fk_ok(name, name[], name, name[], text)

text

plpgsql

VOLATILE

force_unicode_normal_form(string text, form text)

text

plperlu

VOLATILE

foreign_table_owner_is(name, name)

text

sql

VOLATILE

foreign_table_owner_is(name, name, name)

text

sql

VOLATILE

foreign_table_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

foreign_table_owner_is(name, name, text)

text

plpgsql

VOLATILE

foreign_tables_are(name, name[])

text

sql

VOLATILE

foreign_tables_are(name, name[], text)

text

sql

VOLATILE

foreign_tables_are(name[])

text

sql

VOLATILE

foreign_tables_are(name[], text)

text

sql

VOLATILE

function_lang_is(name, name)

text

sql

VOLATILE

function_lang_is(name, name, name)

text

sql

VOLATILE

function_lang_is(name, name, name, text)

text

sql

VOLATILE

function_lang_is(name, name, name[], name)

text

sql

VOLATILE

function_lang_is(name, name, name[], name, text)

text

sql

VOLATILE

function_lang_is(name, name, text)

text

sql

VOLATILE

function_lang_is(name, name[], name)

text

sql

VOLATILE

function_lang_is(name, name[], name, text)

text

sql

VOLATILE

function_owner_is(name, name, name[], name)

text

sql

VOLATILE

function_owner_is(name, name, name[], name, text)

text

plpgsql

VOLATILE

function_owner_is(name, name[], name)

text

sql

VOLATILE

function_owner_is(name, name[], name, text)

text

plpgsql

VOLATILE

function_privs_are(name, name, name[], name, name[])

text

sql

VOLATILE

function_privs_are(name, name, name[], name, name[], text)

text

sql

VOLATILE

function_privs_are(name, name[], name, name[])

text

sql

VOLATILE

function_privs_are(name, name[], name, name[], text)

text

sql

VOLATILE

function_returns(name, name, name[], text)

text

sql

VOLATILE

function_returns(name, name, name[], text, text)

text

sql

VOLATILE

function_returns(name, name, text)

text

sql

VOLATILE

function_returns(name, name, text, text)

text

sql

VOLATILE

function_returns(name, name[], text)

text

sql

VOLATILE

function_returns(name, name[], text, text)

text

sql

VOLATILE

function_returns(name, text)

text

sql

VOLATILE

function_returns(name, text, text)

text

sql

VOLATILE

functions_are(name, name[])

text

sql

VOLATILE

functions_are(name, name[], text)

text

sql

VOLATILE

functions_are(name[])

text

sql

VOLATILE

functions_are(name[], text)

text

sql

VOLATILE

gen_random_bytes_b64(integer)

text

sql

IMMUTABLE

generic_map_normalizer(text, text)

text

plperlu

VOLATILE

get_barcodes(select_ou integer, type text, in_barc…​)

SETOF barcode_set

plpgsql

VOLATILE

get_locale_name(locale text, OUT name text, OUT descr…​)

record

plpgsql

STABLE

groups_are(name[])

text

sql

VOLATILE

groups_are(name[], text)

text

sql

VOLATILE

has_cast(name, name)

text

sql

VOLATILE

has_cast(name, name, name)

text

sql

VOLATILE

has_cast(name, name, name, name)

text

sql

VOLATILE

has_cast(name, name, name, name, text)

text

sql

VOLATILE

has_cast(name, name, name, text)

text

sql

VOLATILE

has_cast(name, name, text)

text

sql

VOLATILE

has_check(name)

text

sql

VOLATILE

has_check(name, name, text)

text

sql

VOLATILE

has_check(name, text)

text

sql

VOLATILE

has_column(name, name)

text

sql

VOLATILE

has_column(name, name, name, text)

text

sql

VOLATILE

has_column(name, name, text)

text

sql

VOLATILE

has_composite(name)

text

sql

VOLATILE

has_composite(name, name, text)

text

sql

VOLATILE

has_composite(name, text)

text

sql

VOLATILE

has_domain(name)

text

sql

VOLATILE

has_domain(name, name)

text

sql

VOLATILE

has_domain(name, name, text)

text

sql

VOLATILE

has_domain(name, text)

text

sql

VOLATILE

has_enum(name)

text

sql

VOLATILE

has_enum(name, name)

text

sql

VOLATILE

has_enum(name, name, text)

text

sql

VOLATILE

has_enum(name, text)

text

sql

VOLATILE

has_extension(name)

text

sql

VOLATILE

has_extension(name, name)

text

sql

VOLATILE

has_extension(name, name, text)

text

sql

VOLATILE

has_extension(name, text)

text

sql

VOLATILE

has_fk(name)

text

sql

VOLATILE

has_fk(name, name, text)

text

sql

VOLATILE

has_fk(name, text)

text

sql

VOLATILE

has_foreign_table(name)

text

sql

VOLATILE

has_foreign_table(name, name)

text

sql

VOLATILE

has_foreign_table(name, name, text)

text

sql

VOLATILE

has_foreign_table(name, text)

text

sql

VOLATILE

has_function(name)

text

sql

VOLATILE

has_function(name, name)

text

sql

VOLATILE

has_function(name, name, name[])

text

sql

VOLATILE

has_function(name, name, name[], text)

text

sql

VOLATILE

has_function(name, name, text)

text

sql

VOLATILE

has_function(name, name[])

text

sql

VOLATILE

has_function(name, name[], text)

text

sql

VOLATILE

has_function(name, text)

text

sql

VOLATILE

has_group(name)

text

sql

VOLATILE

has_group(name, text)

text

sql

VOLATILE

has_index(name, name)

text

sql

VOLATILE

has_index(name, name, name)

text

plpgsql

VOLATILE

has_index(name, name, name, name)

text

sql

VOLATILE

has_index(name, name, name, name, text)

text

sql

VOLATILE

has_index(name, name, name, name[])

text

sql

VOLATILE

has_index(name, name, name, name[], text)

text

plpgsql

VOLATILE

has_index(name, name, name, text)

text

sql

VOLATILE

has_index(name, name, name[])

text

sql

VOLATILE

has_index(name, name, name[], text)

text

plpgsql

VOLATILE

has_index(name, name, text)

text

sql

VOLATILE

has_inherited_tables(name)

text

sql

VOLATILE

has_inherited_tables(name, name)

text

sql

VOLATILE

has_inherited_tables(name, name, text)

text

sql

VOLATILE

has_inherited_tables(name, text)

text

sql

VOLATILE

has_language(name)

text

sql

VOLATILE

has_language(name, text)

text

sql

VOLATILE

has_leftop(name, name)

text

sql

VOLATILE

has_leftop(name, name, name)

text

sql

VOLATILE

has_leftop(name, name, name, name)

text

sql

VOLATILE

has_leftop(name, name, name, name, text)

text

sql

VOLATILE

has_leftop(name, name, name, text)

text

sql

VOLATILE

has_leftop(name, name, text)

text

sql

VOLATILE

has_materialized_view(name)

text

sql

VOLATILE

has_materialized_view(name, name, text)

text

sql

VOLATILE

has_materialized_view(name, text)

text

sql

VOLATILE

has_opclass(name)

text

sql

VOLATILE

has_opclass(name, name)

text

sql

VOLATILE

has_opclass(name, name, text)

text

sql

VOLATILE

has_opclass(name, text)

text

sql

VOLATILE

has_operator(name, name, name)

text

sql

VOLATILE

has_operator(name, name, name, name)

text

sql

VOLATILE

has_operator(name, name, name, name, name)

text

sql

VOLATILE

has_operator(name, name, name, name, name, text)

text

sql

VOLATILE

has_operator(name, name, name, name, text)

text

sql

VOLATILE

has_operator(name, name, name, text)

text

sql

VOLATILE

has_pk(name)

text

sql

VOLATILE

has_pk(name, name, text)

text

sql

VOLATILE

has_pk(name, text)

text

sql

VOLATILE

has_relation(name)

text

sql

VOLATILE

has_relation(name, name, text)

text

sql

VOLATILE

has_relation(name, text)

text

sql

VOLATILE

has_rightop(name, name)

text

sql

VOLATILE

has_rightop(name, name, name)

text

sql

VOLATILE

has_rightop(name, name, name, name)

text

sql

VOLATILE

has_rightop(name, name, name, name, text)

text

sql

VOLATILE

has_rightop(name, name, name, text)

text

sql

VOLATILE

has_rightop(name, name, text)

text

sql

VOLATILE

has_role(name)

text

sql

VOLATILE

has_role(name, text)

text

sql

VOLATILE

has_rule(name, name)

text

sql

VOLATILE

has_rule(name, name, name)

text

sql

VOLATILE

has_rule(name, name, name, text)

text

sql

VOLATILE

has_rule(name, name, text)

text

sql

VOLATILE

has_schema(name)

text

sql

VOLATILE

has_schema(name, text)

text

sql

VOLATILE

has_sequence(name)

text

sql

VOLATILE

has_sequence(name, name)

text

sql

VOLATILE

has_sequence(name, name, text)

text

sql

VOLATILE

has_sequence(name, text)

text

sql

VOLATILE

has_table(name)

text

sql

VOLATILE

has_table(name, name)

text

sql

VOLATILE

has_table(name, name, text)

text

sql

VOLATILE

has_table(name, text)

text

sql

VOLATILE

has_tablespace(name)

text

sql

VOLATILE

has_tablespace(name, text)

text

sql

VOLATILE

has_tablespace(name, text, text)

text

plpgsql

VOLATILE

has_trigger(name, name)

text

sql

VOLATILE

has_trigger(name, name, name)

text

sql

VOLATILE

has_trigger(name, name, name, text)

text

sql

VOLATILE

has_trigger(name, name, text)

text

sql

VOLATILE

has_type(name)

text

sql

VOLATILE

has_type(name, name)

text

sql

VOLATILE

has_type(name, name, text)

text

sql

VOLATILE

has_type(name, text)

text

sql

VOLATILE

has_unique(text)

text

sql

VOLATILE

has_unique(text, text)

text

sql

VOLATILE

has_unique(text, text, text)

text

sql

VOLATILE

has_user(name)

text

sql

VOLATILE

has_user(name, text)

text

sql

VOLATILE

has_view(name)

text

sql

VOLATILE

has_view(name, name, text)

text

sql

VOLATILE

has_view(name, text)

text

sql

VOLATILE

hasnt_cast(name, name)

text

sql

VOLATILE

hasnt_cast(name, name, name)

text

sql

VOLATILE

hasnt_cast(name, name, name, name)

text

sql

VOLATILE

hasnt_cast(name, name, name, name, text)

text

sql

VOLATILE

hasnt_cast(name, name, name, text)

text

sql

VOLATILE

hasnt_cast(name, name, text)

text

sql

VOLATILE

hasnt_column(name, name)

text

sql

VOLATILE

hasnt_column(name, name, name, text)

text

sql

VOLATILE

hasnt_column(name, name, text)

text

sql

VOLATILE

hasnt_composite(name)

text

sql

VOLATILE

hasnt_composite(name, name, text)

text

sql

VOLATILE

hasnt_composite(name, text)

text

sql

VOLATILE

hasnt_domain(name)

text

sql

VOLATILE

hasnt_domain(name, name)

text

sql

VOLATILE

hasnt_domain(name, name, text)

text

sql

VOLATILE

hasnt_domain(name, text)

text

sql

VOLATILE

hasnt_enum(name)

text

sql

VOLATILE

hasnt_enum(name, name)

text

sql

VOLATILE

hasnt_enum(name, name, text)

text

sql

VOLATILE

hasnt_enum(name, text)

text

sql

VOLATILE

hasnt_extension(name)

text

sql

VOLATILE

hasnt_extension(name, name)

text

sql

VOLATILE

hasnt_extension(name, name, text)

text

sql

VOLATILE

hasnt_extension(name, text)

text

sql

VOLATILE

hasnt_fk(name)

text

sql

VOLATILE

hasnt_fk(name, name, text)

text

sql

VOLATILE

hasnt_fk(name, text)

text

sql

VOLATILE

hasnt_foreign_table(name)

text

sql

VOLATILE

hasnt_foreign_table(name, name)

text

sql

VOLATILE

hasnt_foreign_table(name, name, text)

text

sql

VOLATILE

hasnt_foreign_table(name, text)

text

sql

VOLATILE

hasnt_function(name)

text

sql

VOLATILE

hasnt_function(name, name)

text

sql

VOLATILE

hasnt_function(name, name, name[])

text

sql

VOLATILE

hasnt_function(name, name, name[], text)

text

sql

VOLATILE

hasnt_function(name, name, text)

text

sql

VOLATILE

hasnt_function(name, name[])

text

sql

VOLATILE

hasnt_function(name, name[], text)

text

sql

VOLATILE

hasnt_function(name, text)

text

sql

VOLATILE

hasnt_group(name)

text

sql

VOLATILE

hasnt_group(name, text)

text

sql

VOLATILE

hasnt_index(name, name)

text

sql

VOLATILE

hasnt_index(name, name, name)

text

sql

VOLATILE

hasnt_index(name, name, name, text)

text

plpgsql

VOLATILE

hasnt_index(name, name, text)

text

sql

VOLATILE

hasnt_inherited_tables(name)

text

sql

VOLATILE

hasnt_inherited_tables(name, name)

text

sql

VOLATILE

hasnt_inherited_tables(name, name, text)

text

sql

VOLATILE

hasnt_inherited_tables(name, text)

text

sql

VOLATILE

hasnt_language(name)

text

sql

VOLATILE

hasnt_language(name, text)

text

sql

VOLATILE

hasnt_materialized_view(name)

text

sql

VOLATILE

hasnt_materialized_view(name, name, text)

text

sql

VOLATILE

hasnt_materialized_view(name, text)

text

sql

VOLATILE

hasnt_opclass(name)

text

sql

VOLATILE

hasnt_opclass(name, name)

text

sql

VOLATILE

hasnt_opclass(name, name, text)

text

sql

VOLATILE

hasnt_opclass(name, text)

text

sql

VOLATILE

hasnt_pk(name)

text

sql

VOLATILE

hasnt_pk(name, name, text)

text

sql

VOLATILE

hasnt_pk(name, text)

text

sql

VOLATILE

hasnt_relation(name)

text

sql

VOLATILE

hasnt_relation(name, name, text)

text

sql

VOLATILE

hasnt_relation(name, text)

text

sql

VOLATILE

hasnt_role(name)

text

sql

VOLATILE

hasnt_role(name, text)

text

sql

VOLATILE

hasnt_rule(name, name)

text

sql

VOLATILE

hasnt_rule(name, name, name)

text

sql

VOLATILE

hasnt_rule(name, name, name, text)

text

sql

VOLATILE

hasnt_rule(name, name, text)

text

sql

VOLATILE

hasnt_schema(name)

text

sql

VOLATILE

hasnt_schema(name, text)

text

sql

VOLATILE

hasnt_sequence(name)

text

sql

VOLATILE

hasnt_sequence(name, name, text)

text

sql

VOLATILE

hasnt_sequence(name, text)

text

sql

VOLATILE

hasnt_table(name)

text

sql

VOLATILE

hasnt_table(name, name)

text

sql

VOLATILE

hasnt_table(name, name, text)

text

sql

VOLATILE

hasnt_table(name, text)

text

sql

VOLATILE

hasnt_tablespace(name)

text

sql

VOLATILE

hasnt_tablespace(name, text)

text

sql

VOLATILE

hasnt_trigger(name, name)

text

sql

VOLATILE

hasnt_trigger(name, name, name)

text

sql

VOLATILE

hasnt_trigger(name, name, name, text)

text

sql

VOLATILE

hasnt_trigger(name, name, text)

text

sql

VOLATILE

hasnt_type(name)

text

sql

VOLATILE

hasnt_type(name, name)

text

sql

VOLATILE

hasnt_type(name, name, text)

text

sql

VOLATILE

hasnt_type(name, text)

text

sql

VOLATILE

hasnt_user(name)

text

sql

VOLATILE

hasnt_user(name, text)

text

sql

VOLATILE

hasnt_view(name)

text

sql

VOLATILE

hasnt_view(name, name, text)

text

sql

VOLATILE

hasnt_view(name, text)

text

sql

VOLATILE

hint_opt_in_check(hint_val text, pkey_val bigint, staff…​)

boolean

plpgsql

STABLE

ialike(anyelement, text)

text

sql

VOLATILE

ialike(anyelement, text, text)

text

sql

VOLATILE

imatches(anyelement, text)

text

sql

VOLATILE

imatches(anyelement, text, text)

text

sql

VOLATILE

in_todo()

boolean

plpgsql

VOLATILE

index_is_primary(name)

text

plpgsql

VOLATILE

index_is_primary(name, name)

text

plpgsql

VOLATILE

index_is_primary(name, name, name)

text

sql

VOLATILE

index_is_primary(name, name, name, text)

text

plpgsql

VOLATILE

index_is_type(name, name)

text

plpgsql

VOLATILE

index_is_type(name, name, name)

text

plpgsql

VOLATILE

index_is_type(name, name, name, name)

text

sql

VOLATILE

index_is_type(name, name, name, name, text)

text

plpgsql

VOLATILE

index_is_unique(name)

text

plpgsql

VOLATILE

index_is_unique(name, name)

text

plpgsql

VOLATILE

index_is_unique(name, name, name)

text

sql

VOLATILE

index_is_unique(name, name, name, text)

text

plpgsql

VOLATILE

index_owner_is(name, name, name)

text

sql

VOLATILE

index_owner_is(name, name, name, name)

text

sql

VOLATILE

index_owner_is(name, name, name, name, text)

text

plpgsql

VOLATILE

index_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

indexes_are(name, name, name[])

text

sql

VOLATILE

indexes_are(name, name, name[], text)

text

sql

VOLATILE

indexes_are(name, name[])

text

sql

VOLATILE

indexes_are(name, name[], text)

text

sql

VOLATILE

indexing_ingest_or_delete()

trigger

plpgsql

VOLATILE

is(anyelement, anyelement)

text

sql

VOLATILE

is(anyelement, anyelement, text)

text

plpgsql

VOLATILE

is_aggregate(name)

text

sql

VOLATILE

is_aggregate(name, name)

text

sql

VOLATILE

is_aggregate(name, name, name[])

text

sql

VOLATILE

is_aggregate(name, name, name[], text)

text

sql

VOLATILE

is_aggregate(name, name, text)

text

sql

VOLATILE

is_aggregate(name, name[])

text

sql

VOLATILE

is_aggregate(name, name[], text)

text

sql

VOLATILE

is_aggregate(name, text)

text

sql

VOLATILE

is_ancestor_of(name, name)

text

sql

VOLATILE

is_ancestor_of(name, name, integer)

text

sql

VOLATILE

is_ancestor_of(name, name, integer, text)

text

sql

VOLATILE

is_ancestor_of(name, name, name, name)

text

sql

VOLATILE

is_ancestor_of(name, name, name, name, integer)

text

sql

VOLATILE

is_ancestor_of(name, name, name, name, integer, text)

text

sql

VOLATILE

is_ancestor_of(name, name, name, name, text)

text

sql

VOLATILE

is_ancestor_of(name, name, text)

text

sql

VOLATILE

is_clustered(name)

text

plpgsql

VOLATILE

is_clustered(name, name)

text

plpgsql

VOLATILE

is_clustered(name, name, name)

text

sql

VOLATILE

is_clustered(name, name, name, text)

text

plpgsql

VOLATILE

is_definer(name)

text

sql

VOLATILE

is_definer(name, name)

text

sql

VOLATILE

is_definer(name, name, name[])

text

sql

VOLATILE

is_definer(name, name, name[], text)

text

sql

VOLATILE

is_definer(name, name, text)

text

sql

VOLATILE

is_definer(name, name[])

text

sql

VOLATILE

is_definer(name, name[], text)

text

sql

VOLATILE

is_definer(name, text)

text

sql

VOLATILE

is_descendent_of(name, name)

text

sql

VOLATILE

is_descendent_of(name, name, integer)

text

sql

VOLATILE

is_descendent_of(name, name, integer, text)

text

sql

VOLATILE

is_descendent_of(name, name, name, name)

text

sql

VOLATILE

is_descendent_of(name, name, name, name, integer)

text

sql

VOLATILE

is_descendent_of(name, name, name, name, integer, text)

text

sql

VOLATILE

is_descendent_of(name, name, name, name, text)

text

sql

VOLATILE

is_descendent_of(name, name, text)

text

sql

VOLATILE

is_empty(text)

text

sql

VOLATILE

is_empty(text, text)

text

plpgsql

VOLATILE

is_indexed(name, name)

text

sql

VOLATILE

is_indexed(name, name, name)

text

sql

VOLATILE

is_indexed(name, name, name, text)

text

sql

VOLATILE

is_indexed(name, name, name[])

text

sql

VOLATILE

is_indexed(name, name, name[], text)

text

sql

VOLATILE

is_indexed(name, name[])

text

sql

VOLATILE

is_indexed(name, name[], text)

text

sql

VOLATILE

is_json(text)

boolean

plperlu

VOLATILE

is_member_of(name, name)

text

sql

VOLATILE

is_member_of(name, name, text)

text

sql

VOLATILE

is_member_of(name, name[])

text

sql

VOLATILE

is_member_of(name, name[], text)

text

plpgsql

VOLATILE

is_partition_of(name, name)

text

sql

VOLATILE

is_partition_of(name, name, name, name)

text

sql

VOLATILE

is_partition_of(name, name, name, name, text)

text

sql

VOLATILE

is_partition_of(name, name, text)

text

sql

VOLATILE

is_partitioned(name)

text

sql

VOLATILE

is_partitioned(name, name)

text

sql

VOLATILE

is_partitioned(name, name, text)

text

sql

VOLATILE

is_partitioned(name, text)

text

sql

VOLATILE

is_strict(name)

text

sql

VOLATILE

is_strict(name, name)

text

sql

VOLATILE

is_strict(name, name, name[])

text

sql

VOLATILE

is_strict(name, name, name[], text)

text

sql

VOLATILE

is_strict(name, name, text)

text

sql

VOLATILE

is_strict(name, name[])

text

sql

VOLATILE

is_strict(name, name[], text)

text

sql

VOLATILE

is_strict(name, text)

text

sql

VOLATILE

is_superuser(name)

text

sql

VOLATILE

is_superuser(name, text)

text

plpgsql

VOLATILE

isa_ok(anyelement, regtype)

text

sql

VOLATILE

isa_ok(anyelement, regtype, text)

text

plpgsql

VOLATILE

isnt(anyelement, anyelement)

text

sql

VOLATILE

isnt(anyelement, anyelement, text)

text

plpgsql

VOLATILE

isnt_aggregate(name)

text

sql

VOLATILE

isnt_aggregate(name, name)

text

sql

VOLATILE

isnt_aggregate(name, name, name[])

text

sql

VOLATILE

isnt_aggregate(name, name, name[], text)

text

sql

VOLATILE

isnt_aggregate(name, name, text)

text

sql

VOLATILE

isnt_aggregate(name, name[])

text

sql

VOLATILE

isnt_aggregate(name, name[], text)

text

sql

VOLATILE

isnt_aggregate(name, text)

text

sql

VOLATILE

isnt_ancestor_of(name, name)

text

sql

VOLATILE

isnt_ancestor_of(name, name, integer)

text

sql

VOLATILE

isnt_ancestor_of(name, name, integer, text)

text

sql

VOLATILE

isnt_ancestor_of(name, name, name, name)

text

sql

VOLATILE

isnt_ancestor_of(name, name, name, name, integer)

text

sql

VOLATILE

isnt_ancestor_of(name, name, name, name, integer, text)

text

sql

VOLATILE

isnt_ancestor_of(name, name, name, name, text)

text

sql

VOLATILE

isnt_ancestor_of(name, name, text)

text

sql

VOLATILE

isnt_definer(name)

text

sql

VOLATILE

isnt_definer(name, name)

text

sql

VOLATILE

isnt_definer(name, name, name[])

text

sql

VOLATILE

isnt_definer(name, name, name[], text)

text

sql

VOLATILE

isnt_definer(name, name, text)

text

sql

VOLATILE

isnt_definer(name, name[])

text

sql

VOLATILE

isnt_definer(name, name[], text)

text

sql

VOLATILE

isnt_definer(name, text)

text

sql

VOLATILE

isnt_descendent_of(name, name)

text

sql

VOLATILE

isnt_descendent_of(name, name, integer)

text

sql

VOLATILE

isnt_descendent_of(name, name, integer, text)

text

sql

VOLATILE

isnt_descendent_of(name, name, name, name)

text

sql

VOLATILE

isnt_descendent_of(name, name, name, name, integer)

text

sql

VOLATILE

isnt_descendent_of(name, name, name, name, integer, text)

text

sql

VOLATILE

isnt_descendent_of(name, name, name, name, text)

text

sql

VOLATILE

isnt_descendent_of(name, name, text)

text

sql

VOLATILE

isnt_empty(text)

text

sql

VOLATILE

isnt_empty(text, text)

text

plpgsql

VOLATILE

isnt_partitioned(name)

text

sql

VOLATILE

isnt_partitioned(name, name)

text

sql

VOLATILE

isnt_partitioned(name, name, text)

text

sql

VOLATILE

isnt_partitioned(name, text)

text

sql

VOLATILE

isnt_strict(name)

text

sql

VOLATILE

isnt_strict(name, name)

text

sql

VOLATILE

isnt_strict(name, name, name[])

text

sql

VOLATILE

isnt_strict(name, name, name[], text)

text

sql

VOLATILE

isnt_strict(name, name, text)

text

sql

VOLATILE

isnt_strict(name, name[])

text

sql

VOLATILE

isnt_strict(name, name[], text)

text

sql

VOLATILE

isnt_strict(name, text)

text

sql

VOLATILE

isnt_superuser(name)

text

sql

VOLATILE

isnt_superuser(name, text)

text

plpgsql

VOLATILE

json_delta(old_obj json, new_obj json, only_keys…​)

jsonb

plperlu

VOLATILE

language_is_trusted(name)

text

sql

VOLATILE

language_is_trusted(name, text)

text

plpgsql

VOLATILE

language_owner_is(name, name)

text

sql

VOLATILE

language_owner_is(name, name, text)

text

plpgsql

VOLATILE

language_privs_are(name, name, name[])

text

sql

VOLATILE

language_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

languages_are(name[])

text

sql

VOLATILE

languages_are(name[], text)

text

sql

VOLATILE

levenshtein_damerau_edistance(a text, b text, integer)

numeric

plperlu

IMMUTABLE

limit_oustl()

trigger

plpgsql

VOLATILE

lives_ok(text)

text

sql

VOLATILE

lives_ok(text, text)

text

plpgsql

VOLATILE

located_uris(bibid bigint, ouid integer, pref_lib …​)

TABLE(id bigint, name text, label_sortkey text, rank integer)

sql

STABLE

located_uris(bibid bigint[], ouid integer, pref_li…​)

TABLE(id bigint, name text, label_sortkey text, rank integer)

sql

STABLE

located_uris_as_uris(bibid bigint, ouid integer, pref_lib …​)

SETOF asset.uri

sql

STABLE

lowercase(text)

text

plperlu

IMMUTABLE

lpad_number_substrings(text, text, integer)

text

plperlu

VOLATILE

maintain_901()

trigger

plperlu

VOLATILE

maintain_control_numbers()

trigger

plperlu

VOLATILE

marc_to(marc text, xfrm text)

text

sql

VOLATILE

matches(anyelement, text)

text

sql

VOLATILE

matches(anyelement, text, text)

text

sql

VOLATILE

materialized_view_owner_is(name, name)

text

sql

VOLATILE

materialized_view_owner_is(name, name, name)

text

sql

VOLATILE

materialized_view_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

materialized_view_owner_is(name, name, text)

text

plpgsql

VOLATILE

materialized_views_are(name, name[])

text

sql

VOLATILE

materialized_views_are(name, name[], text)

text

sql

VOLATILE

materialized_views_are(name[])

text

sql

VOLATILE

materialized_views_are(name[], text)

text

sql

VOLATILE

no_plan()

SETOF boolean

plpgsql

VOLATILE

num_failed()

integer

sql

VOLATILE

oils_i18n_code_tracking()

trigger

plpgsql

VOLATILE

oils_i18n_gettext(integer, text, text, text)

text

sql

VOLATILE

oils_i18n_gettext(text, text, text, text)

text

sql

VOLATILE

oils_i18n_id_tracking()

trigger

plpgsql

VOLATILE

oils_i18n_update_apply(old_ident text, new_ident text, hint …​)

void

plpgsql

VOLATILE

oils_i18n_xlate(keytable text, keyclass text, keycol …​)

text

plpgsql

STABLE

oils_json_to_text(text)

text

plperlu

VOLATILE

oils_text_as_bytea(text)

bytea

sql

IMMUTABLE

oils_xpath(text, text)

text[]

sql

IMMUTABLE

oils_xpath(text, text, text[])

text[]

sql

IMMUTABLE

oils_xpath_string(text, text)

text

sql

IMMUTABLE

oils_xpath_string(text, text, anyarray)

text

sql

IMMUTABLE

oils_xpath_string(text, text, text)

text

sql

IMMUTABLE

oils_xpath_string(text, text, text, anyarray)

text

sql

IMMUTABLE

oils_xpath_table(key text, document_field text, relati…​)

SETOF record

plpgsql

IMMUTABLE

oils_xpath_tag_to_table(marc text, tag text, xpaths text[])

SETOF record

plpgsql

VOLATILE

oils_xslt_process(text, text)

text

plperlu

IMMUTABLE

ok(boolean)

text

sql

VOLATILE

ok(boolean, text)

text

plpgsql

VOLATILE

opclass_owner_is(name, name)

text

sql

VOLATILE

opclass_owner_is(name, name, name)

text

sql

VOLATILE

opclass_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

opclass_owner_is(name, name, text)

text

plpgsql

VOLATILE

opclasses_are(name, name[])

text

sql

VOLATILE

opclasses_are(name, name[], text)

text

sql

VOLATILE

opclasses_are(name[])

text

sql

VOLATILE

opclasses_are(name[], text)

text

sql

VOLATILE

operators_are(name, text[])

text

sql

VOLATILE

operators_are(name, text[], text)

text

sql

VOLATILE

operators_are(text[])

text

sql

VOLATILE

operators_are(text[], text)

text

sql

VOLATILE

org_top()

actor.org_unit

sql

STABLE

os_name()

text

sql

IMMUTABLE

ous_change_log()

trigger

plpgsql

VOLATILE

ous_delete_log()

trigger

plpgsql

VOLATILE

partitions_are(name, name, name[])

text

sql

VOLATILE

partitions_are(name, name, name[], text)

text

sql

VOLATILE

partitions_are(name, name[])

text

sql

VOLATILE

partitions_are(name, name[], text)

text

sql

VOLATILE

pass()

text

sql

VOLATILE

pass(text)

text

sql

VOLATILE

performs_ok(text, numeric)

text

sql

VOLATILE

performs_ok(text, numeric, text)

text

plpgsql

VOLATILE

performs_within(text, numeric, numeric)

text

sql

VOLATILE

performs_within(text, numeric, numeric, integer)

text

sql

VOLATILE

performs_within(text, numeric, numeric, integer, text)

text

plpgsql

VOLATILE

performs_within(text, numeric, numeric, text)

text

sql

VOLATILE

pg_statistics(tab text, col text)

TABLE(element text, frequency integer)

plpgsql

VOLATILE

pg_version()

text

sql

IMMUTABLE

pg_version_num()

integer

sql

IMMUTABLE

pgtap_version()

numeric

sql

IMMUTABLE

plan(integer)

text

plpgsql

VOLATILE

policies_are(name, name, name[])

text

sql

VOLATILE

policies_are(name, name, name[], text)

text

sql

VOLATILE

policies_are(name, name[])

text

sql

VOLATILE

policies_are(name, name[], text)

text

sql

VOLATILE

policy_cmd_is(name, name, name, text)

text

sql

VOLATILE

policy_cmd_is(name, name, name, text, text)

text

plpgsql

VOLATILE

policy_cmd_is(name, name, text)

text

sql

VOLATILE

policy_cmd_is(name, name, text, text)

text

plpgsql

VOLATILE

policy_roles_are(name, name, name, name[])

text

sql

VOLATILE

policy_roles_are(name, name, name, name[], text)

text

sql

VOLATILE

policy_roles_are(name, name, name[])

text

sql

VOLATILE

policy_roles_are(name, name, name[], text)

text

sql

VOLATILE

protect_reserved_rows_from_delete()

trigger

plpgsql

VOLATILE

query_int_wrapper(integer[], text)

boolean

plpgsql

STABLE

qwerty_keyboard_distance(a text, b text)

numeric

plperlu

IMMUTABLE

qwerty_keyboard_distance_match(a text, b text)

numeric

plperlu

IMMUTABLE

raise_protected_row_exception()

trigger

plpgsql

VOLATILE

rank_cp(copy asset.copy)

integer

plpgsql

STABLE

rank_cp(copy_id bigint)

integer

plpgsql

STABLE

rank_ou(lib integer, search_lib integer, pref…​)

integer

sql

STABLE

rank_ou(lib integer, search_lib integer, pref…​)

integer

sql

STABLE

ranked_volumes(bibid bigint, ouid integer, depth int…​)

TABLE(id bigint, name text, label_sortkey text, rank bigint)

sql

STABLE

ranked_volumes(bibid bigint[], ouid integer, depth i…​)

TABLE(id bigint, name text, label_sortkey text, rank bigint)

sql

STABLE

redact_value(input_data anyelement, skip_redaction…​)

anyelement

plpgsql

STABLE

regexp_split_to_array(text, text)

text[]

plperlu

IMMUTABLE

rel_bump(terms text[], value text, bumps text[…​)

numeric

plperlu

IMMUTABLE

relation_owner_is(name, name)

text

sql

VOLATILE

relation_owner_is(name, name, name)

text

sql

VOLATILE

relation_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

relation_owner_is(name, name, text)

text

plpgsql

VOLATILE

results_eq(refcursor, anyarray)

text

sql

VOLATILE

results_eq(refcursor, anyarray, text)

text

plpgsql

VOLATILE

results_eq(refcursor, refcursor)

text

sql

VOLATILE

results_eq(refcursor, refcursor, text)

text

plpgsql

VOLATILE

results_eq(refcursor, text)

text

sql

VOLATILE

results_eq(refcursor, text, text)

text

plpgsql

VOLATILE

results_eq(text, anyarray)

text

sql

VOLATILE

results_eq(text, anyarray, text)

text

plpgsql

VOLATILE

results_eq(text, refcursor)

text

sql

VOLATILE

results_eq(text, refcursor, text)

text

plpgsql

VOLATILE

results_eq(text, text)

text

sql

VOLATILE

results_eq(text, text, text)

text

plpgsql

VOLATILE

results_ne(refcursor, anyarray)

text

sql

VOLATILE

results_ne(refcursor, anyarray, text)

text

plpgsql

VOLATILE

results_ne(refcursor, refcursor)

text

sql

VOLATILE

results_ne(refcursor, refcursor, text)

text

plpgsql

VOLATILE

results_ne(refcursor, text)

text

sql

VOLATILE

results_ne(refcursor, text, text)

text

plpgsql

VOLATILE

results_ne(text, anyarray)

text

sql

VOLATILE

results_ne(text, anyarray, text)

text

plpgsql

VOLATILE

results_ne(text, refcursor)

text

sql

VOLATILE

results_ne(text, refcursor, text)

text

plpgsql

VOLATILE

results_ne(text, text)

text

sql

VOLATILE

results_ne(text, text, text)

text

plpgsql

VOLATILE

roles_are(name[])

text

sql

VOLATILE

roles_are(name[], text)

text

sql

VOLATILE

row_eq(text, anyelement)

text

sql

VOLATILE

row_eq(text, anyelement, text)

text

plpgsql

VOLATILE

rule_is_instead(name, name)

text

sql

VOLATILE

rule_is_instead(name, name, name)

text

sql

VOLATILE

rule_is_instead(name, name, name, text)

text

plpgsql

VOLATILE

rule_is_instead(name, name, text)

text

plpgsql

VOLATILE

rule_is_on(name, name, name, text)

text

sql

VOLATILE

rule_is_on(name, name, name, text, text)

text

plpgsql

VOLATILE

rule_is_on(name, name, text)

text

sql

VOLATILE

rule_is_on(name, name, text, text)

text

plpgsql

VOLATILE

rules_are(name, name, name[])

text

sql

VOLATILE

rules_are(name, name, name[], text)

text

sql

VOLATILE

rules_are(name, name[])

text

sql

VOLATILE

rules_are(name, name[], text)

text

sql

VOLATILE

runtests()

SETOF text

sql

VOLATILE

runtests(name)

SETOF text

sql

VOLATILE

runtests(name, text)

SETOF text

sql

VOLATILE

runtests(text)

SETOF text

sql

VOLATILE

schema_owner_is(name, name)

text

sql

VOLATILE

schema_owner_is(name, name, text)

text

plpgsql

VOLATILE

schema_privs_are(name, name, name[])

text

sql

VOLATILE

schema_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

schemas_are(name[])

text

sql

VOLATILE

schemas_are(name[], text)

text

sql

VOLATILE

sequence_owner_is(name, name)

text

sql

VOLATILE

sequence_owner_is(name, name, name)

text

sql

VOLATILE

sequence_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

sequence_owner_is(name, name, text)

text

plpgsql

VOLATILE

sequence_privs_are(name, name, name, name[])

text

sql

VOLATILE

sequence_privs_are(name, name, name, name[], text)

text

plpgsql

VOLATILE

sequence_privs_are(name, name, name[])

text

sql

VOLATILE

sequence_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

sequences_are(name, name[])

text

sql

VOLATILE

sequences_are(name, name[], text)

text

sql

VOLATILE

sequences_are(name[])

text

sql

VOLATILE

sequences_are(name[], text)

text

sql

VOLATILE

server_privs_are(name, name, name[])

text

sql

VOLATILE

server_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

set_eq(text, anyarray)

text

sql

VOLATILE

set_eq(text, anyarray, text)

text

sql

VOLATILE

set_eq(text, text)

text

sql

VOLATILE

set_eq(text, text, text)

text

sql

VOLATILE

set_has(text, text)

text

sql

VOLATILE

set_has(text, text, text)

text

sql

VOLATILE

set_hasnt(text, text)

text

sql

VOLATILE

set_hasnt(text, text, text)

text

sql

VOLATILE

set_ne(text, anyarray)

text

sql

VOLATILE

set_ne(text, anyarray, text)

text

sql

VOLATILE

set_ne(text, text)

text

sql

VOLATILE

set_ne(text, text, text)

text

sql

VOLATILE

setup_delete_protect_rule(t_schema text, t_table text, t_additi…​)

void

plpgsql

VOLATILE

skip(integer)

text

sql

VOLATILE

skip(integer, text)

text

sql

VOLATILE

skip(text)

text

sql

VOLATILE

skip(why text, how_many integer)

text

plpgsql

VOLATILE

table_owner_is(name, name)

text

sql

VOLATILE

table_owner_is(name, name, name)

text

sql

VOLATILE

table_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

table_owner_is(name, name, text)

text

plpgsql

VOLATILE

table_privs_are(name, name, name, name[])

text

sql

VOLATILE

table_privs_are(name, name, name, name[], text)

text

plpgsql

VOLATILE

table_privs_are(name, name, name[])

text

sql

VOLATILE

table_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

tableoid2name(oid)

text

plpgsql

VOLATILE

tables_are(name, name[])

text

sql

VOLATILE

tables_are(name, name[], text)

text

sql

VOLATILE

tables_are(name[])

text

sql

VOLATILE

tables_are(name[], text)

text

sql

VOLATILE

tablespace_owner_is(name, name)

text

sql

VOLATILE

tablespace_owner_is(name, name, text)

text

plpgsql

VOLATILE

tablespace_privs_are(name, name, name[])

text

sql

VOLATILE

tablespace_privs_are(name, name, name[], text)

text

plpgsql

VOLATILE

tablespaces_are(name[])

text

sql

VOLATILE

tablespaces_are(name[], text)

text

sql

VOLATILE

text_array_merge_unique(text[], text[])

text[]

sql

VOLATILE

throws_ilike(text, text)

text

sql

VOLATILE

throws_ilike(text, text, text)

text

plpgsql

VOLATILE

throws_imatching(text, text)

text

sql

VOLATILE

throws_imatching(text, text, text)

text

plpgsql

VOLATILE

throws_like(text, text)

text

sql

VOLATILE

throws_like(text, text, text)

text

plpgsql

VOLATILE

throws_matching(text, text)

text

sql

VOLATILE

throws_matching(text, text, text)

text

plpgsql

VOLATILE

throws_ok(text)

text

sql

VOLATILE

throws_ok(text, character, text, text)

text

plpgsql

VOLATILE

throws_ok(text, integer)

text

sql

VOLATILE

throws_ok(text, integer, text)

text

sql

VOLATILE

throws_ok(text, integer, text, text)

text

sql

VOLATILE

throws_ok(text, text)

text

plpgsql

VOLATILE

throws_ok(text, text, text)

text

plpgsql

VOLATILE

todo(how_many integer)

SETOF boolean

plpgsql

VOLATILE

todo(how_many integer, why text)

SETOF boolean

plpgsql

VOLATILE

todo(why text)

SETOF boolean

plpgsql

VOLATILE

todo(why text, how_many integer)

SETOF boolean

plpgsql

VOLATILE

todo_end()

SETOF boolean

plpgsql

VOLATILE

todo_start()

SETOF boolean

plpgsql

VOLATILE

todo_start(text)

SETOF boolean

plpgsql

VOLATILE

trigger_is(name, name, name)

text

sql

VOLATILE

trigger_is(name, name, name, name, name)

text

sql

VOLATILE

trigger_is(name, name, name, name, name, text)

text

plpgsql

VOLATILE

trigger_is(name, name, name, text)

text

plpgsql

VOLATILE

triggers_are(name, name, name[])

text

sql

VOLATILE

triggers_are(name, name, name[], text)

text

sql

VOLATILE

triggers_are(name, name[])

text

sql

VOLATILE

triggers_are(name, name[], text)

text

sql

VOLATILE

type_owner_is(name, name)

text

sql

VOLATILE

type_owner_is(name, name, name)

text

sql

VOLATILE

type_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

type_owner_is(name, name, text)

text

plpgsql

VOLATILE

types_are(name, name[])

text

sql

VOLATILE

types_are(name, name[], text)

text

sql

VOLATILE

types_are(name[])

text

sql

VOLATILE

types_are(name[], text)

text

sql

VOLATILE

unaccent_and_squash(arg text)

text

plpgsql

IMMUTABLE

unalike(anyelement, text)

text

sql

VOLATILE

unalike(anyelement, text, text)

text

sql

VOLATILE

unialike(anyelement, text)

text

sql

VOLATILE

unialike(anyelement, text, text)

text

sql

VOLATILE

upgrade_deps_block_check(my_db_patch text, my_applied_to text)

boolean

plpgsql

VOLATILE

upgrade_list_applied_deprecated(my_db_patch text)

SETOF text

sql

VOLATILE

upgrade_list_applied_deprecates(my_db_patch text)

SETOF patch

sql

VOLATILE

upgrade_list_applied_superseded(my_db_patch text)

SETOF text

sql

VOLATILE

upgrade_list_applied_supersedes(my_db_patch text)

SETOF patch

sql

VOLATILE

upgrade_verify_no_dep_conflicts(my_db_patch text)

boolean

sql

VOLATILE

uppercase(text)

text

plperlu

IMMUTABLE

uri_escape(text)

text

plperlu

IMMUTABLE

uri_unescape(text)

text

plperlu

IMMUTABLE

users_are(name[])

text

sql

VOLATILE

users_are(name[], text)

text

sql

VOLATILE

vandelay_import_item_imported_as_inh_fkey()

trigger

plpgsql

VOLATILE

view_owner_is(name, name)

text

sql

VOLATILE

view_owner_is(name, name, name)

text

sql

VOLATILE

view_owner_is(name, name, name, text)

text

plpgsql

VOLATILE

view_owner_is(name, name, text)

text

plpgsql

VOLATILE

views_are(name, name[])

text

sql

VOLATILE

views_are(name, name[], text)

text

sql

VOLATILE

views_are(name[])

text

sql

VOLATILE

views_are(name[], text)

text

sql

VOLATILE

volatility_is(name, name, name[], text)

text

sql

VOLATILE

volatility_is(name, name, name[], text, text)

text

sql

VOLATILE

volatility_is(name, name, text)

text

sql

VOLATILE

volatility_is(name, name, text, text)

text

sql

VOLATILE

volatility_is(name, name[], text)

text

sql

VOLATILE

volatility_is(name, name[], text, text)

text

sql

VOLATILE

volatility_is(name, text)

text

sql

VOLATILE

volatility_is(name, text, text)

text

sql

VOLATILE

xml_escape(str text)

text

sql

IMMUTABLE

xml_famous5_to_text(text)

text

sql

IMMUTABLE

xml_pretty_print(input xml)

xml

sql

VOLATILE

z3950_attr_name_is_valid()

trigger

plpgsql

STABLE

_add

Signature: evergreen._add(text, integer)

Returns: integer

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _add($1, $2, '')

_add

Signature: evergreen._add(text, integer, text)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE 'INSERT INTO __tcache__ (label, value, note) values (' ||
    quote_literal($1) || ', ' || $2 || ', ' || quote_literal(COALESCE($3, '')) || ')';
    RETURN $2;
END;

_agg

Signature: evergreen._agg(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT kind = 'a' FROM tap_funky WHERE name = $1 AND is_visible;

_agg

Signature: evergreen._agg(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT kind = 'a' FROM tap_funky WHERE schema = $1 AND name = $2

_agg

Signature: evergreen._agg(name, name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT kind = 'a'
      FROM tap_funky
     WHERE schema = $1
       AND name   = $2
       AND args   = array_to_string($3, ',')

_agg

Signature: evergreen._agg(name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT kind = 'a'
      FROM tap_funky
     WHERE name = $1
       AND args = array_to_string($2, ',')
       AND is_visible;

_alike

Signature: evergreen._alike(boolean, anyelement, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    result ALIAS FOR $1;
    got    ALIAS FOR $2;
    rx     ALIAS FOR $3;
    descr  ALIAS FOR $4;
    output TEXT;
BEGIN
    output := ok( result, descr );
    RETURN output || CASE result WHEN TRUE THEN '' ELSE E'\n' || diag(
           '                  ' || COALESCE( quote_literal(got), 'NULL' ) ||
       E'\n   doesn''t match: ' || COALESCE( quote_literal(rx), 'NULL' )
    ) END;
END;

_ancestor_of

Signature: evergreen._ancestor_of(name, name, integer)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    WITH RECURSIVE inheritance_chain AS (
        -- select the ancestor tuple
        SELECT i.inhrelid AS descendent_id, 1 AS inheritance_level
          FROM pg_catalog.pg_inherits i
        WHERE i.inhparent = (
            SELECT c1.oid
              FROM pg_catalog.pg_class c1
              JOIN pg_catalog.pg_namespace n1
                ON c1.relnamespace = n1.oid
             WHERE c1.relname = $1
               AND pg_catalog.pg_table_is_visible( c1.oid )
        )
        UNION
        -- select the descendents
        SELECT i.inhrelid AS descendent_id,
               p.inheritance_level + 1 AS inheritance_level
          FROM pg_catalog.pg_inherits i
          JOIN inheritance_chain p
            ON p.descendent_id = i.inhparent
         WHERE i.inhrelid = (
            SELECT c1.oid
              FROM pg_catalog.pg_class c1
              JOIN pg_catalog.pg_namespace n1
                ON c1.relnamespace = n1.oid
             WHERE c1.relname = $2
               AND pg_catalog.pg_table_is_visible( c1.oid )
        )
    )
    SELECT EXISTS(
        SELECT true
          FROM inheritance_chain
         WHERE inheritance_level = COALESCE($3, inheritance_level)
           AND descendent_id = (
                SELECT c1.oid
                  FROM pg_catalog.pg_class c1
                  JOIN pg_catalog.pg_namespace n1
                    ON c1.relnamespace = n1.oid
                 WHERE c1.relname = $2
                   AND pg_catalog.pg_table_is_visible( c1.oid )
        )
    );

_ancestor_of

Signature: evergreen._ancestor_of(name, name, name, name, integer)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    WITH RECURSIVE inheritance_chain AS (
        -- select the ancestor tuple
        SELECT i.inhrelid AS descendent_id, 1 AS inheritance_level
          FROM pg_catalog.pg_inherits i
        WHERE i.inhparent = (
            SELECT c1.oid
              FROM pg_catalog.pg_class c1
              JOIN pg_catalog.pg_namespace n1
                ON c1.relnamespace = n1.oid
             WHERE c1.relname = $2
               AND n1.nspname = $1
        )
        UNION
        -- select the descendents
        SELECT i.inhrelid AS descendent_id,
               p.inheritance_level + 1 AS inheritance_level
          FROM pg_catalog.pg_inherits i
          JOIN inheritance_chain p
            ON p.descendent_id = i.inhparent
         WHERE i.inhrelid = (
            SELECT c1.oid
              FROM pg_catalog.pg_class c1
              JOIN pg_catalog.pg_namespace n1
                ON c1.relnamespace = n1.oid
             WHERE c1.relname = $4
               AND n1.nspname = $3
        )
    )
    SELECT EXISTS(
        SELECT true
          FROM inheritance_chain
         WHERE inheritance_level = COALESCE($5, inheritance_level)
           AND descendent_id = (
                SELECT c1.oid
                  FROM pg_catalog.pg_class c1
                  JOIN pg_catalog.pg_namespace n1
                    ON c1.relnamespace = n1.oid
                 WHERE c1.relname = $4
                   AND n1.nspname = $3
        )
    );

_are

Signature: evergreen._are(text, name[], name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    what    ALIAS FOR $1;
    extras  ALIAS FOR $2;
    missing ALIAS FOR $3;
    descr   ALIAS FOR $4;
    msg     TEXT    := '';
    res     BOOLEAN := TRUE;
BEGIN
    IF extras[1] IS NOT NULL THEN
        res = FALSE;
        msg := E'\n' || diag(
            '    Extra ' || what || E':\n        '
            ||  _ident_array_to_sorted_string( extras, E'\n        ' )
        );
    END IF;
    IF missing[1] IS NOT NULL THEN
        res = FALSE;
        msg := msg || E'\n' || diag(
            '    Missing ' || what || E':\n        '
            ||  _ident_array_to_sorted_string( missing, E'\n        ' )
        );
    END IF;

    RETURN ok(res, descr) || msg;
END;

_areni

Signature: evergreen._areni(text, text[], text[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    what    ALIAS FOR $1;
    extras  ALIAS FOR $2;
    missing ALIAS FOR $3;
    descr   ALIAS FOR $4;
    msg     TEXT    := '';
    res     BOOLEAN := TRUE;
BEGIN
    IF extras[1] IS NOT NULL THEN
        res = FALSE;
        msg := E'\n' || diag(
            '    Extra ' || what || E':\n        '
            ||  _array_to_sorted_string( extras, E'\n        ' )
        );
    END IF;
    IF missing[1] IS NOT NULL THEN
        res = FALSE;
        msg := msg || E'\n' || diag(
            '    Missing ' || what || E':\n        '
            ||  _array_to_sorted_string( missing, E'\n        ' )
        );
    END IF;

    RETURN ok(res, descr) || msg;
END;

_array_to_sorted_string

Signature: evergreen._array_to_sorted_string(name[], text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT array_to_string(ARRAY(
        SELECT $1[i]
          FROM generate_series(1, array_upper($1, 1)) s(i)
         ORDER BY $1[i]
    ), $2);

_assets_are

Signature: evergreen._assets_are(text, text[], text[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _areni(
        $1,
        ARRAY(
            SELECT UPPER($2[i]) AS thing
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
             ORDER BY thing
        ),
        ARRAY(
            SELECT $3[i] AS thing
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT UPPER($2[i])
              FROM generate_series(1, array_upper($2, 1)) s(i)
             ORDER BY thing
        ),
        $4
    );

_cast_exists

Signature: evergreen._cast_exists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_cast c
        WHERE _cmp_types(castsource, $1)
          AND _cmp_types(casttarget, $2)
   );

_cast_exists

Signature: evergreen._cast_exists(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_cast c
         JOIN pg_catalog.pg_proc p ON c.castfunc = p.oid
        WHERE _cmp_types(castsource, $1)
          AND _cmp_types(casttarget, $2)
          AND p.proname   = $3
   );

_cast_exists

Signature: evergreen._cast_exists(name, name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_cast c
         JOIN pg_catalog.pg_proc p ON c.castfunc = p.oid
         JOIN pg_catalog.pg_namespace n ON p.pronamespace = n.oid
        WHERE _cmp_types(castsource, $1)
          AND _cmp_types(casttarget, $2)
          AND n.nspname   = $3
          AND p.proname   = $4
   );

_cdi

Signature: evergreen._cdi(name, name, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_default_is(
        $1, $2, $3,
        'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should default to '
        || COALESCE( quote_literal($3), 'NULL')
    );

_cdi

Signature: evergreen._cdi(name, name, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2 ) THEN
        RETURN fail( $4 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist' );
    END IF;

    IF NOT _has_def( $1, $2 ) THEN
        RETURN fail( $4 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || ' has no default' );
    END IF;

    RETURN _def_is(
        pg_catalog.pg_get_expr(d.adbin, d.adrelid),
        pg_catalog.format_type(a.atttypid, a.atttypmod),
        $3, $4
    )
      FROM pg_catalog.pg_class c, pg_catalog.pg_attribute a, pg_catalog.pg_attrdef d
     WHERE c.oid = a.attrelid
       AND pg_table_is_visible(c.oid)
       AND a.atthasdef
       AND a.attrelid = d.adrelid
       AND a.attnum = d.adnum
       AND c.relname = $1
       AND a.attnum > 0
       AND NOT a.attisdropped
       AND a.attname = $2;
END;

_cdi

Signature: evergreen._cdi(name, name, name, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2, $3 ) THEN
        RETURN fail( $5 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3) || ' does not exist' );
    END IF;

    IF NOT _has_def( $1, $2, $3 ) THEN
        RETURN fail( $5 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3) || ' has no default' );
    END IF;

    RETURN _def_is(
        pg_catalog.pg_get_expr(d.adbin, d.adrelid),
        pg_catalog.format_type(a.atttypid, a.atttypmod),
        $4, $5
    )
      FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_attribute a,
           pg_catalog.pg_attrdef d
     WHERE n.oid = c.relnamespace
       AND c.oid = a.attrelid
       AND a.atthasdef
       AND a.attrelid = d.adrelid
       AND a.attnum = d.adnum
       AND n.nspname = $1
       AND c.relname = $2
       AND a.attnum > 0
       AND NOT a.attisdropped
       AND a.attname = $3;
END;

_cexists

Signature: evergreen._cexists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_class c
          JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
         WHERE c.relname = $1
           AND pg_catalog.pg_table_is_visible(c.oid)
           AND a.attnum > 0
           AND NOT a.attisdropped
           AND a.attname = $2
    );

_cexists

Signature: evergreen._cexists(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
          JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
         WHERE n.nspname = $1
           AND c.relname = $2
           AND a.attnum > 0
           AND NOT a.attisdropped
           AND a.attname = $3
    );

_ckeys

Signature: evergreen._ckeys(name, character)

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _keys($1, $2) LIMIT 1;

_ckeys

Signature: evergreen._ckeys(name, name, character)

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _keys($1, $2, $3) LIMIT 1;

_cleanup

Signature: evergreen._cleanup()

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    DROP SEQUENCE __tresults___numb_seq;
    DROP TABLE __tcache__;
    DROP SEQUENCE __tcache___id_seq;
    SELECT TRUE;

_cmp_types

Signature: evergreen._cmp_types(oid, name)

Returns: boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    dtype TEXT := pg_catalog.format_type($1, NULL);
BEGIN
    RETURN dtype = _quote_ident_like($2, dtype);
END;

_col_is_null

Signature: evergreen._col_is_null(name, name, name, text, boolean)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    qcol CONSTANT text := quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3);
    c_desc CONSTANT text := coalesce(
        $4,
        'Column ' || qcol || ' should '
            || CASE WHEN $5 THEN 'be NOT' ELSE 'allow' END || ' NULL'
    );
BEGIN
    IF NOT _cexists( $1, $2, $3 ) THEN
        RETURN fail( c_desc ) || E'\n'
            || diag ('    Column ' || qcol || ' does not exist' );
    END IF;
    RETURN ok(
        EXISTS(
            SELECT true
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE n.nspname = $1
               AND c.relname = $2
               AND a.attnum  > 0
               AND NOT a.attisdropped
               AND a.attname    = $3
               AND a.attnotnull = $5
        ), c_desc
    );
END;

_col_is_null

Signature: evergreen._col_is_null(name, name, text, boolean)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    qcol CONSTANT text := quote_ident($1) || '.' || quote_ident($2);
    c_desc CONSTANT text := coalesce(
        $3,
        'Column ' || qcol || ' should '
            || CASE WHEN $4 THEN 'be NOT' ELSE 'allow' END || ' NULL'
    );
BEGIN
    IF NOT _cexists( $1, $2 ) THEN
        RETURN fail( c_desc ) || E'\n'
            || diag ('    Column ' || qcol || ' does not exist' );
    END IF;
    RETURN ok(
        EXISTS(
            SELECT true
              FROM pg_catalog.pg_class c
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE pg_catalog.pg_table_is_visible(c.oid)
               AND c.relname = $1
               AND a.attnum > 0
               AND NOT a.attisdropped
               AND a.attname    = $2
               AND a.attnotnull = $4
        ), c_desc
    );
END;

_constraint

Signature: evergreen._constraint(name, character, name[], text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    akey NAME[];
    keys TEXT[] := '{}';
    have TEXT;
BEGIN
    FOR akey IN SELECT * FROM _keys($1, $2) LOOP
        IF akey = $3 THEN RETURN pass($4); END IF;
        keys = keys || akey::text;
    END LOOP;
    IF array_upper(keys, 0) = 1 THEN
        have := 'No ' || $5 || ' constraints';
    ELSE
        have := array_to_string(keys, E'\n              ');
    END IF;

    RETURN fail($4) || E'\n' || diag(
             '        have: ' || have
       || E'\n        want: ' || CASE WHEN $3 IS NULL THEN 'NULL' ELSE $3::text END
    );
END;

_constraint

Signature: evergreen._constraint(name, name, character, name[], text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    akey NAME[];
    keys TEXT[] := '{}';
    have TEXT;
BEGIN
    FOR akey IN SELECT * FROM _keys($1, $2, $3) LOOP
        IF akey = $4 THEN RETURN pass($5); END IF;
        keys = keys || akey::text;
    END LOOP;
    IF array_upper(keys, 0) = 1 THEN
        have := 'No ' || $6 || ' constraints';
    ELSE
        have := array_to_string(keys, E'\n              ');
    END IF;

    RETURN fail($5) || E'\n' || diag(
             '        have: ' || have
       || E'\n        want: ' || CASE WHEN $4 IS NULL THEN 'NULL' ELSE $4::text END
    );
END;

_contract_on

Signature: evergreen._contract_on(text)

Returns: "char"

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
   SELECT CASE substring(LOWER($1) FROM 1 FOR 1)
          WHEN 's' THEN '1'::"char"
          WHEN 'u' THEN '2'::"char"
          WHEN 'i' THEN '3'::"char"
          WHEN 'd' THEN '4'::"char"
          ELSE          '0'::"char" END

_currtest

Signature: evergreen._currtest()

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    RETURN currval('__tresults___numb_seq');
EXCEPTION
    WHEN object_not_in_prerequisite_state THEN RETURN 0;
END;

_db_privs

Signature: evergreen._db_privs()

Returns: name[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    pgversion INTEGER := pg_version_num();
BEGIN
    IF pgversion < 80200 THEN
        RETURN ARRAY['CREATE', 'TEMPORARY'];
    ELSE
        RETURN ARRAY['CREATE', 'CONNECT', 'TEMPORARY'];
    END IF;
END;

_def_is

Signature: evergreen._def_is(text, text, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    thing text;
BEGIN
    -- Function or special SQL syntax.
    IF $1 ~ '^[^'']+[(]' OR $1 = ANY('{CURRENT_CATALOG,CURRENT_ROLE,CURRENT_SCHEMA,CURRENT_USER,SESSION_USER,USER}') THEN
        RETURN is( $1, $3, $4 );
    END IF;

    EXECUTE 'SELECT is('
             || COALESCE($1, 'NULL' || '::' || $2) || '::' || $2 || ', '
             || COALESCE(quote_literal($3), 'NULL') || '::' || $2 || ', '
             || COALESCE(quote_literal($4), 'NULL')
    || ')' INTO thing;
    RETURN thing;
END;

_definer

Signature: evergreen._definer(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_definer FROM tap_funky WHERE name = $1 AND is_visible;

_definer

Signature: evergreen._definer(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_definer FROM tap_funky WHERE schema = $1 AND name = $2

_definer

Signature: evergreen._definer(name, name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_definer
      FROM tap_funky
     WHERE schema = $1
       AND name   = $2
       AND args   = array_to_string($3, ',')

_definer

Signature: evergreen._definer(name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_definer
      FROM tap_funky
     WHERE name = $1
       AND args = array_to_string($2, ',')
       AND is_visible;

_dexists

Signature: evergreen._dexists(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT EXISTS(
       SELECT true
         FROM pg_catalog.pg_type t
        WHERE t.typname = $1
          AND pg_catalog.pg_type_is_visible(t.oid)
   );

_dexists

Signature: evergreen._dexists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT EXISTS(
       SELECT true
         FROM pg_catalog.pg_namespace n
         JOIN pg_catalog.pg_type t on n.oid = t.typnamespace
        WHERE n.nspname = $1
          AND t.typname = $2
   );

_do_ne

Signature: evergreen._do_ne(text, text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have    ALIAS FOR $1;
    want    ALIAS FOR $2;
    extras  TEXT[]  := '{}';
    missing TEXT[]  := '{}';
    res     BOOLEAN := TRUE;
    msg     TEXT    := '';
BEGIN
    BEGIN
        -- Find extra records.
        EXECUTE 'SELECT EXISTS ( '
             || '( SELECT * FROM ' || have || ' EXCEPT ' || $4
             || '  SELECT * FROM ' || want
             || ' ) UNION ( '
             || '  SELECT * FROM ' || want || ' EXCEPT ' || $4
             || '  SELECT * FROM ' || have
             || ' ) LIMIT 1 )' INTO res;

        -- Drop the temporary tables.
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
    EXCEPTION WHEN syntax_error OR datatype_mismatch THEN
        msg := E'\n' || diag(
            E'    Columns differ between queries:\n'
            || '        have: (' || _temptypes(have) || E')\n'
            || '        want: (' || _temptypes(want) || ')'
        );
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
        RETURN ok(FALSE, $3) || msg;
    END;

    -- Return the value from the query.
    RETURN ok(res, $3);
END;

_docomp

Signature: evergreen._docomp(text, text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have    ALIAS FOR $1;
    want    ALIAS FOR $2;
    extras  TEXT[]  := '{}';
    missing TEXT[]  := '{}';
    res     BOOLEAN := TRUE;
    msg     TEXT    := '';
    rec     RECORD;
BEGIN
    BEGIN
        -- Find extra records.
        FOR rec in EXECUTE 'SELECT * FROM ' || have || ' EXCEPT ' || $4
                        || 'SELECT * FROM ' || want LOOP
            extras := extras || rec::text;
        END LOOP;

        -- Find missing records.
        FOR rec in EXECUTE 'SELECT * FROM ' || want || ' EXCEPT ' || $4
                        || 'SELECT * FROM ' || have LOOP
            missing := missing || rec::text;
        END LOOP;

        -- Drop the temporary tables.
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
    EXCEPTION WHEN syntax_error OR datatype_mismatch THEN
        msg := E'\n' || diag(
            E'    Columns differ between queries:\n'
            || '        have: (' || _temptypes(have) || E')\n'
            || '        want: (' || _temptypes(want) || ')'
        );
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
        RETURN ok(FALSE, $3) || msg;
    END;

    -- What extra records do we have?
    IF extras[1] IS NOT NULL THEN
        res := FALSE;
        msg := E'\n' || diag(
            E'    Extra records:\n        '
            ||  array_to_string( extras, E'\n        ' )
        );
    END IF;

    -- What missing records do we have?
    IF missing[1] IS NOT NULL THEN
        res := FALSE;
        msg := msg || E'\n' || diag(
            E'    Missing records:\n        '
            ||  array_to_string( missing, E'\n        ' )
        );
    END IF;

    RETURN ok(res, $3) || msg;
END;

_error_diag

Signature: evergreen._error_diag(text, text, text, text, text, text, text, text, text, text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT COALESCE(
               COALESCE( NULLIF($1, '') || ': ', '' ) || COALESCE( NULLIF($2, ''), '' ),
               'NO ERROR FOUND'
           )
        || COALESCE(E'\n        DETAIL:     ' || nullif($3, ''), '')
        || COALESCE(E'\n        HINT:       ' || nullif($4, ''), '')
        || COALESCE(E'\n        SCHEMA:     ' || nullif($6, ''), '')
        || COALESCE(E'\n        TABLE:      ' || nullif($7, ''), '')
        || COALESCE(E'\n        COLUMN:     ' || nullif($8, ''), '')
        || COALESCE(E'\n        CONSTRAINT: ' || nullif($9, ''), '')
        || COALESCE(E'\n        TYPE:       ' || nullif($10, ''), '')
        -- We need to manually indent all the context lines
        || COALESCE(E'\n        CONTEXT:\n'
               || regexp_replace(NULLIF( $5, ''), '^', '            ', 'gn'
           ), '');

_expand_context

Signature: evergreen._expand_context(character)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
   SELECT CASE $1
          WHEN 'i' THEN 'implicit'
          WHEN 'a' THEN 'assignment'
          WHEN 'e' THEN 'explicit'
          ELSE          'unknown' END

_expand_on

Signature: evergreen._expand_on(character)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
   SELECT CASE $1
          WHEN '1' THEN 'SELECT'
          WHEN '2' THEN 'UPDATE'
          WHEN '3' THEN 'INSERT'
          WHEN '4' THEN 'DELETE'
          ELSE          'UNKNOWN' END

_expand_vol

Signature: evergreen._expand_vol(character)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
   SELECT CASE $1
          WHEN 'i' THEN 'IMMUTABLE'
          WHEN 's' THEN 'STABLE'
          WHEN 'v' THEN 'VOLATILE'
          ELSE          'UNKNOWN' END

_ext_exists

Signature: evergreen._ext_exists(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
        SELECT TRUE
          FROM pg_catalog.pg_extension ex
         WHERE ex.extname = $1
    );

_ext_exists

Signature: evergreen._ext_exists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
        SELECT TRUE
          FROM pg_catalog.pg_extension ex
          JOIN pg_catalog.pg_namespace n ON ex.extnamespace = n.oid
         WHERE n.nspname  = $1
           AND ex.extname = $2
    );

_extensions

Signature: evergreen._extensions()

Returns: SETOF name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT extname FROM pg_catalog.pg_extension

_extensions

Signature: evergreen._extensions(name)

Returns: SETOF name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT e.extname
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_extension e ON n.oid = e.extnamespace
     WHERE n.nspname = $1

_extras

Signature: evergreen._extras(character, name, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _extras(ARRAY[$1], $2, $3);

_extras

Signature: evergreen._extras(character, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT _extras(ARRAY[$1], $2);

_extras

Signature: evergreen._extras(character[], name, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT c.relname
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE c.relkind = ANY($1)
           AND n.nspname = $2
           AND c.relname NOT IN('pg_all_foreign_keys', 'tap_funky', '__tresults___numb_seq', '__tcache___id_seq')
        EXCEPT
        SELECT $3[i]
          FROM generate_series(1, array_upper($3, 1)) s(i)
    );

_extras

Signature: evergreen._extras(character[], name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT c.relname
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE pg_catalog.pg_table_is_visible(c.oid)
           AND n.nspname <> 'pg_catalog'
           AND c.relkind = ANY($1)
           AND c.relname NOT IN ('__tcache__', 'pg_all_foreign_keys', 'tap_funky', '__tresults___numb_seq', '__tcache___id_seq')
        EXCEPT
        SELECT $2[i]
          FROM generate_series(1, array_upper($2, 1)) s(i)
    );

_finish

Signature: evergreen._finish(integer, integer, integer, boolean DEFAULT NULL::boolean)

Returns: SETOF text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    curr_test ALIAS FOR $1;
    exp_tests INTEGER := $2;
    num_faild ALIAS FOR $3;
    plural    CHAR;
    raise_ex  ALIAS FOR $4;
BEGIN
    plural    := CASE exp_tests WHEN 1 THEN '' ELSE 's' END;

    IF curr_test IS NULL THEN
        RAISE EXCEPTION '# No tests run!';
    END IF;

    IF exp_tests = 0 OR exp_tests IS NULL THEN
         -- No plan. Output one now.
        exp_tests = curr_test;
        RETURN NEXT '1..' || exp_tests;
    END IF;

    IF curr_test <> exp_tests THEN
        RETURN NEXT diag(
            'Looks like you planned ' || exp_tests || ' test' ||
            plural || ' but ran ' || curr_test
        );
    ELSIF num_faild > 0 THEN
        IF raise_ex THEN
            RAISE EXCEPTION  '% test% failed of %', num_faild, CASE num_faild WHEN 1 THEN '' ELSE 's' END, exp_tests;
        END IF;
        RETURN NEXT diag(
            'Looks like you failed ' || num_faild || ' test' ||
            CASE num_faild WHEN 1 THEN '' ELSE 's' END
            || ' of ' || exp_tests
        );
    ELSE

    END IF;
    RETURN;
END;

_fkexists

Signature: evergreen._fkexists(name, name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT TRUE
           FROM pg_all_foreign_keys
          WHERE fk_schema_name    = $1
            AND quote_ident(fk_table_name)     = quote_ident($2)
            AND fk_columns = $3
    );

_fkexists

Signature: evergreen._fkexists(name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT TRUE
           FROM pg_all_foreign_keys
          WHERE quote_ident(fk_table_name)     = quote_ident($1)
            AND pg_catalog.pg_table_is_visible(fk_table_oid)
            AND fk_columns = $2
    );

_fprivs_are

Signature: evergreen._fprivs_are(text, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_func_privs($2, $1);
BEGIN
    IF grants[1] = 'undefined_function' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Function ' || $1 || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

_func_compare

Signature: evergreen._func_compare(name, name, anyelement, anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $3 IS NULL
      THEN ok( FALSE, $5 ) || _nosuch($1, $2, '{}')
      ELSE is( $3, $4, $5 )
      END;

_func_compare

Signature: evergreen._func_compare(name, name, boolean, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $3 IS NULL
      THEN ok( FALSE, $4 ) || _nosuch($1, $2, '{}')
      ELSE ok( $3, $4 )
      END;

_func_compare

Signature: evergreen._func_compare(name, name, name[], anyelement, anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $4 IS NULL
      THEN ok( FALSE, $6 ) || _nosuch($1, $2, $3)
      ELSE is( $4, $5, $6 )
      END;

_func_compare

Signature: evergreen._func_compare(name, name, name[], boolean, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $4 IS NULL
      THEN ok( FALSE, $5 ) || _nosuch($1, $2, $3)
      ELSE ok( $4, $5 )
      END;

_funkargs

Signature: evergreen._funkargs(name[])

Returns: text

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
BEGIN
    RETURN array_to_string($1::regtype[], ',');
EXCEPTION WHEN undefined_object THEN
    RETURN array_to_string($1, ',');
END;

_get

Signature: evergreen._get(text)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    ret integer;
BEGIN
    EXECUTE 'SELECT value FROM __tcache__ WHERE label = ' || quote_literal($1) || ' LIMIT 1' INTO ret;
    RETURN ret;
END;

_get_ac_privs

Signature: evergreen._get_ac_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := ARRAY['INSERT', 'REFERENCES', 'SELECT', 'UPDATE'];
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        BEGIN
            IF pg_catalog.has_any_column_privilege($1, $2, privs[i]) THEN
                grants := grants || privs[i];
            END IF;
        EXCEPTION WHEN undefined_table THEN
            -- Not a valid table name.
            RETURN '{undefined_table}';
        WHEN undefined_object THEN
            -- Not a valid role.
            RETURN '{undefined_role}';
        WHEN invalid_parameter_value THEN
            -- Not a valid permission on this version of PostgreSQL; ignore;
        END;
    END LOOP;
    RETURN grants;
END;

_get_col_ns_type

Signature: evergreen._get_col_ns_type(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    -- Always include the namespace.
    SELECT CASE WHEN pg_catalog.pg_type_is_visible(t.oid)
                THEN quote_ident(tn.nspname) || '.'
                ELSE ''
           END || pg_catalog.format_type(a.atttypid, a.atttypmod)
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_class c      ON n.oid = c.relnamespace
      JOIN pg_catalog.pg_attribute a  ON c.oid = a.attrelid
      JOIN pg_catalog.pg_type t       ON a.atttypid = t.oid
      JOIN pg_catalog.pg_namespace tn ON t.typnamespace = tn.oid
     WHERE n.nspname = $1
       AND c.relname = $2
       AND a.attname = $3
       AND attnum    > 0
       AND NOT a.attisdropped

_get_col_privs

Signature: evergreen._get_col_privs(name, text, name)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := ARRAY['INSERT', 'REFERENCES', 'SELECT', 'UPDATE'];
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        IF pg_catalog.has_column_privilege($1, $2, $3, privs[i]) THEN
            grants := grants || privs[i];
        END IF;
    END LOOP;
    RETURN grants;
EXCEPTION
    -- Not a valid column name.
    WHEN undefined_column THEN RETURN '{undefined_column}';
    -- Not a valid table name.
    WHEN undefined_table THEN RETURN '{undefined_table}';
    -- Not a valid role.
    WHEN undefined_object THEN RETURN '{undefined_role}';
END;

_get_col_type

Signature: evergreen._get_col_type(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.format_type(a.atttypid, a.atttypmod)
      FROM pg_catalog.pg_attribute a
      JOIN pg_catalog.pg_class c ON  a.attrelid = c.oid
     WHERE pg_catalog.pg_table_is_visible(c.oid)
       AND c.relname = $1
       AND a.attname = $2
       AND attnum    > 0
       AND NOT a.attisdropped

_get_col_type

Signature: evergreen._get_col_type(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.format_type(a.atttypid, a.atttypmod)
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_class c     ON n.oid = c.relnamespace
      JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
     WHERE n.nspname = $1
       AND c.relname = $2
       AND a.attname = $3
       AND attnum    > 0
       AND NOT a.attisdropped

_get_context

Signature: evergreen._get_context(name, name)

Returns: "char"

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT c.castcontext
     FROM pg_catalog.pg_cast c
    WHERE _cmp_types(castsource, $1)
      AND _cmp_types(casttarget, $2)

_get_db_owner

Signature: evergreen._get_db_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(datdba)
      FROM pg_catalog.pg_database
     WHERE datname = $1;

_get_db_privs

Signature: evergreen._get_db_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := _db_privs();
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        BEGIN
            IF pg_catalog.has_database_privilege($1, $2, privs[i]) THEN
                grants := grants || privs[i];
            END IF;
        EXCEPTION WHEN invalid_catalog_name THEN
            -- Not a valid db name.
            RETURN '{invalid_catalog_name}';
        WHEN undefined_object THEN
            -- Not a valid role.
            RETURN '{undefined_role}';
        WHEN invalid_parameter_value THEN
            -- Not a valid permission on this version of PostgreSQL; ignore;
        END;
    END LOOP;
    RETURN grants;
END;

_get_dtype

Signature: evergreen._get_dtype(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.format_type(t.oid, t.typtypmod)
      FROM pg_catalog.pg_type d
      JOIN pg_catalog.pg_type t  ON d.typbasetype  = t.oid
     WHERE d.typisdefined
       AND pg_catalog.pg_type_is_visible(d.oid)
       AND d.typname = LOWER($1)
       AND d.typtype = 'd'

_get_dtype

Signature: evergreen._get_dtype(name, text, boolean)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $3 AND pg_catalog.pg_type_is_visible(t.oid)
                THEN quote_ident(tn.nspname) || '.'
                ELSE ''
            END || pg_catalog.format_type(t.oid, t.typtypmod)
      FROM pg_catalog.pg_type d
      JOIN pg_catalog.pg_namespace dn ON d.typnamespace = dn.oid
      JOIN pg_catalog.pg_type t       ON d.typbasetype  = t.oid
      JOIN pg_catalog.pg_namespace tn ON t.typnamespace = tn.oid
     WHERE d.typisdefined
       AND dn.nspname = $1
       AND d.typname  = LOWER($2)
       AND d.typtype  = 'd'

_get_fdw_privs

Signature: evergreen._get_fdw_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_catalog.has_foreign_data_wrapper_privilege($1, $2, 'USAGE') THEN
        RETURN '{USAGE}';
    ELSE
        RETURN '{}';
    END IF;
EXCEPTION WHEN undefined_object THEN
    -- Same error code for unknown user or fdw. So figure out which.
    RETURN CASE WHEN SQLERRM LIKE '%' || $1 || '%' THEN
        '{undefined_role}'
    ELSE
        '{undefined_fdw}'
    END;
END;

_get_func_owner

Signature: evergreen._get_func_owner(name, name, name[])

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT owner
      FROM tap_funky
     WHERE schema = $1
       AND name   = $2
       AND args   = array_to_string($3, ',')

_get_func_owner

Signature: evergreen._get_func_owner(name, name[])

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT owner
      FROM tap_funky
     WHERE name = $1
       AND args = array_to_string($2, ',')
       AND is_visible

_get_func_privs

Signature: evergreen._get_func_privs(text, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_catalog.has_function_privilege($1, $2, 'EXECUTE') THEN
        RETURN '{EXECUTE}';
    ELSE
        RETURN '{}';
    END IF;
EXCEPTION
    -- Not a valid func name.
    WHEN undefined_function THEN RETURN '{undefined_function}';
    -- Not a valid role.
    WHEN undefined_object   THEN RETURN '{undefined_role}';
END;

_get_index_owner

Signature: evergreen._get_index_owner(name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(ci.relowner)
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
     WHERE ct.relname = $1
       AND ci.relname = $2
       AND pg_catalog.pg_table_is_visible(ct.oid);

_get_index_owner

Signature: evergreen._get_index_owner(name, name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(ci.relowner)
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
     WHERE n.nspname  = $1
       AND ct.relname = $2
       AND ci.relname = $3;

_get_lang_privs

Signature: evergreen._get_lang_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_catalog.has_language_privilege($1, $2, 'USAGE') THEN
        RETURN '{USAGE}';
    ELSE
        RETURN '{}';
    END IF;
EXCEPTION WHEN undefined_object THEN
    -- Same error code for unknown user or language. So figure out which.
    RETURN CASE WHEN SQLERRM LIKE '%' || $1 || '%' THEN
        '{undefined_role}'
    ELSE
        '{undefined_language}'
    END;
END;

_get_language_owner

Signature: evergreen._get_language_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(lanowner)
      FROM pg_catalog.pg_language
     WHERE lanname = $1;

_get_latest

Signature: evergreen._get_latest(text)

Returns: integer[]

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    ret integer[];
BEGIN
    EXECUTE 'SELECT ARRAY[id, value] FROM __tcache__ WHERE label = ' ||
    quote_literal($1) || ' AND id = (SELECT MAX(id) FROM __tcache__ WHERE label = ' ||
    quote_literal($1) || ') LIMIT 1' INTO ret;
    RETURN ret;
EXCEPTION WHEN undefined_table THEN
   RAISE EXCEPTION 'You tried to run a test without a plan! Gotta have a plan';
END;

_get_latest

Signature: evergreen._get_latest(text, integer)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    ret integer;
BEGIN
    EXECUTE 'SELECT MAX(id) FROM __tcache__ WHERE label = ' ||
    quote_literal($1) || ' AND value = ' || $2 INTO ret;
    RETURN ret;
END;

_get_note

Signature: evergreen._get_note(integer)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    ret text;
BEGIN
    EXECUTE 'SELECT note FROM __tcache__ WHERE id = ' || $1 || ' LIMIT 1' INTO ret;
    RETURN ret;
END;

_get_note

Signature: evergreen._get_note(text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    ret text;
BEGIN
    EXECUTE 'SELECT note FROM __tcache__ WHERE label = ' || quote_literal($1) || ' LIMIT 1' INTO ret;
    RETURN ret;
END;

_get_opclass_owner

Signature: evergreen._get_opclass_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(opcowner)
      FROM pg_catalog.pg_opclass
     WHERE opcname = $1
       AND pg_catalog.pg_opclass_is_visible(oid);

_get_opclass_owner

Signature: evergreen._get_opclass_owner(name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(opcowner)
      FROM pg_catalog.pg_opclass oc
      JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
     WHERE n.nspname = $1
       AND opcname   = $2;

_get_rel_owner

Signature: evergreen._get_rel_owner(character, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _get_rel_owner(ARRAY[$1], $2);

_get_rel_owner

Signature: evergreen._get_rel_owner(character, name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _get_rel_owner(ARRAY[$1], $2, $3);

_get_rel_owner

Signature: evergreen._get_rel_owner(character[], name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(c.relowner)
      FROM pg_catalog.pg_class c
     WHERE c.relkind = ANY($1)
       AND c.relname = $2
       AND pg_catalog.pg_table_is_visible(c.oid)

_get_rel_owner

Signature: evergreen._get_rel_owner(character[], name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(c.relowner)
      FROM pg_catalog.pg_class c
      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
     WHERE c.relkind = ANY($1)
       AND n.nspname = $2
       AND c.relname = $3

_get_rel_owner

Signature: evergreen._get_rel_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(c.relowner)
      FROM pg_catalog.pg_class c
     WHERE c.relname = $1
       AND pg_catalog.pg_table_is_visible(c.oid)

_get_rel_owner

Signature: evergreen._get_rel_owner(name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(c.relowner)
      FROM pg_catalog.pg_class c
      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
     WHERE n.nspname = $1
       AND c.relname = $2

_get_schema_owner

Signature: evergreen._get_schema_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(nspowner)
      FROM pg_catalog.pg_namespace
     WHERE nspname = $1;

_get_schema_privs

Signature: evergreen._get_schema_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := ARRAY['CREATE', 'USAGE'];
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        IF pg_catalog.has_schema_privilege($1, $2, privs[i]) THEN
            grants := grants || privs[i];
        END IF;
    END LOOP;
    RETURN grants;
EXCEPTION
    -- Not a valid schema name.
    WHEN invalid_schema_name THEN RETURN '{invalid_schema_name}';
    -- Not a valid role.
    WHEN undefined_object   THEN RETURN '{undefined_role}';
END;

_get_sequence_privs

Signature: evergreen._get_sequence_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := ARRAY['SELECT', 'UPDATE', 'USAGE'];
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        BEGIN
            IF pg_catalog.has_sequence_privilege($1, $2, privs[i]) THEN
                grants := grants || privs[i];
            END IF;
        EXCEPTION WHEN undefined_table THEN
            -- Not a valid sequence name.
            RETURN '{undefined_table}';
        WHEN undefined_object THEN
            -- Not a valid role.
            RETURN '{undefined_role}';
        WHEN invalid_parameter_value THEN
            -- Not a valid permission on this version of PostgreSQL; ignore;
        END;
    END LOOP;
    RETURN grants;
END;

_get_server_privs

Signature: evergreen._get_server_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_catalog.has_server_privilege($1, $2, 'USAGE') THEN
        RETURN '{USAGE}';
    ELSE
        RETURN '{}';
    END IF;
EXCEPTION WHEN undefined_object THEN
    -- Same error code for unknown user or server. So figure out which.
    RETURN CASE WHEN SQLERRM LIKE '%' || $1 || '%' THEN
        '{undefined_role}'
    ELSE
        '{undefined_server}'
    END;
END;

_get_table_privs

Signature: evergreen._get_table_privs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    privs  TEXT[] := _table_privs();
    grants TEXT[] := '{}';
BEGIN
    FOR i IN 1..array_upper(privs, 1) LOOP
        BEGIN
            IF pg_catalog.has_table_privilege($1, $2, privs[i]) THEN
                grants := grants || privs[i];
            END IF;
        EXCEPTION WHEN undefined_table THEN
            -- Not a valid table name.
            RETURN '{undefined_table}';
        WHEN undefined_object THEN
            -- Not a valid role.
            RETURN '{undefined_role}';
        WHEN invalid_parameter_value THEN
            -- Not a valid permission on this version of PostgreSQL; ignore;
        END;
    END LOOP;
    RETURN grants;
END;

_get_tablespace_owner

Signature: evergreen._get_tablespace_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(spcowner)
      FROM pg_catalog.pg_tablespace
     WHERE spcname = $1;

_get_tablespaceprivs

Signature: evergreen._get_tablespaceprivs(name, text)

Returns: text[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_catalog.has_tablespace_privilege($1, $2, 'CREATE') THEN
        RETURN '{CREATE}';
    ELSE
        RETURN '{}';
    END IF;
EXCEPTION WHEN undefined_object THEN
    -- Same error code for unknown user or tablespace. So figure out which.
    RETURN CASE WHEN SQLERRM LIKE '%' || $1 || '%' THEN
        '{undefined_role}'
    ELSE
        '{undefined_tablespace}'
    END;
END;

_get_type_owner

Signature: evergreen._get_type_owner(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(typowner)
      FROM pg_catalog.pg_type
     WHERE typname = $1
       AND pg_catalog.pg_type_is_visible(oid)

_get_type_owner

Signature: evergreen._get_type_owner(name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT pg_catalog.pg_get_userbyid(t.typowner)
      FROM pg_catalog.pg_type t
      JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
     WHERE n.nspname = $1
       AND t.typname = $2

_got_func

Signature: evergreen._got_func(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS( SELECT TRUE FROM tap_funky WHERE name = $1 AND is_visible);

_got_func

Signature: evergreen._got_func(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS( SELECT TRUE FROM tap_funky WHERE schema = $1 AND name = $2 );

_got_func

Signature: evergreen._got_func(name, name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT TRUE
          FROM tap_funky
         WHERE schema = $1
           AND name   = $2
           AND args = _funkargs($3)
    );

_got_func

Signature: evergreen._got_func(name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT TRUE
          FROM tap_funky
         WHERE name = $1
           AND args = _funkargs($2)
           AND is_visible
    );

_grolist

Signature: evergreen._grolist(name)

Returns: oid[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT member
          FROM pg_catalog.pg_auth_members m
          JOIN pg_catalog.pg_roles r ON m.roleid = r.oid
         WHERE r.rolname =  $1
    );

_has_def

Signature: evergreen._has_def(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT a.atthasdef
      FROM pg_catalog.pg_class c
      JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
     WHERE c.relname = $1
       AND a.attnum > 0
       AND NOT a.attisdropped
       AND a.attname = $2
       AND pg_catalog.pg_table_is_visible(c.oid)

_has_def

Signature: evergreen._has_def(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT a.atthasdef
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
      JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
     WHERE n.nspname = $1
       AND c.relname = $2
       AND a.attnum > 0
       AND NOT a.attisdropped
       AND a.attname = $3

_has_group

Signature: evergreen._has_group(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_group
         WHERE groname = $1
    );

_has_role

Signature: evergreen._has_role(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_roles
         WHERE rolname = $1
    );

_has_type

Signature: evergreen._has_type(name, character[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_type t
         WHERE t.typisdefined
           AND pg_catalog.pg_type_is_visible(t.oid)
           AND t.typname = $1
           AND t.typtype = ANY( COALESCE($2, ARRAY['b', 'c', 'd', 'p', 'e']) )
    );

_has_type

Signature: evergreen._has_type(name, name, character[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_type t
          JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
         WHERE t.typisdefined
           AND n.nspname = $1
           AND t.typname = $2
           AND t.typtype = ANY( COALESCE($3, ARRAY['b', 'c', 'd', 'p', 'e']) )
    );

_has_user

Signature: evergreen._has_user(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT EXISTS( SELECT true FROM pg_catalog.pg_user WHERE usename = $1);

_hasc

Signature: evergreen._hasc(name, character)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
            SELECT true
              FROM pg_catalog.pg_class c
              JOIN pg_catalog.pg_constraint x ON c.oid = x.conrelid
             WHERE pg_table_is_visible(c.oid)
               AND c.relname = $1
               AND x.contype = $2
    );

_hasc

Signature: evergreen._hasc(name, name, character)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
            SELECT true
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c      ON c.relnamespace = n.oid
              JOIN pg_catalog.pg_constraint x ON c.oid = x.conrelid
             WHERE n.nspname = $1
               AND c.relname = $2
               AND x.contype = $3
    );

_have_index

Signature: evergreen._have_index(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
    SELECT TRUE
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
     WHERE ct.relname = $1
       AND ci.relname = $2
       AND pg_catalog.pg_table_is_visible(ct.oid)
    );

_have_index

Signature: evergreen._have_index(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
    SELECT TRUE
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
     WHERE n.nspname  = $1
       AND ct.relname = $2
       AND ci.relname = $3
    );

_ident_array_to_sorted_string

Signature: evergreen._ident_array_to_sorted_string(name[], text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT array_to_string(ARRAY(
        SELECT quote_ident($1[i])
          FROM generate_series(1, array_upper($1, 1)) s(i)
         ORDER BY $1[i]
    ), $2);

_ident_array_to_string

Signature: evergreen._ident_array_to_string(name[], text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT array_to_string(ARRAY(
        SELECT quote_ident($1[i])
          FROM generate_series(1, array_upper($1, 1)) s(i)
         ORDER BY i
    ), $2);

_ikeys

Signature: evergreen._ikeys(name, name)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT pg_catalog.pg_get_indexdef( ci.oid, s.i + 1, false)
          FROM pg_catalog.pg_index x
          JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
          JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
          JOIN generate_series(0, current_setting('max_index_keys')::int - 1) s(i)
            ON x.indkey[s.i] IS NOT NULL
         WHERE ct.relname = $1
           AND ci.relname = $2
           AND pg_catalog.pg_table_is_visible(ct.oid)
         ORDER BY s.i
    );

_ikeys

Signature: evergreen._ikeys(name, name, name)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT pg_catalog.pg_get_indexdef( ci.oid, s.i + 1, false)
          FROM pg_catalog.pg_index x
          JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
          JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
          JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
          JOIN generate_series(0, current_setting('max_index_keys')::int - 1) s(i)
            ON x.indkey[s.i] IS NOT NULL
         WHERE ct.relname = $2
           AND ci.relname = $3
           AND n.nspname  = $1
         ORDER BY s.i
    );

_inherited

Signature: evergreen._inherited(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_class c
         WHERE c.relkind = 'r'
           AND pg_catalog.pg_table_is_visible( c.oid )
           AND c.relname = $1
           AND c.relhassubclass = true
    );

_inherited

Signature: evergreen._inherited(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE c.relkind = 'r'
           AND n.nspname = $1
           AND c.relname = $2
           AND c.relhassubclass = true
  );

_is_indexed

Signature: evergreen._is_indexed(name, name, text[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT EXISTS( SELECT TRUE FROM (
        SELECT _ikeys(coalesce($1, n.nspname), $2, ci.relname) AS cols
          FROM pg_catalog.pg_index x
          JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
          JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
          JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
         WHERE ($1 IS NULL OR n.nspname  = $1)
           AND ct.relname = $2
    ) icols
    WHERE cols = $3 )

_is_instead

Signature: evergreen._is_instead(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT r.is_instead
      FROM pg_catalog.pg_rewrite r
      JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
     WHERE r.rulename = $2
       AND c.relname  = $1
       AND pg_catalog.pg_table_is_visible(c.oid)

_is_instead

Signature: evergreen._is_instead(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT r.is_instead
      FROM pg_catalog.pg_rewrite r
      JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
      JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
     WHERE r.rulename = $3
       AND c.relname  = $2
       AND n.nspname  = $1

_is_schema

Signature: evergreen._is_schema(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace
          WHERE nspname = $1
    );

_is_super

Signature: evergreen._is_super(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT rolsuper
      FROM pg_catalog.pg_roles
     WHERE rolname = $1

_is_trusted

Signature: evergreen._is_trusted(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT lanpltrusted FROM pg_catalog.pg_language WHERE lanname = $1;

_is_verbose

Signature: evergreen._is_verbose()

Returns: boolean

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT current_setting('client_min_messages') NOT IN (
        'warning', 'error', 'fatal', 'panic'
    );

_keys

Signature: evergreen._keys(name, character)

Returns: SETOF name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _pg_sv_column_array(x.conrelid,x.conkey) -- name[] doesn't support collation
      FROM pg_catalog.pg_class c
      JOIN pg_catalog.pg_constraint x  ON c.oid = x.conrelid
       AND c.relname = $1
       AND x.contype = $2
     WHERE pg_catalog.pg_table_is_visible(c.oid)
  ORDER BY 1

_keys

Signature: evergreen._keys(name, name, character)

Returns: SETOF name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _pg_sv_column_array(x.conrelid,x.conkey) -- name[] doesn't support collation
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_class c       ON n.oid = c.relnamespace
      JOIN pg_catalog.pg_constraint x  ON c.oid = x.conrelid
     WHERE n.nspname = $1
       AND c.relname = $2
       AND x.contype = $3
  ORDER BY 1

_lang

Signature: evergreen._lang(name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT l.lanname
      FROM tap_funky f
      JOIN pg_catalog.pg_language l ON f.langoid = l.oid
     WHERE f.name = $1
       AND f.is_visible;

_lang

Signature: evergreen._lang(name, name)

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT l.lanname
      FROM tap_funky f
      JOIN pg_catalog.pg_language l ON f.langoid = l.oid
     WHERE f.schema = $1
       and f.name   = $2

_lang

Signature: evergreen._lang(name, name, name[])

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT l.lanname
      FROM tap_funky f
      JOIN pg_catalog.pg_language l ON f.langoid = l.oid
     WHERE f.schema = $1
       and f.name   = $2
       AND f.args   = array_to_string($3, ',')

_lang

Signature: evergreen._lang(name, name[])

Returns: name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT l.lanname
      FROM tap_funky f
      JOIN pg_catalog.pg_language l ON f.langoid = l.oid
     WHERE f.name = $1
       AND f.args = array_to_string($2, ',')
       AND f.is_visible;

_missing

Signature: evergreen._missing(character, name, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _missing(ARRAY[$1], $2, $3);

_missing

Signature: evergreen._missing(character, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _missing(ARRAY[$1], $2);

_missing

Signature: evergreen._missing(character[], name, name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT $3[i]
          FROM generate_series(1, array_upper($3, 1)) s(i)
        EXCEPT
        SELECT c.relname
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE c.relkind = ANY($1)
           AND n.nspname = $2
    );

_missing

Signature: evergreen._missing(character[], name[])

Returns: name[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT $2[i]
          FROM generate_series(1, array_upper($2, 1)) s(i)
        EXCEPT
        SELECT c.relname
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE pg_catalog.pg_table_is_visible(c.oid)
           AND n.nspname NOT IN ('pg_catalog', 'information_schema')
           AND c.relkind = ANY($1)
    );

_nosuch

Signature: evergreen._nosuch(name, name, name[])

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT E'\n' || diag(
        '    Function '
          || CASE WHEN $1 IS NOT NULL THEN quote_ident($1) || '.' ELSE '' END
          || quote_ident($2) || '('
          || array_to_string($3, ', ') || ') does not exist'
    );

_op_exists

Signature: evergreen._op_exists(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_operator o
        WHERE pg_catalog.pg_operator_is_visible(o.oid)
          AND o.oprname = $2
          AND CASE o.oprkind WHEN 'l' THEN $1 IS NULL
              ELSE _cmp_types(o.oprleft, $1) END
          AND CASE o.oprkind WHEN 'r' THEN $3 IS NULL
              ELSE _cmp_types(o.oprright, $3) END
   );

_op_exists

Signature: evergreen._op_exists(name, name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_operator o
        WHERE pg_catalog.pg_operator_is_visible(o.oid)
          AND o.oprname = $2
          AND CASE o.oprkind WHEN 'l' THEN $1 IS NULL
              ELSE _cmp_types(o.oprleft, $1) END
          AND CASE o.oprkind WHEN 'r' THEN $3 IS NULL
              ELSE _cmp_types(o.oprright, $3) END
          AND _cmp_types(o.oprresult, $4)
   );

_op_exists

Signature: evergreen._op_exists(name, name, name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
       SELECT TRUE
         FROM pg_catalog.pg_operator o
         JOIN pg_catalog.pg_namespace n ON o.oprnamespace = n.oid
        WHERE n.nspname = $2
          AND o.oprname = $3
          AND CASE o.oprkind WHEN 'l' THEN $1 IS NULL
              ELSE _cmp_types(o.oprleft, $1) END
          AND CASE o.oprkind WHEN 'r' THEN $4 IS NULL
              ELSE _cmp_types(o.oprright, $4) END
          AND _cmp_types(o.oprresult, $5)
   );

_opc_exists

Signature: evergreen._opc_exists(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
        SELECT TRUE
          FROM pg_catalog.pg_opclass oc
         WHERE oc.opcname = $1
           AND pg_opclass_is_visible(oid)
    );

_opc_exists

Signature: evergreen._opc_exists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS (
        SELECT TRUE
          FROM pg_catalog.pg_opclass oc
          JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
         WHERE n.nspname  = $1
           AND oc.opcname = $2
    );

_partof

Signature: evergreen._partof(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_class cc
          JOIN pg_catalog.pg_inherits i ON cc.oid = i.inhrelid
          JOIN pg_catalog.pg_class pc ON i.inhparent = pc.oid
         WHERE cc.relname = $1
           AND cc.relispartition
           AND pc.relname = $2
           AND pc.relkind = 'p'
           AND pg_catalog.pg_table_is_visible(cc.oid)
           AND pg_catalog.pg_table_is_visible(pc.oid)
    )

_partof

Signature: evergreen._partof(name, name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace cn
          JOIN pg_catalog.pg_class cc ON cn.oid = cc.relnamespace
          JOIN pg_catalog.pg_inherits i ON cc.oid = i.inhrelid
          JOIN pg_catalog.pg_class pc ON i.inhparent = pc.oid
          JOIN pg_catalog.pg_namespace pn ON pc.relnamespace = pn.oid
         WHERE cn.nspname = $1
           AND cc.relname = $2
           AND cc.relispartition
           AND pn.nspname = $3
           AND pc.relname = $4
           AND pc.relkind = 'p'
    )

_parts

Signature: evergreen._parts(name)

Returns: SETOF name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT i.inhrelid::regclass::name
      FROM pg_catalog.pg_class c
      JOIN pg_catalog.pg_inherits i ON c.oid = i.inhparent
     WHERE c.relname = $1
       AND c.relkind = 'p'
       AND pg_catalog.pg_table_is_visible(c.oid)

_parts

Signature: evergreen._parts(name, name)

Returns: SETOF name

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT i.inhrelid::regclass::name
      FROM pg_catalog.pg_namespace n
      JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
      JOIN pg_catalog.pg_inherits i ON c.oid = i.inhparent
     WHERE n.nspname = $1
       AND c.relname = $2
       AND c.relkind = 'p'

_pg_sv_column_array

Signature: evergreen._pg_sv_column_array(oid, smallint[])

Returns: name[]

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT a.attname
          FROM pg_catalog.pg_attribute a
          JOIN generate_series(1, array_upper($2, 1)) s(i) ON a.attnum = $2[i]
         WHERE attrelid = $1
         ORDER BY i
    )

_pg_sv_table_accessible

Signature: evergreen._pg_sv_table_accessible(oid, oid)

Returns: boolean

Language

sql

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT CASE WHEN has_schema_privilege($1, 'USAGE') THEN (
                  has_table_privilege($2, 'SELECT')
               OR has_table_privilege($2, 'INSERT')
               or has_table_privilege($2, 'UPDATE')
               OR has_table_privilege($2, 'DELETE')
               OR has_table_privilege($2, 'RULE')
               OR has_table_privilege($2, 'REFERENCES')
               OR has_table_privilege($2, 'TRIGGER')
           ) ELSE FALSE
    END;

_pg_sv_type_array

Signature: evergreen._pg_sv_type_array(oid[])

Returns: name[]

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT t.typname
          FROM pg_catalog.pg_type t
          JOIN generate_series(1, array_upper($1, 1)) s(i) ON t.oid = $1[i]
         ORDER BY i
    )

_prokind

Signature: evergreen._prokind(p_oid oid)

Returns: "char"

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_version_num() >= 110000 THEN
        RETURN prokind FROM pg_catalog.pg_proc WHERE oid = p_oid;
    ELSE
        RETURN CASE proisagg WHEN true THEN 'a' WHEN false THEN 'f' END
            FROM pg_catalog.pg_proc WHERE oid = p_oid;
    END IF;
END;

_query

Signature: evergreen._query(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE
        WHEN $1 LIKE '"%' OR $1 !~ '[[:space:]]' THEN 'EXECUTE ' || $1
        ELSE $1
    END;

_quote_ident_like

Signature: evergreen._quote_ident_like(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have    TEXT;
    pcision TEXT;
BEGIN
    -- Just return it if rhs isn't quoted.
    IF $2 !~ '"' THEN RETURN $1; END IF;

    -- If it's quoted ident without precision, return it quoted.
    IF $2 ~ '"$' THEN RETURN quote_ident($1); END IF;

    pcision := substring($1 FROM '[(][^")]+[)]$');

    -- Just quote it if thre is no precision.
    if pcision IS NULL THEN RETURN quote_ident($1); END IF;

    -- Quote the non-precision part and concatenate with precision.
    RETURN quote_ident(substring($1 FOR char_length($1) - char_length(pcision)))
        || pcision;
END;

_refine_vol

Signature: evergreen._refine_vol(text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT _expand_vol(substring(LOWER($1) FROM 1 FOR 1)::char);

_relcomp

Signature: evergreen._relcomp(text, anyarray, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _docomp(
        _temptable( $1, '__taphave__' ),
        _temptable( $2, '__tapwant__' ),
        $3, $4
    );

_relcomp

Signature: evergreen._relcomp(text, text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _docomp(
        _temptable( $1, '__taphave__' ),
        _temptable( $2, '__tapwant__' ),
        $3, $4
    );

_relcomp

Signature: evergreen._relcomp(text, text, text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have    TEXT    := _temptable( $1, '__taphave__' );
    want    TEXT    := _temptable( $2, '__tapwant__' );
    results TEXT[]  := '{}';
    res     BOOLEAN := TRUE;
    msg     TEXT    := '';
    rec     RECORD;
BEGIN
    BEGIN
        -- Find relevant records.
        FOR rec in EXECUTE 'SELECT * FROM ' || want || ' ' || $4
                       || ' SELECT * FROM ' || have LOOP
            results := results || rec::text;
        END LOOP;

        -- Drop the temporary tables.
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
    EXCEPTION WHEN syntax_error OR datatype_mismatch THEN
        msg := E'\n' || diag(
            E'    Columns differ between queries:\n'
            || '        have: (' || _temptypes(have) || E')\n'
            || '        want: (' || _temptypes(want) || ')'
        );
        EXECUTE 'DROP TABLE ' || have;
        EXECUTE 'DROP TABLE ' || want;
        RETURN ok(FALSE, $3) || msg;
    END;

    -- What records do we have?
    IF results[1] IS NOT NULL THEN
        res := FALSE;
        msg := msg || E'\n' || diag(
            '    ' || $5 || E' records:\n        '
            ||  array_to_string( results, E'\n        ' )
        );
    END IF;

    RETURN ok(res, $3) || msg;
END;

_relexists

Signature: evergreen._relexists(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_class c
         WHERE pg_catalog.pg_table_is_visible(c.oid)
           AND c.relname = $1
    );

_relexists

Signature: evergreen._relexists(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE n.nspname = $1
           AND c.relname = $2
    );

_relne

Signature: evergreen._relne(text, anyarray, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _do_ne(
        _temptable( $1, '__taphave__' ),
        _temptable( $2, '__tapwant__' ),
        $3, $4
    );

_relne

Signature: evergreen._relne(text, text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _do_ne(
        _temptable( $1, '__taphave__' ),
        _temptable( $2, '__tapwant__' ),
        $3, $4
    );

_returns

Signature: evergreen._returns(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT returns FROM tap_funky WHERE name = $1 AND is_visible;

_returns

Signature: evergreen._returns(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT returns FROM tap_funky WHERE schema = $1 AND name = $2

_returns

Signature: evergreen._returns(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT returns
      FROM tap_funky
     WHERE schema = $1
       AND name   = $2
       AND args   = array_to_string($3, ',')

_returns

Signature: evergreen._returns(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT returns
      FROM tap_funky
     WHERE name = $1
       AND args = array_to_string($2, ',')
       AND is_visible;

_rexists

Signature: evergreen._rexists(character, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT _rexists(ARRAY[$1], $2);

_rexists

Signature: evergreen._rexists(character, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _rexists(ARRAY[$1], $2, $3);

_rexists

Signature: evergreen._rexists(character[], name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_class c
         WHERE c.relkind = ANY($1)
           AND pg_catalog.pg_table_is_visible(c.oid)
           AND c.relname = $2
    );

_rexists

Signature: evergreen._rexists(character[], name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_namespace n
          JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
         WHERE c.relkind = ANY($1)
           AND n.nspname = $2
           AND c.relname = $3
    );

_rule_on

Signature: evergreen._rule_on(name, name)

Returns: "char"

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT r.ev_type
      FROM pg_catalog.pg_rewrite r
      JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
     WHERE r.rulename = $2
       AND c.relname  = $1

_rule_on

Signature: evergreen._rule_on(name, name, name)

Returns: "char"

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT r.ev_type
      FROM pg_catalog.pg_rewrite r
      JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
      JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
     WHERE r.rulename = $3
       AND c.relname  = $2
       AND n.nspname  = $1

_runem

Signature: evergreen._runem(text[], boolean)

Returns: SETOF text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    tap    text;
    lbound int := array_lower($1, 1);
BEGIN
    IF lbound IS NULL THEN RETURN; END IF;
    FOR i IN lbound..array_upper($1, 1) LOOP
        -- Send the name of the function to diag if warranted.
        IF $2 THEN RETURN NEXT diag( $1[i] || '()' ); END IF;
        -- Execute the tap function and return its results.
        FOR tap IN EXECUTE 'SELECT * FROM ' || $1[i] || '()' LOOP
            RETURN NEXT tap;
        END LOOP;
    END LOOP;
    RETURN;
END;

_runner

Signature: evergreen._runner(text[], text[], text[], text[], text[])

Returns: SETOF text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    startup  ALIAS FOR $1;
    shutdown ALIAS FOR $2;
    setup    ALIAS FOR $3;
    teardown ALIAS FOR $4;
    tests    ALIAS FOR $5;
    tap      TEXT;
    tfaild   INTEGER := 0;
    ffaild   INTEGER := 0;
    tnumb    INTEGER := 0;
    fnumb    INTEGER := 0;
    tok      BOOLEAN := TRUE;
BEGIN
    BEGIN
        -- No plan support.
        PERFORM * FROM no_plan();
        FOR tap IN SELECT * FROM _runem(startup, false) LOOP RETURN NEXT tap; END LOOP;
    EXCEPTION
        -- Catch all exceptions and simply rethrow custom exceptions. This
        -- will roll back everything in the above block.
        WHEN raise_exception THEN RAISE EXCEPTION '%', SQLERRM;
    END;

    -- Record how startup tests have failed.
    tfaild := num_failed();

    FOR i IN 1..COALESCE(array_upper(tests, 1), 0) LOOP

        -- What subtest are we running?
        RETURN NEXT '    ' || diag_test_name('Subtest: ' || tests[i]);

        -- Reset the results.
        tok := TRUE;
        tnumb := COALESCE(_get('curr_test'), 0);

        IF tnumb > 0 THEN
            EXECUTE 'ALTER SEQUENCE __tresults___numb_seq RESTART WITH 1';
            PERFORM _set('curr_test', 0);
            PERFORM _set('failed', 0);
        END IF;

        DECLARE
            errstate text;
            errmsg   text;
            detail   text;
            hint     text;
            context  text;
            schname  text;
            tabname  text;
            colname  text;
            chkname  text;
            typname  text;
        BEGIN
            BEGIN
                -- Run the setup functions.
                FOR tap IN SELECT * FROM _runem(setup, false) LOOP
                    RETURN NEXT regexp_replace(tap, '^', '    ', 'gn');
                END LOOP;

                -- Run the actual test function.
                FOR tap IN EXECUTE 'SELECT * FROM ' || tests[i] || '()' LOOP
                    RETURN NEXT regexp_replace(tap, '^', '    ', 'gn');
                END LOOP;

                -- Run the teardown functions.
                FOR tap IN SELECT * FROM _runem(teardown, false) LOOP
                    RETURN NEXT regexp_replace(tap, '^', '    ', 'gn');
                END LOOP;

                -- Emit the plan.
                fnumb := COALESCE(_get('curr_test'), 0);
                RETURN NEXT '    1..' || fnumb;

                -- Emit any error messages.
                IF fnumb = 0 THEN
                    RETURN NEXT '    # No tests run!';
                    tok = false;
                ELSE
                    -- Report failures.
                    ffaild := num_failed();
                    IF ffaild > 0 THEN
                        tok := FALSE;
                        RETURN NEXT '    ' || diag(
                            'Looks like you failed ' || ffaild || ' test' ||
                             CASE tfaild WHEN 1 THEN '' ELSE 's' END
                             || ' of ' || fnumb
                        );
                    END IF;
                END IF;

            EXCEPTION WHEN raise_exception THEN
                -- Something went wrong. Record that fact.
                errstate := SQLSTATE;
                errmsg := SQLERRM;
                GET STACKED DIAGNOSTICS
                    detail  = PG_EXCEPTION_DETAIL,
                    hint    = PG_EXCEPTION_HINT,
                    context = PG_EXCEPTION_CONTEXT,
                    schname = SCHEMA_NAME,
                    tabname = TABLE_NAME,
                    colname = COLUMN_NAME,
                    chkname = CONSTRAINT_NAME,
                    typname = PG_DATATYPE_NAME;
            END;

            -- Always raise an exception to rollback any changes.
            RAISE EXCEPTION '__TAP_ROLLBACK__';

        EXCEPTION WHEN raise_exception THEN
            IF errmsg IS NOT NULL THEN
                -- Something went wrong. Emit the error message.
                tok := FALSE;
               RETURN NEXT regexp_replace( diag('Test died: ' || _error_diag(
                   errstate, errmsg, detail, hint, context, schname, tabname, colname, chkname, typname
               )), '^', '    ', 'gn');
                errmsg := NULL;
            END IF;
        END;

        -- Restore the sequence.
        EXECUTE 'ALTER SEQUENCE __tresults___numb_seq RESTART WITH ' || tnumb + 1;
        PERFORM _set('curr_test', tnumb);
        PERFORM _set('failed', tfaild);

        -- Record this test.
        RETURN NEXT ok(tok, tests[i]);
        IF NOT tok THEN tfaild := tfaild + 1; END IF;

    END LOOP;

    -- Run the shutdown functions.
    FOR tap IN SELECT * FROM _runem(shutdown, false) LOOP RETURN NEXT tap; END LOOP;

    -- Finish up.
    FOR tap IN SELECT * FROM _finish( COALESCE(_get('curr_test'), 0), 0, tfaild ) LOOP
        RETURN NEXT tap;
    END LOOP;

    -- Clean up and return.
    PERFORM _cleanup();
    RETURN;
END;

_set

Signature: evergreen._set(integer, integer)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE 'UPDATE __tcache__ SET value = ' || $2
        || ' WHERE id = ' || $1;
    RETURN $2;
END;

_set

Signature: evergreen._set(text, integer)

Returns: integer

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _set($1, $2, '')

_set

Signature: evergreen._set(text, integer, text)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    rcount integer;
BEGIN
    EXECUTE 'UPDATE __tcache__ SET value = ' || $2
        || CASE WHEN $3 IS NULL THEN '' ELSE ', note = ' || quote_literal($3) END
        || ' WHERE label = ' || quote_literal($1);
    GET DIAGNOSTICS rcount = ROW_COUNT;
    IF rcount = 0 THEN
       RETURN _add( $1, $2, $3 );
    END IF;
    RETURN $2;
END;

_strict

Signature: evergreen._strict(name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_strict FROM tap_funky WHERE name = $1 AND is_visible;

_strict

Signature: evergreen._strict(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_strict FROM tap_funky WHERE schema = $1 AND name = $2

_strict

Signature: evergreen._strict(name, name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_strict
      FROM tap_funky
     WHERE schema = $1
       AND name   = $2
       AND args   = array_to_string($3, ',')

_strict

Signature: evergreen._strict(name, name[])

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_strict
      FROM tap_funky
     WHERE name = $1
       AND args = array_to_string($2, ',')
       AND is_visible;

_table_privs

Signature: evergreen._table_privs()

Returns: name[]

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    pgversion INTEGER := pg_version_num();
BEGIN
    IF pgversion < 80200 THEN RETURN ARRAY[
        'DELETE', 'INSERT', 'REFERENCES', 'RULE', 'SELECT', 'TRIGGER', 'UPDATE'
    ];
    ELSIF pgversion < 80400 THEN RETURN ARRAY[
        'DELETE', 'INSERT', 'REFERENCES', 'SELECT', 'TRIGGER', 'UPDATE'
    ];
    ELSE RETURN ARRAY[
        'DELETE', 'INSERT', 'REFERENCES', 'SELECT', 'TRIGGER', 'TRUNCATE', 'UPDATE'
    ];
    END IF;
END;

_temptable

Signature: evergreen._temptable(anyarray, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    CREATE TEMP TABLE _____coltmp___ AS
    SELECT $1[i]
    FROM generate_series(array_lower($1, 1), array_upper($1, 1)) s(i);
    EXECUTE 'ALTER TABLE _____coltmp___ RENAME TO ' || $2;
    return $2;
END;

_temptable

Signature: evergreen._temptable(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE 'CREATE TEMP TABLE ' || $2 || ' AS ' || _query($1);
    return $2;
END;

_temptypes

Signature: evergreen._temptypes(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT array_to_string(ARRAY(
        SELECT pg_catalog.format_type(a.atttypid, a.atttypmod)
          FROM pg_catalog.pg_attribute a
          JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
         WHERE c.oid = ('pg_temp.' || $1)::pg_catalog.regclass
           AND attnum > 0
           AND NOT attisdropped
         ORDER BY attnum
    ), ',');

_time_trials

Signature: evergreen._time_trials(text, integer, numeric)

Returns: SETOF _time_trial_type

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    query            TEXT := _query($1);
    iterations       ALIAS FOR $2;
    return_percent   ALIAS FOR $3;
    start_time       TEXT;
    act_time         NUMERIC;
    times            NUMERIC[];
    offset_it        INT;
    limit_it         INT;
    offset_percent   NUMERIC;
    a_time	     _time_trial_type;
BEGIN
    -- Execute the query over and over
    FOR i IN 1..iterations LOOP
        start_time := timeofday();
        EXECUTE query;
        -- Store the execution time for the run in an array of times
        times[i] := extract(millisecond from timeofday()::timestamptz - start_time::timestamptz);
    END LOOP;
    offset_percent := (1.0 - return_percent) / 2.0;
    -- Ensure that offset skips the bottom X% of runs, or set it to 0
    SELECT GREATEST((offset_percent * iterations)::int, 0) INTO offset_it;
    -- Ensure that with limit the query to returning only the middle X% of runs
    SELECT GREATEST((return_percent * iterations)::int, 1) INTO limit_it;

    FOR a_time IN SELECT times[i]
		  FROM generate_series(array_lower(times, 1), array_upper(times, 1)) i
                  ORDER BY 1
                  OFFSET offset_it
                  LIMIT limit_it LOOP
	RETURN NEXT a_time;
    END LOOP;
END;

_tlike

Signature: evergreen._tlike(boolean, text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( $1, $4 ) || CASE WHEN $1 THEN '' ELSE E'\n' || diag(
           '   error message: ' || COALESCE( quote_literal($2), 'NULL' ) ||
       E'\n   doesn''t match: ' || COALESCE( quote_literal($3), 'NULL' )
    ) END;

_todo

Signature: evergreen._todo()

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    todos INT[];
    note text;
BEGIN
    -- Get the latest id and value, because todo() might have been called
    -- again before the todos ran out for the first call to todo(). This
    -- allows them to nest.
    todos := _get_latest('todo');
    IF todos IS NULL THEN
        -- No todos.
        RETURN NULL;
    END IF;
    IF todos[2] = 0 THEN
        -- Todos depleted. Clean up.
        EXECUTE 'DELETE FROM __tcache__ WHERE id = ' || todos[1];
        RETURN NULL;
    END IF;
    -- Decrement the count of counted todos and return the reason.
    IF todos[2] <> -1 THEN
        PERFORM _set(todos[1], todos[2] - 1);
    END IF;
    note := _get_note(todos[1]);

    IF todos[2] = 1 THEN
        -- This was the last todo, so delete the record.
        EXECUTE 'DELETE FROM __tcache__ WHERE id = ' || todos[1];
    END IF;

    RETURN note;
END;

_trig

Signature: evergreen._trig(name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_trigger t
          JOIN pg_catalog.pg_class c     ON c.oid = t.tgrelid
         WHERE c.relname = $1
           AND t.tgname  = $2
           AND pg_catalog.pg_table_is_visible(c.oid)
    );

_trig

Signature: evergreen._trig(name, name, name)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT EXISTS(
        SELECT true
          FROM pg_catalog.pg_trigger t
          JOIN pg_catalog.pg_class c     ON c.oid = t.tgrelid
          JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
         WHERE n.nspname = $1
           AND c.relname = $2
           AND t.tgname  = $3
    );

_types_are

Signature: evergreen._types_are(name, name[], text, character[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'types',
        ARRAY(
            SELECT t.typname
              FROM pg_catalog.pg_type t
              LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE (
                     t.typrelid = 0
                 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)
             )
               AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)
               AND n.nspname = $1
               AND t.typtype = ANY( COALESCE($4, ARRAY['b', 'c', 'd', 'p', 'e']) )
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
               FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT t.typname
              FROM pg_catalog.pg_type t
              LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE (
                     t.typrelid = 0
                 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)
             )
               AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)
               AND n.nspname = $1
               AND t.typtype = ANY( COALESCE($4, ARRAY['b', 'c', 'd', 'p', 'e']) )
        ),
        $3
    );

_types_are

Signature: evergreen._types_are(name[], text, character[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'types',
        ARRAY(
            SELECT t.typname
              FROM pg_catalog.pg_type t
              LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE (
                     t.typrelid = 0
                 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)
             )
               AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_type_is_visible(t.oid)
               AND t.typtype = ANY( COALESCE($3, ARRAY['b', 'c', 'd', 'p', 'e']) )
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
               FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT t.typname
              FROM pg_catalog.pg_type t
              LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE (
                     t.typrelid = 0
                 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)
             )
               AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_type_is_visible(t.oid)
               AND t.typtype = ANY( COALESCE($3, ARRAY['b', 'c', 'd', 'p', 'e']) )
        ),
        $2
    );

_unalike

Signature: evergreen._unalike(boolean, anyelement, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    result ALIAS FOR $1;
    got    ALIAS FOR $2;
    rx     ALIAS FOR $3;
    descr  ALIAS FOR $4;
    output TEXT;
BEGIN
    output := ok( result, descr );
    RETURN output || CASE result WHEN TRUE THEN '' ELSE E'\n' || diag(
           '                  ' || COALESCE( quote_literal(got), 'NULL' ) ||
        E'\n         matches: ' || COALESCE( quote_literal(rx), 'NULL' )
    ) END;
END;

_vol

Signature: evergreen._vol(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _expand_vol(volatility) FROM tap_funky f
     WHERE f.name = $1 AND f.is_visible;

_vol

Signature: evergreen._vol(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _expand_vol(volatility) FROM tap_funky f
     WHERE f.schema = $1 and f.name = $2

_vol

Signature: evergreen._vol(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _expand_vol(volatility)
      FROM tap_funky f
     WHERE f.schema = $1
       and f.name   = $2
       AND f.args   = array_to_string($3, ',')

_vol

Signature: evergreen._vol(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _expand_vol(volatility)
      FROM tap_funky f
     WHERE f.name = $1
       AND f.args = array_to_string($2, ',')
       AND f.is_visible;

add_result

Signature: evergreen.add_result(boolean, boolean, text, text, text)

Returns: integer

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT $1 THEN PERFORM _set('failed', _get('failed') + 1); END IF;
    RETURN nextval('__tresults___numb_seq');
END;

alike

Signature: evergreen.alike(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~~ $2, $1, $2, NULL );

alike

Signature: evergreen.alike(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~~ $2, $1, $2, $3 );

any_column_privs_are

Signature: evergreen.any_column_privs_are(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT any_column_privs_are(
        $1, $2, $3, $4,
        'Role ' || quote_ident($3) || ' should be granted '
            || CASE WHEN $4[1] IS NULL THEN 'no privileges' ELSE array_to_string($4, ', ') END
            || ' on any column in '|| quote_ident($1) || '.' || quote_ident($2)
    );

any_column_privs_are

Signature: evergreen.any_column_privs_are(name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_ac_privs( $3, quote_ident($1) || '.' || quote_ident($2) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Role ' || quote_ident($3) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $4, $5);
END;

any_column_privs_are

Signature: evergreen.any_column_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT any_column_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on any column in ' || quote_ident($1)
    );

any_column_privs_are

Signature: evergreen.any_column_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_ac_privs( $2, quote_ident($1) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

array_overlap_check

Signature: evergreen.array_overlap_check()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    fld     TEXT;
    cnt     INT;
BEGIN
    fld := TG_ARGV[0];
    EXECUTE 'SELECT COUNT(*) FROM '|| TG_TABLE_SCHEMA ||'.'|| TG_TABLE_NAME ||' WHERE '|| fld ||' && ($1).'|| fld INTO cnt USING NEW;
    IF cnt > 0 THEN
        RAISE EXCEPTION 'Cannot insert duplicate array into field % of table %', fld, TG_TABLE_SCHEMA ||'.'|| TG_TABLE_NAME;
    END IF;
    RETURN NEW;
END;

asset_copy_alert_copy_inh_fkey

Signature: evergreen.asset_copy_alert_copy_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        PERFORM 1 FROM asset.copy WHERE id = NEW.copy;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, copy:%s$$, NEW.copy
                );
        END IF;
        RETURN NEW;
END;

asset_copy_inventory_copy_inh_fkey

Signature: evergreen.asset_copy_inventory_copy_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        PERFORM 1 FROM asset.copy WHERE id = NEW.copy;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, copy:%s$$, NEW.copy
                );
        END IF;
        RETURN NEW;
END;

asset_copy_note_owning_copy_inh_fkey

Signature: evergreen.asset_copy_note_owning_copy_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        PERFORM 1 FROM asset.copy WHERE id = NEW.owning_copy;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, owning_copy:%s$$, NEW.owning_copy
                );
        END IF;
        RETURN NEW;
END;

asset_copy_tag_copy_map_copy_inh_fkey

Signature: evergreen.asset_copy_tag_copy_map_copy_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        PERFORM 1 FROM asset.copy WHERE id = NEW.copy;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, copy:%s$$, NEW.copy
                );
        END IF;
        RETURN NEW;
END;

bag_eq

Signature: evergreen.bag_eq(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::text, 'ALL ' );

bag_eq

Signature: evergreen.bag_eq(text, anyarray, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'ALL ' );

bag_eq

Signature: evergreen.bag_eq(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::text, 'ALL ' );

bag_eq

Signature: evergreen.bag_eq(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'ALL ' );

bag_has

Signature: evergreen.bag_has(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::TEXT, 'EXCEPT ALL', 'Missing' );

bag_has

Signature: evergreen.bag_has(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'EXCEPT ALL', 'Missing' );

bag_hasnt

Signature: evergreen.bag_hasnt(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::TEXT, 'INTERSECT ALL', 'Extra' );

bag_hasnt

Signature: evergreen.bag_hasnt(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'INTERSECT ALL', 'Extra' );

bag_ne

Signature: evergreen.bag_ne(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, NULL::text, 'ALL ' );

bag_ne

Signature: evergreen.bag_ne(text, anyarray, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, $3, 'ALL ' );

bag_ne

Signature: evergreen.bag_ne(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, NULL::text, 'ALL ' );

bag_ne

Signature: evergreen.bag_ne(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, $3, 'ALL ' );

can

Signature: evergreen.can(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT can( $1, $2, 'Schema ' || quote_ident($1) || ' can' );

can

Signature: evergreen.can(name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    missing text[];
BEGIN
    SELECT ARRAY(
        SELECT quote_ident($2[i])
          FROM generate_series(1, array_upper($2, 1)) s(i)
          LEFT JOIN tap_funky ON name = $2[i] AND schema = $1
         WHERE oid IS NULL
         GROUP BY $2[i], s.i
         ORDER BY MIN(s.i)
    ) INTO missing;
    IF missing[1] IS NULL THEN
        RETURN ok( true, $3 );
    END IF;
    RETURN ok( false, $3 ) || E'\n' || diag(
        '    ' || quote_ident($1) || '.' ||
        array_to_string( missing, E'() missing\n    ' || quote_ident($1) || '.') ||
        '() missing'
    );
END;

can

Signature: evergreen.can(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT can( $1, 'Schema ' || _ident_array_to_string(current_schemas(true), ' or ') || ' can' );

can

Signature: evergreen.can(name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    missing text[];
BEGIN
    SELECT ARRAY(
        SELECT quote_ident($1[i])
          FROM generate_series(1, array_upper($1, 1)) s(i)
          LEFT JOIN pg_catalog.pg_proc p
            ON $1[i] = p.proname
           AND pg_catalog.pg_function_is_visible(p.oid)
         WHERE p.oid IS NULL
         ORDER BY s.i
    ) INTO missing;
    IF missing[1] IS NULL THEN
        RETURN ok( true, $2 );
    END IF;
    RETURN ok( false, $2 ) || E'\n' || diag(
        '    ' ||
        array_to_string( missing, E'() missing\n    ') ||
        '() missing'
    );
END;

can_float

Signature: evergreen.can_float(copy_floating_group integer, from_ou integer, to_ou integer)

Returns: boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    float_member config.floating_group_member%ROWTYPE;
    shared_ou_depth INT;
    to_ou_depth INT;
BEGIN
    -- Grab the shared OU depth. If this is less than the stop depth later we ignore the entry.
    SELECT INTO shared_ou_depth max(depth) FROM actor.org_unit_common_ancestors( from_ou, to_ou ) aou JOIN actor.org_unit_type aout ON aou.ou_type = aout.id;
    -- Grab the to ou depth. If this is greater than max depth we ignore the entry.
    SELECT INTO to_ou_depth depth FROM actor.org_unit aou JOIN actor.org_unit_type aout ON aou.ou_type = aout.id WHERE aou.id = to_ou;
    -- Grab float members that apply. We don't care what we get beyond wanting excluded ones first.
    SELECT INTO float_member *
        FROM
            config.floating_group_member cfgm
            JOIN actor.org_unit aou ON cfgm.org_unit = aou.id
            JOIN actor.org_unit_type aout ON aou.ou_type = aout.id
        WHERE
            cfgm.floating_group = copy_floating_group
            AND to_ou IN (SELECT id FROM actor.org_unit_descendants(aou.id))
            AND cfgm.stop_depth <= shared_ou_depth
            AND (cfgm.max_depth IS NULL OR to_ou_depth <= max_depth)
        ORDER BY
            exclude DESC;
    -- If we found something then we want to return the opposite of the exclude flag
    IF FOUND THEN
        RETURN NOT float_member.exclude;
    END IF;
    -- Otherwise no floating.
    RETURN false;
END;

cast_context_is

Signature: evergreen.cast_context_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT cast_context_is(
        $1, $2, $3,
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') context should be ' || _expand_context(substring(LOWER($3) FROM 1 FOR 1))
    );

cast_context_is

Signature: evergreen.cast_context_is(name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want char = substring(LOWER($3) FROM 1 FOR 1);
    have char := _get_context($1, $2);
BEGIN
    IF have IS NOT NULL THEN
        RETURN is( _expand_context(have), _expand_context(want), $4 );
    END IF;

    RETURN ok( false, $4 ) || E'\n' || diag(
       '    Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
      || ') does not exist'
    );
END;

casts_are

Signature: evergreen.casts_are(text[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT casts_are( $1, 'There should be the correct casts');

casts_are

Signature: evergreen.casts_are(text[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _areni(
        'casts',
        ARRAY(
            SELECT pg_catalog.format_type(castsource, NULL)
                   || ' AS ' || pg_catalog.format_type(casttarget, NULL)
              FROM pg_catalog.pg_cast c
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT pg_catalog.format_type(castsource, NULL)
                   || ' AS ' || pg_catalog.format_type(casttarget, NULL)
              FROM pg_catalog.pg_cast c
        ),
        $2
    );

change_db_setting

Signature: evergreen.change_db_setting(setting_name text, settings text[])

Returns: void

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE 'ALTER DATABASE ' || quote_ident(current_database()) || ' SET ' || quote_ident(setting_name) || ' = ' || array_to_string(settings, ',');
END;

check_test

Signature: evergreen.check_test(text, boolean)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM check_test( $1, $2, NULL, NULL, NULL, FALSE );

check_test

Signature: evergreen.check_test(text, boolean, text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM check_test( $1, $2, $3, NULL, NULL, FALSE );

check_test

Signature: evergreen.check_test(text, boolean, text, text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM check_test( $1, $2, $3, $4, NULL, FALSE );

check_test

Signature: evergreen.check_test(text, boolean, text, text, text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM check_test( $1, $2, $3, $4, $5, FALSE );

check_test

Signature: evergreen.check_test(text, boolean, text, text, text, boolean)

Returns: SETOF text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    tnumb   INTEGER;
    aok     BOOLEAN;
    adescr  TEXT;
    res     BOOLEAN;
    descr   TEXT;
    adiag   TEXT;
    have    ALIAS FOR $1;
    eok     ALIAS FOR $2;
    name    ALIAS FOR $3;
    edescr  ALIAS FOR $4;
    ediag   ALIAS FOR $5;
    matchit ALIAS FOR $6;
BEGIN
    -- What test was it that just ran?
    tnumb := currval('__tresults___numb_seq');

    -- Fetch the results.
    aok    := substring(have, 1, 2) = 'ok';
    adescr := COALESCE(substring(have FROM  E'(?:not )?ok [[:digit:]]+ - ([^\n]+)'), '');

    -- Now delete those results.
    EXECUTE 'ALTER SEQUENCE __tresults___numb_seq RESTART WITH ' || tnumb;
    IF NOT aok THEN PERFORM _set('failed', _get('failed') - 1); END IF;

    -- Set up the description.
    descr := coalesce( name || ' ', 'Test ' ) || 'should ';

    -- So, did the test pass?
    RETURN NEXT is(
        aok,
        eok,
        descr || CASE eok WHEN true then 'pass' ELSE 'fail' END
    );

    -- Was the description as expected?
    IF edescr IS NOT NULL THEN
        RETURN NEXT is(
            adescr,
            edescr,
            descr || 'have the proper description'
        );
    END IF;

    -- Were the diagnostics as expected?
    IF ediag IS NOT NULL THEN
        -- Remove ok and the test number.
        adiag := substring(
            have
            FROM CASE WHEN aok THEN 4 ELSE 9 END + char_length(tnumb::text)
        );

        -- Remove the description, if there is one.
        IF adescr <> '' THEN
            adiag := substring(
                adiag FROM 1 + char_length( ' - ' || substr(diag( adescr ), 3) )
            );
        END IF;

        IF NOT aok THEN
            -- Remove failure message from ok().
            adiag := substring(adiag FROM 1 + char_length(diag(
                'Failed test ' || tnumb ||
                CASE adescr WHEN '' THEN '' ELSE COALESCE(': "' || adescr || '"', '') END
            )));
        END IF;

        IF ediag <> '' THEN
           -- Remove the space before the diagnostics.
           adiag := substring(adiag FROM 2);
        END IF;

        -- Remove the #s.
        adiag := replace( substring(adiag from 3), E'\n# ', E'\n' );

        -- Now compare the diagnostics.
        IF matchit THEN
            RETURN NEXT matches(
                adiag,
                ediag,
                descr || 'have the proper diagnostics'
            );
        ELSE
            RETURN NEXT is(
                adiag,
                ediag,
                descr || 'have the proper diagnostics'
            );
        END IF;
    END IF;

    -- And we're done
    RETURN;
END;

cmp_ok

Signature: evergreen.cmp_ok(anyelement, text, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT cmp_ok( $1, $2, $3, NULL );

cmp_ok

Signature: evergreen.cmp_ok(anyelement, text, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have   ALIAS FOR $1;
    op     ALIAS FOR $2;
    want   ALIAS FOR $3;
    descr  ALIAS FOR $4;
    result BOOLEAN;
    output TEXT;
BEGIN
    EXECUTE 'SELECT ' ||
            COALESCE(quote_literal( have ), 'NULL') || '::' || pg_typeof(have) || ' '
            || op || ' ' ||
            COALESCE(quote_literal( want ), 'NULL') || '::' || pg_typeof(want)
       INTO result;
    output := ok( COALESCE(result, FALSE), descr );
    RETURN output || CASE result WHEN TRUE THEN '' ELSE E'\n' || diag(
           '    ' || COALESCE( quote_literal(have), 'NULL' ) ||
           E'\n        ' || op ||
           E'\n    ' || COALESCE( quote_literal(want), 'NULL' )
    ) END;
END;

coded_value_map_normalizer

Signature: evergreen.coded_value_map_normalizer(input text, ctype text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
        SELECT COALESCE(value,$1)
            FROM config.coded_value_map
            WHERE ctype = $2 AND code = $1;

col_default_is

Signature: evergreen.col_default_is(name, name, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3 );

col_default_is

Signature: evergreen.col_default_is(name, name, anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3, $4 );

col_default_is

Signature: evergreen.col_default_is(name, name, name, anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3, $4, $5 );

col_default_is

Signature: evergreen.col_default_is(name, name, name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3, $4, $5 );

col_default_is

Signature: evergreen.col_default_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3 );

col_default_is

Signature: evergreen.col_default_is(name, name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _cdi( $1, $2, $3, $4 );

col_has_check

Signature: evergreen.col_has_check(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_has_check( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should have a check constraint' );

col_has_check

Signature: evergreen.col_has_check(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_has_check( $1, $2, ARRAY[$3], $4 );

col_has_check

Signature: evergreen.col_has_check(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _constraint( $1, $2, 'c', $3, $4, 'check' );

col_has_check

Signature: evergreen.col_has_check(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_has_check( $1, ARRAY[$2], $3 );

col_has_check

Signature: evergreen.col_has_check(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_has_check( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should have a check constraint' );

col_has_check

Signature: evergreen.col_has_check(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _constraint( $1, 'c', $2, $3, 'check' );

col_has_default

Signature: evergreen.col_has_default(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_has_default( $1, $2, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should have a default' );

col_has_default

Signature: evergreen.col_has_default(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2, $3 ) THEN
        RETURN fail( $4 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3) || ' does not exist' );
    END IF;
    RETURN ok( _has_def( $1, $2, $3 ), $4 );
END

col_has_default

Signature: evergreen.col_has_default(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2 ) THEN
        RETURN fail( $3 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist' );
    END IF;
    RETURN ok( _has_def( $1, $2 ), $3 );
END;

col_hasnt_default

Signature: evergreen.col_hasnt_default(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_hasnt_default( $1, $2, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should not have a default' );

col_hasnt_default

Signature: evergreen.col_hasnt_default(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2, $3 ) THEN
        RETURN fail( $4 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3) || ' does not exist' );
    END IF;
    RETURN ok( NOT _has_def( $1, $2, $3 ), $4 );
END;

col_hasnt_default

Signature: evergreen.col_hasnt_default(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF NOT _cexists( $1, $2 ) THEN
        RETURN fail( $3 ) || E'\n'
            || diag ('    Column ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist' );
    END IF;
    RETURN ok( NOT _has_def( $1, $2 ), $3 );
END;

col_is_fk

Signature: evergreen.col_is_fk(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_fk( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should be a foreign key' );

col_is_fk

Signature: evergreen.col_is_fk(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_fk( $1, $2, ARRAY[$3], $4 );

col_is_fk

Signature: evergreen.col_is_fk(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    names text[];
BEGIN
    IF _fkexists($1, $2, $3) THEN
        RETURN pass( $4 );
    END IF;

    -- Try to show the columns.
    SELECT ARRAY(
        SELECT _ident_array_to_string(fk_columns, ', ')
          FROM pg_all_foreign_keys
         WHERE fk_schema_name = $1
           AND fk_table_name  = $2
         ORDER BY fk_columns
    ) INTO names;

    IF names[1] IS NOT NULL THEN
        RETURN fail($4) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || E' has foreign key constraints on these columns:\n        '
            ||  array_to_string( names, E'\n        ' )
        );
    END IF;

    -- No FKs in this table.
    RETURN fail($4) || E'\n' || diag(
        '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' has no foreign key columns'
    );
END;

col_is_fk

Signature: evergreen.col_is_fk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_fk( $1, ARRAY[$2], $3 );

col_is_fk

Signature: evergreen.col_is_fk(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_fk( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should be a foreign key' );

col_is_fk

Signature: evergreen.col_is_fk(name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    names text[];
BEGIN
    IF _fkexists($1, $2) THEN
        RETURN pass( $3 );
    END IF;

    -- Try to show the columns.
    SELECT ARRAY(
        SELECT _ident_array_to_string(fk_columns, ', ')
          FROM pg_all_foreign_keys
         WHERE fk_table_name  = $1
         ORDER BY fk_columns
    ) INTO names;

    IF NAMES[1] IS NOT NULL THEN
        RETURN fail($3) || E'\n' || diag(
            '    Table ' || quote_ident($1) || E' has foreign key constraints on these columns:\n        '
            || array_to_string( names, E'\n        ' )
        );
    END IF;

    -- No FKs in this table.
    RETURN fail($3) || E'\n' || diag(
        '    Table ' || quote_ident($1) || ' has no foreign key columns'
    );
END;

col_is_null

Signature: evergreen.col_is_null(schema_name name, table_name name, column_name name, description text DEFAULT NULL::text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _col_is_null( $1, $2, $3, $4, false );

col_is_null

Signature: evergreen.col_is_null(table_name name, column_name name, description text DEFAULT NULL::text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _col_is_null( $1, $2, $3, false );

col_is_pk

Signature: evergreen.col_is_pk(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_pk( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should be a primary key' );

col_is_pk

Signature: evergreen.col_is_pk(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_pk( $1, $2, ARRAY[$3], $4 );

col_is_pk

Signature: evergreen.col_is_pk(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is( _ckeys( $1, $2, 'p' ), $3, $4 );

col_is_pk

Signature: evergreen.col_is_pk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_pk( $1, ARRAY[$2], $3 );

col_is_pk

Signature: evergreen.col_is_pk(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_pk( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should be a primary key' );

col_is_pk

Signature: evergreen.col_is_pk(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is( _ckeys( $1, 'p' ), $2, $3 );

col_is_unique

Signature: evergreen.col_is_unique(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should have a unique constraint' );

col_is_unique

Signature: evergreen.col_is_unique(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, $2, ARRAY[$3], 'Column ' || quote_ident($2) || '(' || quote_ident($3) || ') should have a unique constraint' );

col_is_unique

Signature: evergreen.col_is_unique(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, $2, ARRAY[$3], $4 );

col_is_unique

Signature: evergreen.col_is_unique(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, $2, $3, 'Columns ' || quote_ident($2) || '(' || _ident_array_to_string($3, ', ') || ') should have a unique constraint' );

col_is_unique

Signature: evergreen.col_is_unique(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _constraint( $1, $2, 'u', $3, $4, 'unique' );

col_is_unique

Signature: evergreen.col_is_unique(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, ARRAY[$2], $3 );

col_is_unique

Signature: evergreen.col_is_unique(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_is_unique( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should have a unique constraint' );

col_is_unique

Signature: evergreen.col_is_unique(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _constraint( $1, 'u', $2, $3, 'unique' );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_fk( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should not be a foreign key' );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_fk( $1, $2, ARRAY[$3], $4 );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _fkexists( $1, $2, $3 ), $4 );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_fk( $1, ARRAY[$2], $3 );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_fk( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should not be a foreign key' );

col_isnt_fk

Signature: evergreen.col_isnt_fk(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _fkexists( $1, $2 ), $3 );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_pk( $1, $2, 'Column ' || quote_ident($1) || '(' || quote_ident($2) || ') should not be a primary key' );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_pk( $1, $2, ARRAY[$3], $4 );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isnt( _ckeys( $1, $2, 'p' ), $3, $4 );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_pk( $1, ARRAY[$2], $3 );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_isnt_pk( $1, $2, 'Columns ' || quote_ident($1) || '(' || _ident_array_to_string($2, ', ') || ') should not be a primary key' );

col_isnt_pk

Signature: evergreen.col_isnt_pk(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isnt( _ckeys( $1, 'p' ), $2, $3 );

col_not_null

Signature: evergreen.col_not_null(schema_name name, table_name name, column_name name, description text DEFAULT NULL::text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _col_is_null( $1, $2, $3, $4, true );

col_not_null

Signature: evergreen.col_not_null(table_name name, column_name name, description text DEFAULT NULL::text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _col_is_null( $1, $2, $3, true );

col_type_is

Signature: evergreen.col_type_is(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_type_is( $1, $2, $3, $4, $5, 'Column ' || quote_ident($1) || '.' || quote_ident($2)
        || '.' || quote_ident($3) || ' should be type ' || quote_ident($4) || '.' || $5);

col_type_is

Signature: evergreen.col_type_is(name, name, name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have_type TEXT := _get_col_ns_type($1, $2, $3);
    want_type TEXT;
BEGIN
    IF have_type IS NULL THEN
        RETURN fail( $6 ) || E'\n' || diag (
            '   Column ' || COALESCE(quote_ident($1) || '.', '')
            || quote_ident($2) || '.' || quote_ident($3) || ' does not exist'
        );
    END IF;

    want_type := quote_ident($4) || '.' || _quote_ident_like($5, have_type);
    IF have_type = want_type THEN
        -- We're good to go.
        RETURN ok( true, $6 );
    END IF;

    -- Wrong data type. tell 'em what we really got.
    RETURN ok( false, $6 ) || E'\n' || diag(
           '        have: ' || have_type ||
        E'\n        want: ' || want_type
    );
END;

col_type_is

Signature: evergreen.col_type_is(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_type_is( $1, $2, $3, $4, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3) || ' should be type ' || $4 );

col_type_is

Signature: evergreen.col_type_is(name, name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have_type TEXT;
    want_type TEXT;
BEGIN
    -- Get the data type.
    IF $1 IS NULL THEN
        have_type := _get_col_type($2, $3);
    ELSE
        have_type := _get_col_type($1, $2, $3);
    END IF;

    IF have_type IS NULL THEN
        RETURN fail( $5 ) || E'\n' || diag (
            '   Column ' || COALESCE(quote_ident($1) || '.', '')
            || quote_ident($2) || '.' || quote_ident($3) || ' does not exist'
        );
    END IF;

    want_type := _quote_ident_like($4, have_type);
    IF have_type = want_type THEN
        -- We're good to go.
        RETURN ok( true, $5 );
    END IF;

    -- Wrong data type. tell 'em what we really got.
    RETURN ok( false, $5 ) || E'\n' || diag(
           '        have: ' || have_type ||
        E'\n        want: ' || want_type
    );
END;

col_type_is

Signature: evergreen.col_type_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_type_is( $1, $2, $3, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should be type ' || $3 );

col_type_is

Signature: evergreen.col_type_is(name, name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT col_type_is( NULL, $1, $2, $3, $4 );

collect_tap

Signature: evergreen.collect_tap(VARIADIC text[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT array_to_string($1, E'\n');

collect_tap

Signature: evergreen.collect_tap(character varying[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT array_to_string($1, E'\n');

column_privs_are

Signature: evergreen.column_privs_are(name, name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT column_privs_are(
        $1, $2, $3, $4, $5,
        'Role ' || quote_ident($4) || ' should be granted '
            || CASE WHEN $5[1] IS NULL THEN 'no privileges' ELSE array_to_string($5, ', ') END
            || ' on column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3)
    );

column_privs_are

Signature: evergreen.column_privs_are(name, name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_col_privs( $4, quote_ident($1) || '.' || quote_ident($2), $3 );
BEGIN
    IF grants[1] = 'undefined_column' THEN
        RETURN ok(FALSE, $6) || E'\n' || diag(
            '    Column ' || quote_ident($1) || '.' || quote_ident($2) || '.' || quote_ident($3)
            || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $6) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $6) || E'\n' || diag(
            '    Role ' || quote_ident($4) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $5, $6);
END;

column_privs_are

Signature: evergreen.column_privs_are(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT column_privs_are(
        $1, $2, $3, $4,
        'Role ' || quote_ident($3) || ' should be granted '
            || CASE WHEN $4[1] IS NULL THEN 'no privileges' ELSE array_to_string($4, ', ') END
            || ' on column ' || quote_ident($1) || '.' || quote_ident($2)
    );

column_privs_are

Signature: evergreen.column_privs_are(name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_col_privs( $3, quote_ident($1), $2 );
BEGIN
    IF grants[1] = 'undefined_column' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Column ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Table ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Role ' || quote_ident($3) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $4, $5);
END;

columns_are

Signature: evergreen.columns_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT columns_are( $1, $2, $3, 'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct columns' );

columns_are

Signature: evergreen.columns_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'columns',
        ARRAY(
            SELECT a.attname
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE n.nspname = $1
               AND c.relname = $2
               AND a.attnum > 0
               AND NOT a.attisdropped
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT a.attname
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE n.nspname = $1
               AND c.relname = $2
               AND a.attnum > 0
               AND NOT a.attisdropped
        ),
        $4
    );

columns_are

Signature: evergreen.columns_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT columns_are( $1, $2, 'Table ' || quote_ident($1) || ' should have the correct columns' );

columns_are

Signature: evergreen.columns_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'columns',
        ARRAY(
            SELECT a.attname
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_table_is_visible(c.oid)
               AND c.relname = $1
               AND a.attnum > 0
               AND NOT a.attisdropped
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT a.attname
              FROM pg_catalog.pg_namespace n
              JOIN pg_catalog.pg_class c ON n.oid = c.relnamespace
              JOIN pg_catalog.pg_attribute a ON c.oid = a.attrelid
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_table_is_visible(c.oid)
               AND c.relname = $1
               AND a.attnum > 0
               AND NOT a.attisdropped
        ),
        $3
    );

composite_owner_is

Signature: evergreen.composite_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT composite_owner_is(
        $1, $2,
        'Composite type ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

composite_owner_is

Signature: evergreen.composite_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT composite_owner_is(
        $1, $2, $3,
        'Composite type ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

composite_owner_is

Signature: evergreen.composite_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('c'::char, $1, $2);
BEGIN
    -- Make sure the composite exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Composite type ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

composite_owner_is

Signature: evergreen.composite_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('c'::char, $1);
BEGIN
    -- Make sure the composite exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Composite type ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

container_copy_bucket_item_target_copy_inh_fkey

Signature: evergreen.container_copy_bucket_item_target_copy_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        PERFORM 1 FROM asset.copy WHERE id = NEW.target_copy;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, target_copy:%s$$, NEW.target_copy
                );
        END IF;
        RETURN NEW;
END;

could_be_serial_holding_code

Signature: evergreen.could_be_serial_holding_code(text)

Returns: boolean

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

Return true if parameter is valid JSON representing an array that at minimum doesn’t make MARC::Field balk and only has subfield labels exactly one character long. Otherwise false.

    use JSON::XS;
    use MARC::Field;

    eval {
        my $holding_code = (new JSON::XS)->decode(shift);
        new MARC::Field('999', @$holding_code);
    };
    return 0 if $@;
    # verify that subfield labels are exactly one character long
    foreach (keys %{ { @$holding_code } }) {
        return 0 if length($_) != 1;
    }
    return 1;

database_privs_are

Signature: evergreen.database_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT database_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on database ' || quote_ident($1)
    );

database_privs_are

Signature: evergreen.database_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_db_privs( $2, $1::TEXT );
BEGIN
    IF grants[1] = 'invalid_catalog_name' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Database ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

db_owner_is

Signature: evergreen.db_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT db_owner_is(
        $1, $2,
        'Database ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

db_owner_is

Signature: evergreen.db_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    dbowner NAME := _get_db_owner($1);
BEGIN
    -- Make sure the database exists.
    IF dbowner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Database ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(dbowner, $2, $3);
END;

decode_base32

Signature: evergreen.decode_base32(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
  use MIME::Base32;
  my $input = shift;
  return decode_base32($input);

diag

Signature: evergreen.diag(VARIADIC anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT diag(array_to_string($1, ''));

diag

Signature: evergreen.diag(VARIADIC text[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT diag(array_to_string($1, ''));

diag

Signature: evergreen.diag(msg anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT diag($1::text);

diag

Signature: evergreen.diag(msg text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT '# ' || replace(
       replace(
            replace( $1, E'\r\n', E'\n# ' ),
            E'\n',
            E'\n# '
        ),
        E'\r',
        E'\n# '
    );

diag_test_name

Signature: evergreen.diag_test_name(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT diag($1 || '()');

direct_opt_in_check

Signature: evergreen.direct_opt_in_check(patron_id integer, staff_id integer, permlist text[] DEFAULT '{}'::text[])

Returns: boolean

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    default_boundary    INT;
    org_depth           INT;
    patron              actor.usr%ROWTYPE;
    staff               actor.usr%ROWTYPE;
    patron_visible_at   INT[];
    patron_hard_wall    INT[];
    staff_orgs          INT[];
    current_staff_org   INT;
    passed_optin        BOOL;
BEGIN
    passed_optin := FALSE;

    SELECT * INTO patron FROM actor.usr WHERE id = patron_id;
    SELECT * INTO staff FROM actor.usr WHERE id = staff_id;

    IF patron.id IS NULL OR staff.id IS NULL THEN
        RETURN FALSE;
    END IF;

    -- get the hard wall, if any
    SELECT oils_json_to_text(value)::INT INTO default_boundary
      FROM actor.org_unit_ancestor_setting('org.restrict_opt_to_depth', patron.home_ou);

    IF default_boundary IS NULL THEN default_boundary := 0; END IF;

    IF default_boundary = 0 THEN -- common case
        SELECT ARRAY_AGG(id) INTO patron_hard_wall FROM actor.org_unit;
    ELSE
        -- Patron opt-in scope(s), including home_ou from default_boundary depth
        SELECT  ARRAY_AGG(id) INTO patron_hard_wall
          FROM  actor.org_unit_descendants(patron.home_ou, default_boundary);
    END IF;

    -- gather where the patron has opted in, and their home
    SELECT  COALESCE(ARRAY_AGG(DISTINCT aoud.id),'{}') INTO patron_visible_at
      FROM  actor.usr_org_unit_opt_in auoi
            JOIN LATERAL actor.org_unit_descendants(auoi.org_unit) aoud ON TRUE
      WHERE auoi.usr = patron.id;

    patron_visible_at := patron_visible_at || patron.home_ou;

    <<staff_org_loop>>
    FOR current_staff_org IN SELECT work_ou FROM permission.usr_work_ou_map WHERE usr = staff.id LOOP

        SELECT oils_json_to_text(value)::INT INTO org_depth
          FROM actor.org_unit_ancestor_setting('org.patron_opt_boundary', current_staff_org);

        IF FOUND THEN
            SELECT ARRAY_AGG(DISTINCT id) INTO staff_orgs FROM actor.org_unit_descendants(current_staff_org,org_depth);
        ELSE
            SELECT ARRAY_AGG(DISTINCT id) INTO staff_orgs FROM actor.org_unit_descendants(current_staff_org);
        END IF;

        -- If this staff org (adjusted) isn't at least partly inside the allowed range, move on.
        IF NOT (staff_orgs && patron_hard_wall) THEN CONTINUE staff_org_loop; END IF;

        -- If this staff org (adjusted) overlaps with the patron visibility list
        IF staff_orgs && patron_visible_at THEN passed_optin := TRUE; EXIT staff_org_loop; END IF;

    END LOOP staff_org_loop;

    -- does the staff member have a requested permission where the patron lives or has opted in?
    IF passed_optin AND cardinality(permlist) > 0 THEN
        SELECT  ARRAY_AGG(id) INTO staff_orgs
          FROM  UNNEST(permlist) perms (p)
                JOIN LATERAL permission.usr_has_perm_at_all(staff.id, perms.p) perms_at (id) ON TRUE;

        passed_optin := COALESCE(staff_orgs && patron_visible_at, FALSE);
    END IF;

    RETURN passed_optin;

END;

display_field_force_nfc

Signature: evergreen.display_field_force_nfc()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    NEW.value := force_unicode_normal_form(NEW.value,'NFC');
    RETURN NEW;
END;

display_oper

Signature: evergreen.display_oper(name, oid)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT $1 || substring($2::regoperator::text, '[(][^)]+[)]$')

do_tap

Signature: evergreen.do_tap()

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runem( findfuncs('^test'), _is_verbose());

do_tap

Signature: evergreen.do_tap(name)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runem( findfuncs($1, '^test'), _is_verbose() );

do_tap

Signature: evergreen.do_tap(name, text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runem( findfuncs($1, $2), _is_verbose() );

do_tap

Signature: evergreen.do_tap(text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runem( findfuncs($1), _is_verbose() );

doesnt_imatch

Signature: evergreen.doesnt_imatch(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~* $2, $1, $2, NULL );

doesnt_imatch

Signature: evergreen.doesnt_imatch(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~* $2, $1, $2, $3 );

doesnt_match

Signature: evergreen.doesnt_match(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~ $2, $1, $2, NULL );

doesnt_match

Signature: evergreen.doesnt_match(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~ $2, $1, $2, $3 );

domain_type_is

Signature: evergreen.domain_type_is(name, text, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_is(
        $1, $2, $3, $4,
        'Domain ' || quote_ident($1) || '.' || $2
        || ' should extend type ' || quote_ident($3) || '.' || $4
    );

domain_type_is

Signature: evergreen.domain_type_is(name, text, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1, $2, true);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $5 ) || E'\n' || diag (
            '   Domain ' || quote_ident($1) || '.' || $2
            || ' does not exist'
        );
    END IF;

    RETURN is( actual_type, quote_ident($3) || '.' || _quote_ident_like($4, actual_type), $5 );
END;

domain_type_is

Signature: evergreen.domain_type_is(name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_is(
        $1, $2, $3,
        'Domain ' || quote_ident($1) || '.' || $2
        || ' should extend type ' || $3
    );

domain_type_is

Signature: evergreen.domain_type_is(name, text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1, $2, false);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $4 ) || E'\n' || diag (
            '   Domain ' || quote_ident($1) || '.' || $2
            || ' does not exist'
        );
    END IF;

    RETURN is( actual_type, _quote_ident_like($3, actual_type), $4 );
END;

domain_type_is

Signature: evergreen.domain_type_is(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_is(
        $1, $2,
        'Domain ' || $1 || ' should extend type ' || $2
    );

domain_type_is

Signature: evergreen.domain_type_is(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $3 ) || E'\n' || diag (
            '   Domain ' ||  $1 || ' does not exist'
        );
    END IF;

    RETURN is( actual_type, _quote_ident_like($2, actual_type), $3 );
END;

domain_type_isnt

Signature: evergreen.domain_type_isnt(name, text, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_isnt(
        $1, $2, $3, $4,
        'Domain ' || quote_ident($1) || '.' || $2
        || ' should not extend type ' || quote_ident($3) || '.' || $4
    );

domain_type_isnt

Signature: evergreen.domain_type_isnt(name, text, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1, $2, true);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $5 ) || E'\n' || diag (
            '   Domain ' || quote_ident($1) || '.' || $2
            || ' does not exist'
        );
    END IF;

    RETURN isnt( actual_type, quote_ident($3) || '.' || _quote_ident_like($4, actual_type), $5 );
END;

domain_type_isnt

Signature: evergreen.domain_type_isnt(name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_isnt(
        $1, $2, $3,
        'Domain ' || quote_ident($1) || '.' || $2
        || ' should not extend type ' || $3
    );

domain_type_isnt

Signature: evergreen.domain_type_isnt(name, text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1, $2, false);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $4 ) || E'\n' || diag (
            '   Domain ' || quote_ident($1) || '.' || $2
            || ' does not exist'
        );
    END IF;

    RETURN isnt( actual_type, _quote_ident_like($3, actual_type), $4 );
END;

domain_type_isnt

Signature: evergreen.domain_type_isnt(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT domain_type_isnt(
        $1, $2,
        'Domain ' || $1 || ' should not extend type ' || $2
    );

domain_type_isnt

Signature: evergreen.domain_type_isnt(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    actual_type TEXT := _get_dtype($1);
BEGIN
    IF actual_type IS NULL THEN
        RETURN fail( $3 ) || E'\n' || diag (
            '   Domain ' ||  $1 || ' does not exist'
        );
    END IF;

    RETURN isnt( actual_type, _quote_ident_like($2, actual_type), $3 );
END;

domains_are

Signature: evergreen.domains_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, 'Schema ' || quote_ident($1) || ' should have the correct domains', ARRAY['d'] );

domains_are

Signature: evergreen.domains_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, $3, ARRAY['d'] );

domains_are

Signature: evergreen.domains_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, 'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct domains', ARRAY['d'] );

domains_are

Signature: evergreen.domains_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, ARRAY['d'] );

encode_base32

Signature: evergreen.encode_base32(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
  use MIME::Base32;
  my $input = shift;
  return encode_base32($input);

enum_has_labels

Signature: evergreen.enum_has_labels(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT enum_has_labels(
        $1, $2, $3,
        'Enum ' || quote_ident($1) || '.' || quote_ident($2) || ' should have labels (' || array_to_string( $3, ', ' ) || ')'
    );

enum_has_labels

Signature: evergreen.enum_has_labels(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is(
        ARRAY(
            SELECT e.enumlabel
              FROM pg_catalog.pg_type t
              JOIN pg_catalog.pg_enum e      ON t.oid = e.enumtypid
              JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid
              WHERE t.typisdefined
               AND n.nspname = $1
               AND t.typname = $2
               AND t.typtype = 'e'
             ORDER BY e.enumsortorder
        ),
        $3,
        $4
    );

enum_has_labels

Signature: evergreen.enum_has_labels(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT enum_has_labels(
        $1, $2,
        'Enum ' || quote_ident($1) || ' should have labels (' || array_to_string( $2, ', ' ) || ')'
    );

enum_has_labels

Signature: evergreen.enum_has_labels(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is(
        ARRAY(
            SELECT e.enumlabel
              FROM pg_catalog.pg_type t
              JOIN pg_catalog.pg_enum e ON t.oid = e.enumtypid
              WHERE t.typisdefined
               AND pg_catalog.pg_type_is_visible(t.oid)
               AND t.typname = $1
               AND t.typtype = 'e'
             ORDER BY e.enumsortorder
        ),
        $2,
        $3
    );

enums_are

Signature: evergreen.enums_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, 'Schema ' || quote_ident($1) || ' should have the correct enums', ARRAY['e'] );

enums_are

Signature: evergreen.enums_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, $3, ARRAY['e'] );

enums_are

Signature: evergreen.enums_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, 'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct enums', ARRAY['e'] );

enums_are

Signature: evergreen.enums_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, ARRAY['e'] );

escape_for_html

Signature: evergreen.escape_for_html(text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT  regexp_replace(
                regexp_replace(
                    regexp_replace(
                        $1,
                        '&',
                        '&amp;',
                        'g'
                    ),
                    '<',
                    '&lt;',
                    'g'
                ),
                '>',
                '&gt;',
                'g'
            );

extensions_are

Signature: evergreen.extensions_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
  SELECT extensions_are(
        $1, $2,
        'Schema ' || quote_ident($1) || ' should have the correct extensions'
    );

extensions_are

Signature: evergreen.extensions_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'extensions',
        ARRAY(SELECT _extensions($1) EXCEPT SELECT unnest($2)),
        ARRAY(SELECT unnest($2) EXCEPT SELECT _extensions($1)),
        $3
    );

extensions_are

Signature: evergreen.extensions_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
  SELECT extensions_are($1, 'Should have the correct extensions');

extensions_are

Signature: evergreen.extensions_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'extensions',
        ARRAY(SELECT _extensions() EXCEPT SELECT unnest($1)),
        ARRAY(SELECT unnest($1) EXCEPT SELECT _extensions()),
        $2
    );

extract_marc_field

Signature: evergreen.extract_marc_field(text, bigint, text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT extract_marc_field($1,$2,$3,'');

extract_marc_field

Signature: evergreen.extract_marc_field(text, bigint, text, text)

Returns: text

Language

plpgsql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
DECLARE
    query TEXT;
    output TEXT;
BEGIN
    query := $q$
        SELECT  regexp_replace(
                    oils_xpath_string(
                        $q$ || quote_literal($3) || $q$,
                        marc,
                        ' '
                    ),
                    $q$ || quote_literal($4) || $q$,
                    '',
                    'g')
          FROM  $q$ || $1 || $q$
          WHERE id = $q$ || $2;

    EXECUTE query INTO output;

    -- RAISE NOTICE 'query: %, output; %', query, output;

    RETURN output;
END;

extract_marc_field_set

Signature: evergreen.extract_marc_field_set(text, bigint, text, text)

Returns: SETOF text

Language

plpgsql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
DECLARE
    query TEXT;
    output TEXT;
BEGIN
    FOR output IN
        SELECT x.t FROM (
            SELECT id,t
                FROM  oils_xpath_table(
                    'id', 'marc', $1, $3, 'id = ' || $2)
                AS t(id int, t text))x
        LOOP
        IF $4 IS NOT NULL THEN
            SELECT INTO output (SELECT regexp_replace(output, $4, '', 'g'));
        END IF;
        RETURN NEXT output;
    END LOOP;
    RETURN;
END;

facet_force_nfc

Signature: evergreen.facet_force_nfc()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    NEW.value := force_unicode_normal_form(NEW.value,'NFC');
    RETURN NEW;
END;

fail

Signature: evergreen.fail()

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( FALSE, NULL );

fail

Signature: evergreen.fail(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( FALSE, $1 );

fake_fkey_tgr

Signature: evergreen.fake_fkey_tgr()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    copy_id BIGINT;
BEGIN
    EXECUTE 'SELECT ($1).' || quote_ident(TG_ARGV[0]) INTO copy_id USING NEW;
    IF copy_id IS NOT NULL THEN
        PERFORM * FROM asset.copy WHERE id = copy_id;
        IF NOT FOUND THEN
            RAISE EXCEPTION 'Key (%.%=%) does not exist in asset.copy', TG_TABLE_SCHEMA, TG_TABLE_NAME, copy_id;
        END IF;
    END IF;
    RETURN NULL;
END;

fdw_privs_are

Signature: evergreen.fdw_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fdw_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on FDW ' || quote_ident($1)
    );

fdw_privs_are

Signature: evergreen.fdw_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_fdw_privs( $2, $1::TEXT );
BEGIN
    IF grants[1] = 'undefined_fdw' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    FDW ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

find_next_open_time

Signature: evergreen.find_next_open_time(circ_lib integer, initial timestamp with time zone, hourly boolean DEFAULT false, initial_time time without time zone DEFAULT NULL::time without time zone, has_hoo boolean DEFAULT true)

Returns: timestamp with time zone

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    day_number      INT;
    plus_days       INT;
    final_time      TEXT;
    time_adjusted   BOOL;
    hoo_open        TIME WITHOUT TIME ZONE;
    hoo_close       TIME WITHOUT TIME ZONE;
    adjacent        actor.org_unit_closed%ROWTYPE;
    breakout        INT := 0;
BEGIN

    IF initial_time IS NULL THEN
        initial_time := initial::TIME;
    END IF;

    final_time := (initial + '1 second'::INTERVAL)::TEXT;
    LOOP
        breakout := breakout + 1;

        time_adjusted := FALSE;

        IF has_hoo THEN -- Don't check hours if they have no hoo. I think the behavior in that case is that we act like they're always open? Better than making things due in 2 years.
                        -- Don't expect anyone to call this with it set to false; it's just for our own recursive use.
            day_number := EXTRACT(ISODOW FROM final_time::TIMESTAMPTZ) - 1; --Get which day of the week  it is from which it started on.
            plus_days := 0;
            has_hoo := FALSE; -- set has_hoo to false to check if any days are open (for the first recursion where it's always true)
            FOR i IN 1..7 LOOP
                EXECUTE 'SELECT dow_' || day_number || '_open, dow_' || day_number || '_close FROM actor.hours_of_operation WHERE id = $1'
                    INTO hoo_open, hoo_close
                    USING circ_lib;

                -- RAISE NOTICE 'initial time: %; dow: %; close: %',initial_time,day_number,hoo_close;

                IF hoo_close = '00:00:00' THEN -- bah ... I guess we'll check the next day
                    day_number := (day_number + 1) % 7;
                    plus_days := plus_days + 1;
                    time_adjusted := TRUE;
                    CONTINUE;
                ELSE
                    has_hoo := TRUE; --We do have hours open sometimes, yay!
                END IF;

                IF hoo_close IS NULL THEN -- no hours of operation ... assume no closing?
                    hoo_close := '23:59:59';
                END IF;

                EXIT;
            END LOOP;

            IF NOT has_hoo THEN -- If always closed then forget the extra days - just determine based on closures.
                plus_days := 0;
            END IF;

            final_time := DATE(final_time::TIMESTAMPTZ + (plus_days || ' days')::INTERVAL)::TEXT;
            IF hoo_close <> '00:00:00' AND hourly THEN -- Not a day-granular circ
                final_time := final_time||' '|| hoo_close;
            ELSE
                final_time := final_time||' 23:59:59';
            END IF;
        END IF;

        --RAISE NOTICE 'final_time: %',final_time;

        -- Loop through other closings
        LOOP
            SELECT * INTO adjacent FROM actor.org_unit_closed WHERE org_unit = circ_lib AND final_time::TIMESTAMPTZ between close_start AND close_end;
            EXIT WHEN adjacent.id IS NULL;
            time_adjusted := TRUE;
            -- RAISE NOTICE 'recursing for closings with final_time: %',final_time;
            final_time := evergreen.find_next_open_time(circ_lib, adjacent.close_end::TIMESTAMPTZ, hourly, initial_time, has_hoo)::TEXT;
        END LOOP;

        EXIT WHEN breakout > 100;
        EXIT WHEN NOT time_adjusted;

    END LOOP;

    RETURN final_time;
END;

findfuncs

Signature: evergreen.findfuncs(name, text)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT findfuncs( $1, $2, NULL )

findfuncs

Signature: evergreen.findfuncs(name, text, text)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT DISTINCT (quote_ident(n.nspname) || '.' || quote_ident(p.proname)) COLLATE "C" AS pname
          FROM pg_catalog.pg_proc p
          JOIN pg_catalog.pg_namespace n ON p.pronamespace = n.oid
         WHERE n.nspname = $1
           AND p.proname ~ $2
           AND ($3 IS NULL OR p.proname !~ $3)
         ORDER BY pname
    );

findfuncs

Signature: evergreen.findfuncs(text)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT findfuncs( $1, NULL )

findfuncs

Signature: evergreen.findfuncs(text, text)

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ARRAY(
        SELECT DISTINCT (quote_ident(n.nspname) || '.' || quote_ident(p.proname)) COLLATE "C" AS pname
          FROM pg_catalog.pg_proc p
          JOIN pg_catalog.pg_namespace n ON p.pronamespace = n.oid
         WHERE pg_catalog.pg_function_is_visible(p.oid)
           AND p.proname ~ $1
           AND ($2 IS NULL OR p.proname !~ $2)
         ORDER BY pname
    );

finish

Signature: evergreen.finish(exception_on_failure boolean DEFAULT NULL::boolean)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _finish(
        _get('curr_test'),
        _get('plan'),
        num_failed(),
        $1
    );

fk_ok

Signature: evergreen.fk_ok(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, ARRAY[$2], $3, ARRAY[$4] );

fk_ok

Signature: evergreen.fk_ok(name, name, name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, $2, ARRAY[$3], $4, $5, ARRAY[$6], $7 );

fk_ok

Signature: evergreen.fk_ok(name, name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, $2, ARRAY[$3], $4, $5, ARRAY[$6] );

fk_ok

Signature: evergreen.fk_ok(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, ARRAY[$2], $3, ARRAY[$4], $5 );

fk_ok

Signature: evergreen.fk_ok(name, name, name[], name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, $2, $3, $4, $5, $6,
        quote_ident($1) || '.' || quote_ident($2) || '(' || _ident_array_to_string( $3, ', ' )
        || ') should reference ' ||
        $4 || '.' || $5 || '(' || _ident_array_to_string( $6, ', ' ) || ')'
    );

fk_ok

Signature: evergreen.fk_ok(name, name, name[], name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    sch  name;
    tab  name;
    cols name[];
BEGIN
    SELECT pk_schema_name, pk_table_name, pk_columns
      FROM pg_all_foreign_keys
      WHERE fk_schema_name = $1
        AND fk_table_name  = $2
        AND fk_columns     = $3
      INTO sch, tab, cols;

    RETURN is(
        -- have
        quote_ident($1) || '.' || quote_ident($2) || '(' || _ident_array_to_string( $3, ', ' )
        || ') REFERENCES ' || COALESCE ( sch || '.' || tab || '(' || _ident_array_to_string( cols, ', ' ) || ')', 'NOTHING' ),
        -- want
        quote_ident($1) || '.' || quote_ident($2) || '(' || _ident_array_to_string( $3, ', ' )
        || ') REFERENCES ' ||
        $4 || '.' || $5 || '(' || _ident_array_to_string( $6, ', ' ) || ')',
        $7
    );
END;

fk_ok

Signature: evergreen.fk_ok(name, name[], name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT fk_ok( $1, $2, $3, $4,
        $1 || '(' || _ident_array_to_string( $2, ', ' )
        || ') should reference ' ||
        $3 || '(' || _ident_array_to_string( $4, ', ' ) || ')'
    );

fk_ok

Signature: evergreen.fk_ok(name, name[], name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    tab  name;
    cols name[];
BEGIN
    SELECT pk_table_name, pk_columns
      FROM pg_all_foreign_keys
     WHERE fk_table_name = $1
       AND fk_columns    = $2
       AND pg_catalog.pg_table_is_visible(fk_table_oid)
      INTO tab, cols;

    RETURN is(
        -- have
        $1 || '(' || _ident_array_to_string( $2, ', ' )
        || ') REFERENCES ' || COALESCE( tab || '(' || _ident_array_to_string( cols, ', ' ) || ')', 'NOTHING'),
        -- want
        $1 || '(' || _ident_array_to_string( $2, ', ' )
        || ') REFERENCES ' ||
        $3 || '(' || _ident_array_to_string( $4, ', ' ) || ')',
        $5
    );
END;

force_unicode_normal_form

Signature: evergreen.force_unicode_normal_form(string text, form text)

Returns: text

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
use Unicode::Normalize 'normalize';
return normalize($_[1],$_[0]); # reverse the params

foreign_table_owner_is

Signature: evergreen.foreign_table_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT foreign_table_owner_is(
        $1, $2,
        'Foreign table ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

foreign_table_owner_is

Signature: evergreen.foreign_table_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT foreign_table_owner_is(
        $1, $2, $3,
        'Foreign table ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

foreign_table_owner_is

Signature: evergreen.foreign_table_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('f'::char, $1, $2);
BEGIN
    -- Make sure the table exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Foreign table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

foreign_table_owner_is

Signature: evergreen.foreign_table_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('f'::char, $1);
BEGIN
    -- Make sure the table exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Foreign table ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

foreign_tables_are

Signature: evergreen.foreign_tables_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'foreign tables', _extras('f', $1, $2), _missing('f', $1, $2),
        'Schema ' || quote_ident($1) || ' should have the correct foreign tables'
    );

foreign_tables_are

Signature: evergreen.foreign_tables_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'foreign tables', _extras('f', $1, $2), _missing('f', $1, $2), $3);

foreign_tables_are

Signature: evergreen.foreign_tables_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'foreign tables', _extras('f', $1), _missing('f', $1),
        'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct foreign tables'
    );

foreign_tables_are

Signature: evergreen.foreign_tables_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'foreign tables', _extras('f', $1), _missing('f', $1), $2);

function_lang_is

Signature: evergreen.function_lang_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_lang_is(
        $1, $2,
        'Function ' || quote_ident($1)
        || '() should be written in ' || quote_ident($2)
    );

function_lang_is

Signature: evergreen.function_lang_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_lang_is(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '.' || quote_ident($2)
        || '() should be written in ' || quote_ident($3)
    );

function_lang_is

Signature: evergreen.function_lang_is(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _lang($1, $2), $3, $4 );

function_lang_is

Signature: evergreen.function_lang_is(name, name, name[], name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_lang_is(
        $1, $2, $3, $4,
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be written in ' || quote_ident($4)
    );

function_lang_is

Signature: evergreen.function_lang_is(name, name, name[], name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _lang($1, $2, $3), $4, $5 );

function_lang_is

Signature: evergreen.function_lang_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _lang($1), $2, $3 );

function_lang_is

Signature: evergreen.function_lang_is(name, name[], name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_lang_is(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be written in ' || quote_ident($3)
    );

function_lang_is

Signature: evergreen.function_lang_is(name, name[], name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _lang($1, $2), $3, $4 );

function_owner_is

Signature: evergreen.function_owner_is(name, name, name[], name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_owner_is(
        $1, $2, $3, $4,
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be owned by ' || quote_ident($4)
    );

function_owner_is

Signature: evergreen.function_owner_is(name, name, name[], name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_func_owner($1, $2, $3);
BEGIN
    -- Make sure the function exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            E'    Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
                    array_to_string($3, ', ') || ') does not exist'
        );
    END IF;

    RETURN is(owner, $4, $5);
END;

function_owner_is

Signature: evergreen.function_owner_is(name, name[], name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_owner_is(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be owned by ' || quote_ident($3)
    );

function_owner_is

Signature: evergreen.function_owner_is(name, name[], name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_func_owner($1, $2);
BEGIN
    -- Make sure the function exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Function ' || quote_ident($1) || '(' ||
                    array_to_string($2, ', ') || ') does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

function_privs_are

Signature: evergreen.function_privs_are(name, name, name[], name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_privs_are(
        $1, $2, $3, $4, $5,
        'Role ' || quote_ident($4) || ' should be granted '
            || CASE WHEN $5[1] IS NULL THEN 'no privileges' ELSE array_to_string($5, ', ') END
            || ' on function ' || quote_ident($1) || '.' || quote_ident($2)
            || '(' || array_to_string($3, ', ') || ')'
    );

function_privs_are

Signature: evergreen.function_privs_are(name, name, name[], name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _fprivs_are(
        quote_ident($1) || '.' || quote_ident($2) || '(' || array_to_string($3, ', ') || ')',
        $4, $5, $6
    );

function_privs_are

Signature: evergreen.function_privs_are(name, name[], name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_privs_are(
        $1, $2, $3, $4,
        'Role ' || quote_ident($3) || ' should be granted '
            || CASE WHEN $4[1] IS NULL THEN 'no privileges' ELSE array_to_string($4, ', ') END
            || ' on function ' || quote_ident($1) || '(' || array_to_string($2, ', ') || ')'
    );

function_privs_are

Signature: evergreen.function_privs_are(name, name[], name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _fprivs_are(
        quote_ident($1) || '(' || array_to_string($2, ', ') || ')',
        $3, $4, $5
    );

function_returns

Signature: evergreen.function_returns(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_returns(
        $1, $2, $3, $4,
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should return ' || $4
    );

function_returns

Signature: evergreen.function_returns(name, name, name[], text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _returns($1, $2, $3), $4, $5 );

function_returns

Signature: evergreen.function_returns(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_returns(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '.' || quote_ident($2)
        || '() should return ' || $3
    );

function_returns

Signature: evergreen.function_returns(name, name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _returns($1, $2), $3, $4 );

function_returns

Signature: evergreen.function_returns(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_returns(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should return ' || $3
    );

function_returns

Signature: evergreen.function_returns(name, name[], text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _returns($1, $2), $3, $4 );

function_returns

Signature: evergreen.function_returns(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT function_returns(
        $1, $2,
        'Function ' || quote_ident($1) || '() should return ' || $2
    );

function_returns

Signature: evergreen.function_returns(name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _returns($1), $2, $3 );

functions_are

Signature: evergreen.functions_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT functions_are( $1, $2, 'Schema ' || quote_ident($1) || ' should have the correct functions' );

functions_are

Signature: evergreen.functions_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'functions',
        ARRAY(
            SELECT name FROM tap_funky WHERE schema = $1
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
               FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT name FROM tap_funky WHERE schema = $1
        ),
        $3
    );

functions_are

Signature: evergreen.functions_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT functions_are( $1, 'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct functions' );

functions_are

Signature: evergreen.functions_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'functions',
        ARRAY(
            SELECT name FROM tap_funky WHERE is_visible
            AND schema NOT IN ('pg_catalog', 'information_schema')
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
               FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT name FROM tap_funky WHERE is_visible
            AND schema NOT IN ('pg_catalog', 'information_schema')
        ),
        $2
    );

gen_random_bytes_b64

Signature: evergreen.gen_random_bytes_b64(integer)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT encode(gen_random_bytes($1),'base64');

generic_map_normalizer

Signature: evergreen.generic_map_normalizer(text, text)

Returns: text

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
my $string = shift;
my %map;

my $default = $string;

$_ = shift;
while (/^\s*?(.*?)\s*?=>\s*?(\S+)\s*/) {
    if ($1 eq '') {
        $default = $2;
    } else {
        $map{$2} = [split(/\s*,\s*/, $1)];
    }
    $_ = $';
}

for my $key ( keys %map ) {
    return $key if (grep { $_ eq $string } @{ $map{$key} });
}

return $default;

get_barcodes

Signature: evergreen.get_barcodes(select_ou integer, type text, in_barcode text)

Returns: SETOF barcode_set

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

Given user input, find an appropriate barcode in the proper class.

Will add prefix/suffix information to do so, and return all results.

DECLARE
    cur_barcode TEXT;
    barcode_len INT;
    completion_len  INT;
    asset_barcodes  TEXT[];
    actor_barcodes  TEXT[];
    do_asset    BOOL = false;
    do_serial   BOOL = false;
    do_booking  BOOL = false;
    do_actor    BOOL = false;
    completion_set  config.barcode_completion%ROWTYPE;
BEGIN

    IF position('asset' in type) > 0 THEN
        do_asset = true;
    END IF;
    IF position('serial' in type) > 0 THEN
        do_serial = true;
    END IF;
    IF position('booking' in type) > 0 THEN
        do_booking = true;
    END IF;
    IF do_asset OR do_serial OR do_booking THEN
        asset_barcodes = asset_barcodes || in_barcode;
    END IF;
    IF position('actor' in type) > 0 THEN
        do_actor = true;
        actor_barcodes = actor_barcodes || in_barcode;
    END IF;

    barcode_len := length(in_barcode);

    FOR completion_set IN
      SELECT * FROM config.barcode_completion
        WHERE active
        AND org_unit IN (SELECT aou.id FROM actor.org_unit_ancestors(select_ou) aou)
        LOOP
        IF completion_set.prefix IS NULL THEN
            completion_set.prefix := '';
        END IF;
        IF completion_set.suffix IS NULL THEN
            completion_set.suffix := '';
        END IF;
        IF completion_set.length = 0 OR completion_set.padding IS NULL OR length(completion_set.padding) = 0 THEN
            cur_barcode = completion_set.prefix || in_barcode || completion_set.suffix;
        ELSE
            completion_len = completion_set.length - length(completion_set.prefix) - length(completion_set.suffix);
            IF completion_len >= barcode_len THEN
                IF completion_set.padding_end THEN
                    cur_barcode = rpad(in_barcode, completion_len, completion_set.padding);
                ELSE
                    cur_barcode = lpad(in_barcode, completion_len, completion_set.padding);
                END IF;
                cur_barcode = completion_set.prefix || cur_barcode || completion_set.suffix;
            END IF;
        END IF;
        IF completion_set.actor THEN
            actor_barcodes = actor_barcodes || cur_barcode;
        END IF;
        IF completion_set.asset THEN
            asset_barcodes = asset_barcodes || cur_barcode;
        END IF;
    END LOOP;

    IF do_asset AND do_serial THEN
        RETURN QUERY SELECT 'asset'::TEXT, id, barcode FROM ONLY asset.copy WHERE barcode = ANY(asset_barcodes) AND deleted = false;
        RETURN QUERY SELECT 'serial'::TEXT, id, barcode FROM serial.unit WHERE barcode = ANY(asset_barcodes) AND deleted = false;
    ELSIF do_asset THEN
        RETURN QUERY SELECT 'asset'::TEXT, id, barcode FROM asset.copy WHERE barcode = ANY(asset_barcodes) AND deleted = false;
    ELSIF do_serial THEN
        RETURN QUERY SELECT 'serial'::TEXT, id, barcode FROM serial.unit WHERE barcode = ANY(asset_barcodes) AND deleted = false;
    END IF;
    IF do_booking THEN
        RETURN QUERY SELECT 'booking'::TEXT, id::BIGINT, barcode FROM booking.resource WHERE barcode = ANY(asset_barcodes);
    END IF;
    IF do_actor THEN
        RETURN QUERY SELECT 'actor'::TEXT, c.usr::BIGINT, c.barcode FROM actor.card c JOIN actor.usr u ON c.usr = u.id WHERE
            ((c.barcode = ANY(actor_barcodes) AND c.active) OR c.barcode = in_barcode) AND NOT u.deleted ORDER BY usr;
    END IF;
    RETURN;
END;

get_locale_name

Signature: evergreen.get_locale_name(locale text, OUT name text, OUT description text)

Returns: record

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    eg_locale TEXT;
BEGIN
    eg_locale := LOWER(SUBSTRING(locale FROM 1 FOR 2)) || '-' || UPPER(SUBSTRING(locale FROM 4 FOR 2));

    SELECT i18nc.string INTO name
    FROM config.i18n_locale i18nl
       INNER JOIN config.i18n_core i18nc ON i18nl.code = i18nc.translation
    WHERE i18nc.identity_value = eg_locale
       AND code = eg_locale
       AND i18nc.fq_field = 'i18n_l.name';

    IF name IS NULL THEN
       SELECT i18nl.name INTO name
       FROM config.i18n_locale i18nl
       WHERE code = eg_locale;
    END IF;

    SELECT i18nc.string INTO description
    FROM config.i18n_locale i18nl
       INNER JOIN config.i18n_core i18nc ON i18nl.code = i18nc.translation
    WHERE i18nc.identity_value = eg_locale
       AND code = eg_locale
       AND i18nc.fq_field = 'i18n_l.description';

    IF description IS NULL THEN
       SELECT i18nl.description INTO description
       FROM config.i18n_locale i18nl
       WHERE code = eg_locale;
    END IF;
END;

groups_are

Signature: evergreen.groups_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT groups_are( $1, 'There should be the correct groups' );

groups_are

Signature: evergreen.groups_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'groups',
        ARRAY(
            SELECT groname
              FROM pg_catalog.pg_group
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT groname
              FROM pg_catalog.pg_group
        ),
        $2
    );

has_cast

Signature: evergreen.has_cast(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _cast_exists( $1, $2 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') should exist'
    );

has_cast

Signature: evergreen.has_cast(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
        _cast_exists( $1, $2, $3 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') WITH FUNCTION ' || quote_ident($3) || '() should exist'
    );

has_cast

Signature: evergreen.has_cast(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
       _cast_exists( $1, $2, $3, $4 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') WITH FUNCTION ' || quote_ident($3)
        || '.' || quote_ident($4) || '() should exist'
    );

has_cast

Signature: evergreen.has_cast(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( _cast_exists( $1, $2, $3, $4 ), $5 );

has_cast

Signature: evergreen.has_cast(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( _cast_exists( $1, $2, $3 ), $4 );

has_cast

Signature: evergreen.has_cast(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _cast_exists( $1, $2 ), $3 );

has_check

Signature: evergreen.has_check(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_check( $1, 'Table ' || quote_ident($1) || ' should have a check constraint' );

has_check

Signature: evergreen.has_check(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, $2, 'c' ), $3 );

has_check

Signature: evergreen.has_check(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, 'c' ), $2 );

has_column

Signature: evergreen.has_column(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_column( $1, $2, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist' );

has_column

Signature: evergreen.has_column(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _cexists( $1, $2, $3 ), $4 );

has_column

Signature: evergreen.has_column(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _cexists( $1, $2 ), $3 );

has_composite

Signature: evergreen.has_composite(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_composite( $1, 'Composite type ' || quote_ident($1) || ' should exist' );

has_composite

Signature: evergreen.has_composite(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'c', $1, $2 ), $3 );

has_composite

Signature: evergreen.has_composite(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'c', $1 ), $2 );

has_domain

Signature: evergreen.has_domain(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, ARRAY['d'] ), ('Domain ' || quote_ident($1) || ' should exist')::text );

has_domain

Signature: evergreen.has_domain(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_domain( $1, $2, 'Domain ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist' );

has_domain

Signature: evergreen.has_domain(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, $2, ARRAY['d'] ), $3 );

has_domain

Signature: evergreen.has_domain(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, ARRAY['d'] ), $2 );

has_enum

Signature: evergreen.has_enum(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, ARRAY['e'] ), ('Enum ' || quote_ident($1) || ' should exist')::text );

has_enum

Signature: evergreen.has_enum(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_enum( $1, $2, 'Enum ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist' );

has_enum

Signature: evergreen.has_enum(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, $2, ARRAY['e'] ), $3 );

has_enum

Signature: evergreen.has_enum(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, ARRAY['e'] ), $2 );

has_extension

Signature: evergreen.has_extension(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ext_exists( $1 ),
        'Extension ' || quote_ident($1) || ' should exist' );

has_extension

Signature: evergreen.has_extension(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ext_exists( $1, $2 ),
        'Extension ' || quote_ident($2)
        || ' should exist in schema ' || quote_ident($1) );

has_extension

Signature: evergreen.has_extension(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ext_exists( $1, $2 ), $3 );

has_extension

Signature: evergreen.has_extension(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ext_exists( $1 ), $2)

has_fk

Signature: evergreen.has_fk(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_fk( $1, 'Table ' || quote_ident($1) || ' should have a foreign key constraint' );

has_fk

Signature: evergreen.has_fk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, $2, 'f' ), $3 );

has_fk

Signature: evergreen.has_fk(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, 'f' ), $2 );

has_foreign_table

Signature: evergreen.has_foreign_table(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_foreign_table( $1, 'Foreign table ' || quote_ident($1) || ' should exist' );

has_foreign_table

Signature: evergreen.has_foreign_table(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _rexists( 'f', $1, $2 ),
        'Foreign table ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist'
    );

has_foreign_table

Signature: evergreen.has_foreign_table(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'f', $1, $2 ), $3 );

has_foreign_table

Signature: evergreen.has_foreign_table(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'f', $1 ), $2 );

has_function

Signature: evergreen.has_function(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _got_func($1), 'Function ' || quote_ident($1) || '() should exist' );

has_function

Signature: evergreen.has_function(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _got_func($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should exist'
    );

has_function

Signature: evergreen.has_function(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _got_func($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should exist'
    );

has_function

Signature: evergreen.has_function(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _got_func($1, $2, $3), $4 );

has_function

Signature: evergreen.has_function(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _got_func($1, $2), $3 );

has_function

Signature: evergreen.has_function(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _got_func($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should exist'
    );

has_function

Signature: evergreen.has_function(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _got_func($1, $2), $3 );

has_function

Signature: evergreen.has_function(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _got_func($1), $2 );

has_group

Signature: evergreen.has_group(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_group($1), 'Group ' || quote_ident($1) || ' should exist' );

has_group

Signature: evergreen.has_group(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_group($1), $2 );

has_index

Signature: evergreen.has_index(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _have_index( $1, $2 ), 'Index ' || quote_ident($2) || ' should exist' );

has_index

Signature: evergreen.has_index(name, name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
   IF _is_schema($1) THEN
       -- ( schema, table, index )
       RETURN ok( _have_index( $1, $2, $3 ), 'Index ' || quote_ident($3) || ' should exist' );
   ELSE
       -- ( table, index, column/expression )
       RETURN has_index( $1, $2, $3, 'Index ' || quote_ident($2) || ' should exist' );
   END IF;
END;

has_index

Signature: evergreen.has_index(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT has_index( $1, $2, $3, $4, 'Index ' || quote_ident($3) || ' should exist' );

has_index

Signature: evergreen.has_index(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_index( $1, $2, $3, ARRAY[$4], $5 );

has_index

Signature: evergreen.has_index(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT has_index( $1, $2, $3, $4, 'Index ' || quote_ident($3) || ' should exist' );

has_index

Signature: evergreen.has_index(name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
     index_cols name[];
BEGIN
    index_cols := _ikeys($1, $2, $3 );

    IF index_cols IS NULL OR index_cols = '{}'::name[] THEN
        RETURN ok( false, $5 ) || E'\n'
            || diag( 'Index ' || quote_ident($3) || ' ON ' || quote_ident($1) || '.' || quote_ident($2) || ' not found');
    END IF;

    RETURN is(
        quote_ident($3) || ' ON ' || quote_ident($1) || '.' || quote_ident($2) || '(' || array_to_string( index_cols, ', ' ) || ')',
        quote_ident($3) || ' ON ' || quote_ident($1) || '.' || quote_ident($2) || '(' || array_to_string( $4, ', ' ) || ')',
        $5
    );
END;

has_index

Signature: evergreen.has_index(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN _is_schema( $1 ) THEN
        -- Looking for schema.table index.
            ok ( _have_index( $1, $2, $3 ), $4)
        ELSE
        -- Looking for particular columns.
            has_index( $1, $2, ARRAY[$3], $4 )
      END;

has_index

Signature: evergreen.has_index(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT has_index( $1, $2, $3, 'Index ' || quote_ident($2) || ' should exist' );

has_index

Signature: evergreen.has_index(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
     index_cols name[];
BEGIN
    index_cols := _ikeys($1, $2 );

    IF index_cols IS NULL OR index_cols = '{}'::name[] THEN
        RETURN ok( false, $4 ) || E'\n'
            || diag( 'Index ' || quote_ident($2) || ' ON ' || quote_ident($1) || ' not found');
    END IF;

    RETURN is(
        quote_ident($2) || ' ON ' || quote_ident($1) || '(' || array_to_string( index_cols, ', ' ) || ')',
        quote_ident($2) || ' ON ' || quote_ident($1) || '(' || array_to_string( $3, ', ' ) || ')',
        $4
    );
END;

has_index

Signature: evergreen.has_index(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN $3 LIKE '%(%'
           THEN has_index( $1, $2, $3::name )
           ELSE ok( _have_index( $1, $2 ), $3 )
           END;

has_inherited_tables

Signature: evergreen.has_inherited_tables(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _inherited( $1 ),
        'Table ' || quote_ident( $1 ) || ' should have descendents'
    );

has_inherited_tables

Signature: evergreen.has_inherited_tables(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _inherited( $1, $2 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 ) || ' should have descendents'
    );

has_inherited_tables

Signature: evergreen.has_inherited_tables(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _inherited( $1, $2 ), $3);

has_inherited_tables

Signature: evergreen.has_inherited_tables(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _inherited( $1 ), $2 );

has_language

Signature: evergreen.has_language(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_trusted($1) IS NOT NULL, 'Procedural language ' || quote_ident($1) || ' should exist' );

has_language

Signature: evergreen.has_language(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_trusted($1) IS NOT NULL, $2 );

has_leftop

Signature: evergreen.has_leftop(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists(NULL, $1, $2 ),
        'Left operator ' || $1 || '(NONE,' || $2 || ') should exist'
    );

has_leftop

Signature: evergreen.has_leftop(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists(NULL, $1, $2, $3 ),
        'Left operator ' || $1 || '(NONE,' || $2 || ') RETURNS ' || $3 || ' should exist'
    );

has_leftop

Signature: evergreen.has_leftop(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists(NULL, $1, $2, $3, $4 ),
        'Left operator ' || quote_ident($1) || '.' || $2 || '(NONE,'
        || $3 || ') RETURNS ' || $4 || ' should exist'
    );

has_leftop

Signature: evergreen.has_leftop(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists(NULL, $1, $2, $3, $4), $5 );

has_leftop

Signature: evergreen.has_leftop(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists(NULL, $1, $2, $3), $4 );

has_leftop

Signature: evergreen.has_leftop(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists(NULL, $1, $2), $3 );

has_materialized_view

Signature: evergreen.has_materialized_view(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_materialized_view( $1, 'Materialized view ' || quote_ident($1) || ' should exist' );

has_materialized_view

Signature: evergreen.has_materialized_view(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'm', $1, $2 ), $3 );

has_materialized_view

Signature: evergreen.has_materialized_view(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'm', $1 ), $2 );

has_opclass

Signature: evergreen.has_opclass(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _opc_exists( $1 ), 'Operator class ' || quote_ident($1) || ' should exist' );

has_opclass

Signature: evergreen.has_opclass(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _opc_exists( $1, $2 ), 'Operator class ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist' );

has_opclass

Signature: evergreen.has_opclass(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _opc_exists( $1, $2 ), $3 );

has_opclass

Signature: evergreen.has_opclass(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _opc_exists( $1 ), $2)

has_operator

Signature: evergreen.has_operator(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, $3 ),
        'Operator ' ||  $2 || '(' || $1 || ',' || $3
        || ') should exist'
    );

has_operator

Signature: evergreen.has_operator(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, $3, $4 ),
        'Operator ' ||  $2 || '(' || $1 || ',' || $3
        || ') RETURNS ' || $4 || ' should exist'
    );

has_operator

Signature: evergreen.has_operator(name, name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, $3, $4, $5 ),
        'Operator ' || quote_ident($2) || '.' || $3 || '(' || $1 || ',' || $4
        || ') RETURNS ' || $5 || ' should exist'
    );

has_operator

Signature: evergreen.has_operator(name, name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists($1, $2, $3, $4, $5 ), $6 );

has_operator

Signature: evergreen.has_operator(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists($1, $2, $3, $4 ), $5 );

has_operator

Signature: evergreen.has_operator(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists($1, $2, $3 ), $4 );

has_pk

Signature: evergreen.has_pk(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_pk( $1, 'Table ' || quote_ident($1) || ' should have a primary key' );

has_pk

Signature: evergreen.has_pk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, $2, 'p' ), $3 );

has_pk

Signature: evergreen.has_pk(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, 'p' ), $2 );

has_relation

Signature: evergreen.has_relation(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_relation( $1, 'Relation ' || quote_ident($1) || ' should exist' );

has_relation

Signature: evergreen.has_relation(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _relexists( $1, $2 ), $3 );

has_relation

Signature: evergreen.has_relation(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _relexists( $1 ), $2 );

has_rightop

Signature: evergreen.has_rightop(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, NULL ),
        'Right operator ' || $2 || '(' || $1 || ',NONE) should exist'
    );

has_rightop

Signature: evergreen.has_rightop(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, NULL, $3 ),
        'Right operator ' || $2 || '('
        || $1 || ',NONE) RETURNS ' || $3 || ' should exist'
    );

has_rightop

Signature: evergreen.has_rightop(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
         _op_exists($1, $2, $3, NULL, $4 ),
        'Right operator ' || quote_ident($2) || '.' || $3 || '('
        || $1 || ',NONE) RETURNS ' || $4 || ' should exist'
    );

has_rightop

Signature: evergreen.has_rightop(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists( $1, $2, $3, NULL, $4), $5 );

has_rightop

Signature: evergreen.has_rightop(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists( $1, $2, NULL, $3), $4 );

has_rightop

Signature: evergreen.has_rightop(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _op_exists( $1, $2, NULL), $3 );

has_role

Signature: evergreen.has_role(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_role($1), 'Role ' || quote_ident($1) || ' should exist' );

has_role

Signature: evergreen.has_role(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_role($1), $2 );

has_rule

Signature: evergreen.has_rule(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2) IS NOT NULL, 'Relation ' || quote_ident($1) || ' should have rule ' || quote_ident($2) );

has_rule

Signature: evergreen.has_rule(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2, $3) IS NOT NULL, 'Relation ' || quote_ident($1) || '.' || quote_ident($2) || ' should have rule ' || quote_ident($3) );

has_rule

Signature: evergreen.has_rule(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2, $3) IS NOT NULL, $4 );

has_rule

Signature: evergreen.has_rule(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2) IS NOT NULL, $3 );

has_schema

Signature: evergreen.has_schema(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_schema( $1, 'Schema ' || quote_ident($1) || ' should exist' );

has_schema

Signature: evergreen.has_schema(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        EXISTS(
            SELECT true
              FROM pg_catalog.pg_namespace
             WHERE nspname = $1
        ), $2
    );

has_sequence

Signature: evergreen.has_sequence(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_sequence( $1, 'Sequence ' || quote_ident($1) || ' should exist' );

has_sequence

Signature: evergreen.has_sequence(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _rexists( 'S', $1, $2 ),
        'Sequence ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist'
    );

has_sequence

Signature: evergreen.has_sequence(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'S', $1, $2 ), $3 );

has_sequence

Signature: evergreen.has_sequence(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'S', $1 ), $2 );

has_table

Signature: evergreen.has_table(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_table( $1, 'Table ' || quote_ident($1) || ' should exist' );

has_table

Signature: evergreen.has_table(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _rexists( '{r,p}'::char[], $1, $2 ),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist'
    );

has_table

Signature: evergreen.has_table(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( '{r,p}'::char[], $1, $2 ), $3 );

has_table

Signature: evergreen.has_table(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( '{r,p}'::char[], $1 ), $2 );

has_tablespace

Signature: evergreen.has_tablespace(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_tablespace( $1, 'Tablespace ' || quote_ident($1) || ' should exist' );

has_tablespace

Signature: evergreen.has_tablespace(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        EXISTS(
            SELECT true
              FROM pg_catalog.pg_tablespace
             WHERE spcname = $1
        ), $2
    );

has_tablespace

Signature: evergreen.has_tablespace(name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF pg_version_num() >= 90200 THEN
        RETURN ok(
            EXISTS(
                SELECT true
                  FROM pg_catalog.pg_tablespace
                 WHERE spcname = $1
                   AND pg_tablespace_location(oid) = $2
            ), $3
        );
    ELSE
        RETURN ok(
            EXISTS(
                SELECT true
                  FROM pg_catalog.pg_tablespace
                 WHERE spcname = $1
                   AND spclocation = $2
            ), $3
        );
    END IF;
END;

has_trigger

Signature: evergreen.has_trigger(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _trig($1, $2), 'Table ' || quote_ident($1) || ' should have trigger ' || quote_ident($2));

has_trigger

Signature: evergreen.has_trigger(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_trigger(
        $1, $2, $3,
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have trigger ' || quote_ident($3)
    );

has_trigger

Signature: evergreen.has_trigger(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _trig($1, $2, $3), $4);

has_trigger

Signature: evergreen.has_trigger(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _trig($1, $2), $3);

has_type

Signature: evergreen.has_type(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, NULL ), ('Type ' || quote_ident($1) || ' should exist')::text );

has_type

Signature: evergreen.has_type(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_type( $1, $2, 'Type ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist' );

has_type

Signature: evergreen.has_type(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, $2, NULL ), $3 );

has_type

Signature: evergreen.has_type(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_type( $1, NULL ), $2 );

has_unique

Signature: evergreen.has_unique(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_unique( $1, 'Table ' || quote_ident($1) || ' should have a unique constraint' );

has_unique

Signature: evergreen.has_unique(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, 'u' ), $2 );

has_unique

Signature: evergreen.has_unique(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _hasc( $1, $2, 'u' ), $3 );

has_user

Signature: evergreen.has_user(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_user( $1 ), 'User ' || quote_ident($1) || ' should exist');

has_user

Signature: evergreen.has_user(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _has_user($1), $2 );

has_view

Signature: evergreen.has_view(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT has_view( $1, 'View ' || quote_ident($1) || ' should exist' );

has_view

Signature: evergreen.has_view(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'v', $1, $2 ), $3 );

has_view

Signature: evergreen.has_view(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists( 'v', $1 ), $2 );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _cast_exists( $1, $2 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') should not exist'
    );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
        NOT _cast_exists( $1, $2, $3 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') WITH FUNCTION ' || quote_ident($3) || '() should not exist'
    );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
       NOT _cast_exists( $1, $2, $3, $4 ),
        'Cast (' || quote_ident($1) || ' AS ' || quote_ident($2)
        || ') WITH FUNCTION ' || quote_ident($3)
        || '.' || quote_ident($4) || '() should not exist'
    );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( NOT _cast_exists( $1, $2, $3, $4 ), $5 );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( NOT _cast_exists( $1, $2, $3 ), $4 );

hasnt_cast

Signature: evergreen.hasnt_cast(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _cast_exists( $1, $2 ), $3 );

hasnt_column

Signature: evergreen.hasnt_column(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_column( $1, $2, 'Column ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist' );

hasnt_column

Signature: evergreen.hasnt_column(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _cexists( $1, $2, $3 ), $4 );

hasnt_column

Signature: evergreen.hasnt_column(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _cexists( $1, $2 ), $3 );

hasnt_composite

Signature: evergreen.hasnt_composite(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_composite( $1, 'Composite type ' || quote_ident($1) || ' should not exist' );

hasnt_composite

Signature: evergreen.hasnt_composite(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'c', $1, $2 ), $3 );

hasnt_composite

Signature: evergreen.hasnt_composite(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'c', $1 ), $2 );

hasnt_domain

Signature: evergreen.hasnt_domain(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, ARRAY['d'] ), ('Domain ' || quote_ident($1) || ' should not exist')::text );

hasnt_domain

Signature: evergreen.hasnt_domain(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_domain( $1, $2, 'Domain ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist' );

hasnt_domain

Signature: evergreen.hasnt_domain(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, $2, ARRAY['d'] ), $3 );

hasnt_domain

Signature: evergreen.hasnt_domain(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, ARRAY['d'] ), $2 );

hasnt_enum

Signature: evergreen.hasnt_enum(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, ARRAY['e'] ), ('Enum ' || quote_ident($1) || ' should not exist')::text );

hasnt_enum

Signature: evergreen.hasnt_enum(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_enum( $1, $2, 'Enum ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist' );

hasnt_enum

Signature: evergreen.hasnt_enum(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, $2, ARRAY['e'] ), $3 );

hasnt_enum

Signature: evergreen.hasnt_enum(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, ARRAY['e'] ), $2 );

hasnt_extension

Signature: evergreen.hasnt_extension(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _ext_exists( $1 ),
        'Extension ' || quote_ident($1) || ' should not exist' );

hasnt_extension

Signature: evergreen.hasnt_extension(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _ext_exists( $1, $2 ),
        'Extension ' || quote_ident($2)
        || ' should not exist in schema ' || quote_ident($1) );

hasnt_extension

Signature: evergreen.hasnt_extension(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _ext_exists( $1, $2 ), $3 );

hasnt_extension

Signature: evergreen.hasnt_extension(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _ext_exists( $1 ), $2)

hasnt_fk

Signature: evergreen.hasnt_fk(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_fk( $1, 'Table ' || quote_ident($1) || ' should not have a foreign key constraint' );

hasnt_fk

Signature: evergreen.hasnt_fk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _hasc( $1, $2, 'f' ), $3 );

hasnt_fk

Signature: evergreen.hasnt_fk(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _hasc( $1, 'f' ), $2 );

hasnt_foreign_table

Signature: evergreen.hasnt_foreign_table(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_foreign_table( $1, 'Foreign table ' || quote_ident($1) || ' should not exist' );

hasnt_foreign_table

Signature: evergreen.hasnt_foreign_table(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _rexists( 'f', $1, $2 ),
        'Foreign table ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist'
    );

hasnt_foreign_table

Signature: evergreen.hasnt_foreign_table(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'f', $1, $2 ), $3 );

hasnt_foreign_table

Signature: evergreen.hasnt_foreign_table(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'f', $1 ), $2 );

hasnt_function

Signature: evergreen.hasnt_function(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _got_func($1), 'Function ' || quote_ident($1) || '() should not exist' );

hasnt_function

Signature: evergreen.hasnt_function(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _got_func($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should not exist'
    );

hasnt_function

Signature: evergreen.hasnt_function(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _got_func($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should not exist'
    );

hasnt_function

Signature: evergreen.hasnt_function(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _got_func($1, $2, $3), $4 );

hasnt_function

Signature: evergreen.hasnt_function(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _got_func($1, $2), $3 );

hasnt_function

Signature: evergreen.hasnt_function(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _got_func($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should not exist'
    );

hasnt_function

Signature: evergreen.hasnt_function(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _got_func($1, $2), $3 );

hasnt_function

Signature: evergreen.hasnt_function(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _got_func($1), $2 );

hasnt_group

Signature: evergreen.hasnt_group(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_group($1), 'Group ' || quote_ident($1) || ' should not exist' );

hasnt_group

Signature: evergreen.hasnt_group(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_group($1), $2 );

hasnt_index

Signature: evergreen.hasnt_index(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _have_index( $1, $2 ),
        'Index ' || quote_ident($2) || ' should not exist'
    );

hasnt_index

Signature: evergreen.hasnt_index(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _have_index( $1, $2, $3 ),
        'Index ' || quote_ident($3) || ' should not exist'
    );

hasnt_index

Signature: evergreen.hasnt_index(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    RETURN ok( NOT _have_index( $1, $2, $3 ), $4 );
END;

hasnt_index

Signature: evergreen.hasnt_index(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _have_index( $1, $2 ), $3 );

hasnt_inherited_tables

Signature: evergreen.hasnt_inherited_tables(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _inherited( $1 ),
        'Table ' || quote_ident( $1 ) || ' should not have descendents'
    );

hasnt_inherited_tables

Signature: evergreen.hasnt_inherited_tables(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _inherited( $1, $2 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 ) || ' should not have descendents'
    );

hasnt_inherited_tables

Signature: evergreen.hasnt_inherited_tables(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
       SELECT ok( NOT _inherited( $1, $2 ), $3 );

hasnt_inherited_tables

Signature: evergreen.hasnt_inherited_tables(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _inherited( $1 ), $2 );

hasnt_language

Signature: evergreen.hasnt_language(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_trusted($1) IS NULL, 'Procedural language ' || quote_ident($1) || ' should not exist' );

hasnt_language

Signature: evergreen.hasnt_language(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_trusted($1) IS NULL, $2 );

hasnt_materialized_view

Signature: evergreen.hasnt_materialized_view(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_materialized_view( $1, 'Materialized view ' || quote_ident($1) || ' should not exist' );

hasnt_materialized_view

Signature: evergreen.hasnt_materialized_view(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'm', $1, $2 ), $3 );

hasnt_materialized_view

Signature: evergreen.hasnt_materialized_view(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'm', $1 ), $2 );

hasnt_opclass

Signature: evergreen.hasnt_opclass(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _opc_exists( $1 ), 'Operator class ' || quote_ident($1) || ' should not exist' );

hasnt_opclass

Signature: evergreen.hasnt_opclass(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _opc_exists( $1, $2 ), 'Operator class ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist' );

hasnt_opclass

Signature: evergreen.hasnt_opclass(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _opc_exists( $1, $2 ), $3 );

hasnt_opclass

Signature: evergreen.hasnt_opclass(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _opc_exists( $1 ), $2)

hasnt_pk

Signature: evergreen.hasnt_pk(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_pk( $1, 'Table ' || quote_ident($1) || ' should not have a primary key' );

hasnt_pk

Signature: evergreen.hasnt_pk(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _hasc( $1, $2, 'p' ), $3 );

hasnt_pk

Signature: evergreen.hasnt_pk(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _hasc( $1, 'p' ), $2 );

hasnt_relation

Signature: evergreen.hasnt_relation(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_relation( $1, 'Relation ' || quote_ident($1) || ' should not exist' );

hasnt_relation

Signature: evergreen.hasnt_relation(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _relexists( $1, $2 ), $3 );

hasnt_relation

Signature: evergreen.hasnt_relation(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _relexists( $1 ), $2 );

hasnt_role

Signature: evergreen.hasnt_role(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_role($1), 'Role ' || quote_ident($1) || ' should not exist' );

hasnt_role

Signature: evergreen.hasnt_role(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_role($1), $2 );

hasnt_rule

Signature: evergreen.hasnt_rule(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2) IS NULL, 'Relation ' || quote_ident($1) || ' should not have rule ' || quote_ident($2) );

hasnt_rule

Signature: evergreen.hasnt_rule(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2, $3) IS NULL, 'Relation ' || quote_ident($1) || '.' || quote_ident($2) || ' should not have rule ' || quote_ident($3) );

hasnt_rule

Signature: evergreen.hasnt_rule(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2, $3) IS NULL, $4 );

hasnt_rule

Signature: evergreen.hasnt_rule(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _is_instead($1, $2) IS NULL, $3 );

hasnt_schema

Signature: evergreen.hasnt_schema(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_schema( $1, 'Schema ' || quote_ident($1) || ' should not exist' );

hasnt_schema

Signature: evergreen.hasnt_schema(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT EXISTS(
            SELECT true
              FROM pg_catalog.pg_namespace
             WHERE nspname = $1
        ), $2
    );

hasnt_sequence

Signature: evergreen.hasnt_sequence(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_sequence( $1, 'Sequence ' || quote_ident($1) || ' should not exist' );

hasnt_sequence

Signature: evergreen.hasnt_sequence(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'S', $1, $2 ), $3 );

hasnt_sequence

Signature: evergreen.hasnt_sequence(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'S', $1 ), $2 );

hasnt_table

Signature: evergreen.hasnt_table(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_table( $1, 'Table ' || quote_ident($1) || ' should not exist' );

hasnt_table

Signature: evergreen.hasnt_table(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _rexists( '{r,p}'::char[], $1, $2 ),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist'
    );

hasnt_table

Signature: evergreen.hasnt_table(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( '{r,p}'::char[], $1, $2 ), $3 );

hasnt_table

Signature: evergreen.hasnt_table(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( '{r,p}'::char[], $1 ), $2 );

hasnt_tablespace

Signature: evergreen.hasnt_tablespace(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_tablespace( $1, 'Tablespace ' || quote_ident($1) || ' should not exist' );

hasnt_tablespace

Signature: evergreen.hasnt_tablespace(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT EXISTS(
            SELECT true
              FROM pg_catalog.pg_tablespace
             WHERE spcname = $1
        ), $2
    );

hasnt_trigger

Signature: evergreen.hasnt_trigger(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _trig($1, $2), 'Table ' || quote_ident($1) || ' should not have trigger ' || quote_ident($2));

hasnt_trigger

Signature: evergreen.hasnt_trigger(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _trig($1, $2, $3),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should not have trigger ' || quote_ident($3)
    );

hasnt_trigger

Signature: evergreen.hasnt_trigger(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _trig($1, $2, $3), $4);

hasnt_trigger

Signature: evergreen.hasnt_trigger(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _trig($1, $2), $3);

hasnt_type

Signature: evergreen.hasnt_type(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, NULL ), ('Type ' || quote_ident($1) || ' should not exist')::text );

hasnt_type

Signature: evergreen.hasnt_type(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_type( $1, $2, 'Type ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist' );

hasnt_type

Signature: evergreen.hasnt_type(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, $2, NULL ), $3 );

hasnt_type

Signature: evergreen.hasnt_type(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_type( $1, NULL ), $2 );

hasnt_user

Signature: evergreen.hasnt_user(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_user( $1 ), 'User ' || quote_ident($1) || ' should not exist');

hasnt_user

Signature: evergreen.hasnt_user(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _has_user($1), $2 );

hasnt_view

Signature: evergreen.hasnt_view(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT hasnt_view( $1, 'View ' || quote_ident($1) || ' should not exist' );

hasnt_view

Signature: evergreen.hasnt_view(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'v', $1, $2 ), $3 );

hasnt_view

Signature: evergreen.hasnt_view(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists( 'v', $1 ), $2 );

hint_opt_in_check

Signature: evergreen.hint_opt_in_check(hint_val text, pkey_val bigint, staff_id integer, permlist text[] DEFAULT '{}'::text[])

Returns: boolean

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
BEGIN
    CASE hint_val
        WHEN 'aua' THEN
            RETURN evergreen.direct_opt_in_check((SELECT usr FROM actor.usr_address WHERE id = pkey_val LIMIT 1), staff_id, permlist);
        WHEN 'auact' THEN
            RETURN evergreen.direct_opt_in_check((SELECT usr FROM actor.usr_activity WHERE id = pkey_val LIMIT 1), staff_id, permlist);
        WHEN 'aus' THEN
            RETURN evergreen.direct_opt_in_check((SELECT usr FROM actor.usr_setting WHERE id = pkey_val LIMIT 1), staff_id, permlist);
        WHEN 'actscecm' THEN
            RETURN evergreen.direct_opt_in_check((SELECT target_usr FROM actor.stat_cat_entry_usr_map WHERE id = pkey_val LIMIT 1), staff_id, permlist);
        WHEN 'ateo' THEN
            RETURN evergreen.direct_opt_in_check(
                (SELECT e.context_user FROM action_trigger.event e JOIN action_trigger.event_output eo ON (eo.event = e.id) WHERE eo.id = pkey_val LIMIT 1),
                staff_id,
                permlist
            );
        ELSE
            RETURN FALSE;
    END CASE;
END;

ialike

Signature: evergreen.ialike(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~~* $2, $1, $2, NULL );

ialike

Signature: evergreen.ialike(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~~* $2, $1, $2, $3 );

imatches

Signature: evergreen.imatches(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~* $2, $1, $2, NULL );

imatches

Signature: evergreen.imatches(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~* $2, $1, $2, $3 );

in_todo

Signature: evergreen.in_todo()

Returns: boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    todos integer;
BEGIN
    todos := _get('todo');
    RETURN CASE WHEN todos IS NULL THEN FALSE ELSE TRUE END;
END;

index_is_primary

Signature: evergreen.index_is_primary(name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisprimary
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
     WHERE ci.relname = $1
       AND pg_catalog.pg_table_is_visible(ct.oid)
      INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Index ' || quote_ident($1) || ' should be on a primary key'
      );
END;

index_is_primary

Signature: evergreen.index_is_primary(name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisprimary
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
     WHERE ct.relname = $1
       AND ci.relname = $2
       AND pg_catalog.pg_table_is_visible(ct.oid)
     INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Index ' || quote_ident($2) || ' should be on a primary key'
      );
END;

index_is_primary

Signature: evergreen.index_is_primary(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT index_is_primary(
        $1, $2, $3,
        'Index ' || quote_ident($3) || ' should be on a primary key'
    );

index_is_primary

Signature: evergreen.index_is_primary(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisprimary
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
     WHERE ct.relname = $2
       AND ci.relname = $3
       AND n.nspname  = $1
      INTO res;

      RETURN ok( COALESCE(res, false), $4 );
END;

index_is_type

Signature: evergreen.index_is_type(name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    aname name;
BEGIN
    SELECT am.amname
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_am am    ON ci.relam = am.oid
     WHERE ci.relname = $1
      INTO aname;

      return is(
          aname, $2,
          'Index ' || quote_ident($1) || ' should be a ' || quote_ident($2) || ' index'
      );
END;

index_is_type

Signature: evergreen.index_is_type(name, name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    aname name;
BEGIN
    SELECT am.amname
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_am am    ON ci.relam = am.oid
     WHERE ct.relname = $1
       AND ci.relname = $2
      INTO aname;

      return is(
          aname, $3,
          'Index ' || quote_ident($2) || ' should be a ' || quote_ident($3) || ' index'
      );
END;

index_is_type

Signature: evergreen.index_is_type(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT index_is_type(
        $1, $2, $3, $4,
        'Index ' || quote_ident($3) || ' should be a ' || quote_ident($4) || ' index'
    );

index_is_type

Signature: evergreen.index_is_type(name, name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    aname name;
BEGIN
    SELECT am.amname
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
      JOIN pg_catalog.pg_am am       ON ci.relam = am.oid
     WHERE ct.relname = $2
       AND ci.relname = $3
       AND n.nspname  = $1
      INTO aname;

      return is( aname, $4, $5 );
END;

index_is_unique

Signature: evergreen.index_is_unique(name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisunique
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
     WHERE ci.relname = $1
       AND pg_catalog.pg_table_is_visible(ct.oid)
      INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Index ' || quote_ident($1) || ' should be unique'
      );
END;

index_is_unique

Signature: evergreen.index_is_unique(name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisunique
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
     WHERE ct.relname = $1
       AND ci.relname = $2
       AND pg_catalog.pg_table_is_visible(ct.oid)
      INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Index ' || quote_ident($2) || ' should be unique'
      );
END;

index_is_unique

Signature: evergreen.index_is_unique(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT index_is_unique(
        $1, $2, $3,
        'Index ' || quote_ident($3) || ' should be unique'
    );

index_is_unique

Signature: evergreen.index_is_unique(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisunique
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
     WHERE ct.relname = $2
       AND ci.relname = $3
       AND n.nspname  = $1
      INTO res;

      RETURN ok( COALESCE(res, false), $4 );
END;

index_owner_is

Signature: evergreen.index_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT index_owner_is(
        $1, $2, $3,
        'Index ' || quote_ident($2) || ' ON '
        || quote_ident($1) || ' should be owned by ' || quote_ident($3)
    );

index_owner_is

Signature: evergreen.index_owner_is(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT index_owner_is(
        $1, $2, $3, $4,
        'Index ' || quote_ident($3) || ' ON '
        || quote_ident($1) || '.' || quote_ident($2)
        || ' should be owned by ' || quote_ident($4)
    );

index_owner_is

Signature: evergreen.index_owner_is(name, name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_index_owner($1, $2, $3);
BEGIN
    -- Make sure the index exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            E'    Index ' || quote_ident($3) || ' ON '
            || quote_ident($1) || '.' || quote_ident($2) || ' not found'
        );
    END IF;

    RETURN is(owner, $4, $5);
END;

index_owner_is

Signature: evergreen.index_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_index_owner($1, $2);
BEGIN
    -- Make sure the index exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Index ' || quote_ident($2) || ' ON ' || quote_ident($1) || ' not found'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

indexes_are

Signature: evergreen.indexes_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT indexes_are( $1, $2, $3, 'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct indexes' );

indexes_are

Signature: evergreen.indexes_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'indexes',
        ARRAY(
            SELECT ci.relname
              FROM pg_catalog.pg_index x
              JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
              JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
             WHERE ct.relname = $2
               AND n.nspname  = $1
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT ci.relname
              FROM pg_catalog.pg_index x
              JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
              JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
             WHERE ct.relname = $2
               AND n.nspname  = $1
        ),
        $4
    );

indexes_are

Signature: evergreen.indexes_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT indexes_are( $1, $2, 'Table ' || quote_ident($1) || ' should have the correct indexes' );

indexes_are

Signature: evergreen.indexes_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'indexes',
        ARRAY(
            SELECT ci.relname
              FROM pg_catalog.pg_index x
              JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
              JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
             WHERE ct.relname = $1
               AND pg_catalog.pg_table_is_visible(ct.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT ci.relname
              FROM pg_catalog.pg_index x
              JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
              JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
             WHERE ct.relname = $1
               AND pg_catalog.pg_table_is_visible(ct.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
        ),
        $3
    );

indexing_ingest_or_delete

Signature: evergreen.indexing_ingest_or_delete()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    old_state_data      TEXT := '';
    new_action          TEXT;
    queuing_force       TEXT;
    queuing_flag_name   TEXT;
    queuing_flag        BOOL := FALSE;
    queuing_success     BOOL := FALSE;
    ingest_success      BOOL := FALSE;
    ingest_queue        INT;
BEGIN

    -- Identify the ingest action type
    IF TG_OP = 'UPDATE' THEN

        -- Gather type-specific data for later use
        IF TG_TABLE_SCHEMA = 'authority' THEN
            old_state_data = OLD.heading;
        END IF;

        IF NOT OLD.deleted THEN -- maybe reingest?
            IF NEW.deleted THEN
                new_action = 'delete'; -- nope, delete
            ELSE
                new_action = 'update'; -- yes, update
            END IF;
        ELSIF NOT NEW.deleted THEN
            new_action = 'insert'; -- revivify, AKA insert
        ELSE
            RETURN NEW; -- was and is still deleted, don't ingest
        END IF;
    ELSIF TG_OP = 'INSERT' THEN
        new_action = 'insert'; -- brand new
    ELSE
        RETURN OLD; -- really deleting the record
    END IF;

    queuing_flag_name := 'ingest.queued.'||TG_TABLE_SCHEMA||'.'||new_action;
    -- See if we should be queuing anything
    SELECT  enabled INTO queuing_flag
      FROM  config.internal_flag
      WHERE name IN ('ingest.queued.all','ingest.queued.'||TG_TABLE_SCHEMA||'.all', queuing_flag_name)
            AND enabled
      LIMIT 1;

    SELECT action.get_queued_ingest_force() INTO queuing_force;
    IF queuing_flag IS NULL AND queuing_force = queuing_flag_name THEN
        queuing_flag := TRUE;
    END IF;

    -- you (or part of authority propagation) can forcibly disable specific queuing actions
    IF queuing_force = queuing_flag_name||'.disabled' THEN
        queuing_flag := FALSE;
    END IF;

    -- And if we should be queuing ...
    IF queuing_flag THEN
        ingest_queue := action.get_ingest_queue();

        -- ... but this is NOT a named or forced queue request (marc editor update, say, or vandelay overlay)...
        IF queuing_force IS NULL AND ingest_queue IS NULL AND new_action = 'update' THEN -- re-ingest?

            PERFORM * FROM config.internal_flag WHERE name = 'ingest.reingest.force_on_same_marc' AND enabled;

            --  ... then don't do anything if ingest.reingest.force_on_same_marc is not enabled and the MARC hasn't changed
            IF NOT FOUND AND OLD.marc = NEW.marc THEN
                RETURN NEW;
            END IF;
        END IF;

        -- Otherwise, attempt to enqueue
        SELECT action.enqueue_ingest_entry( NEW.id, TG_TABLE_SCHEMA, NOW(), ingest_queue, new_action, old_state_data) INTO queuing_success;
    END IF;

    -- If queuing was not requested, or failed for some reason, do it live.
    IF NOT queuing_success THEN
        IF queuing_flag THEN
            RAISE WARNING 'Enqueuing of %.record_entry % for ingest failed, attempting direct ingest', TG_TABLE_SCHEMA, NEW.id;
        END IF;

        IF new_action = 'delete' THEN
            IF TG_TABLE_SCHEMA = 'biblio' THEN
                SELECT metabib.indexing_delete(NEW.*, old_state_data) INTO ingest_success;
            ELSIF TG_TABLE_SCHEMA = 'authority' THEN
                SELECT authority.indexing_delete(NEW.*, old_state_data) INTO ingest_success;
            END IF;
        ELSE
            IF TG_TABLE_SCHEMA = 'biblio' THEN
                SELECT metabib.indexing_update(NEW.*, new_action = 'insert', old_state_data) INTO ingest_success;
            ELSIF TG_TABLE_SCHEMA = 'authority' THEN
                SELECT authority.indexing_update(NEW.*, new_action = 'insert', old_state_data) INTO ingest_success;
            END IF;
        END IF;

        IF NOT ingest_success THEN
            PERFORM * FROM config.internal_flag WHERE name = 'ingest.queued.abort_on_error' AND enabled;
            IF FOUND THEN
                RAISE EXCEPTION 'Ingest of %.record_entry % failed', TG_TABLE_SCHEMA, NEW.id;
            ELSE
                RAISE WARNING 'Ingest of %.record_entry % failed', TG_TABLE_SCHEMA, NEW.id;
            END IF;
        END IF;
    END IF;

    RETURN NEW;
END;

is

Signature: evergreen.is(anyelement, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is( $1, $2, NULL);

is

Signature: evergreen.is(anyelement, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    result BOOLEAN;
    output TEXT;
BEGIN
    -- Would prefer $1 IS NOT DISTINCT FROM, but that's not supported by 8.1.
    result := NOT $1 IS DISTINCT FROM $2;
    output := ok( result, $3 );
    RETURN output || CASE result WHEN TRUE THEN '' ELSE E'\n' || diag(
           '        have: ' || CASE WHEN $1 IS NULL THEN 'NULL' ELSE $1::text END ||
        E'\n        want: ' || CASE WHEN $2 IS NULL THEN 'NULL' ELSE $2::text END
    ) END;
END;

is_aggregate

Signature: evergreen.is_aggregate(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _agg($1), 'Function ' || quote_ident($1) || '() should be an aggregate function' );

is_aggregate

Signature: evergreen.is_aggregate(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _agg($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should be an aggregate function'
    );

is_aggregate

Signature: evergreen.is_aggregate(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _agg($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be an aggregate function'
    );

is_aggregate

Signature: evergreen.is_aggregate(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _agg($1, $2, $3), $4 );

is_aggregate

Signature: evergreen.is_aggregate(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _agg($1, $2), $3 );

is_aggregate

Signature: evergreen.is_aggregate(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _agg($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be an aggregate function'
    );

is_aggregate

Signature: evergreen.is_aggregate(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _agg($1, $2), $3 );

is_aggregate

Signature: evergreen.is_aggregate(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _agg($1), $2 );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $1, $2, NULL ),
        'Table ' || quote_ident( $1 ) || ' should be an ancestor of ' || quote_ident( $2)
    );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $1, $2, $3 ),
        'Table ' || quote_ident( $1 ) || ' should be ancestor ' || $3 || ' of ' || quote_ident( $2)
    );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $1, $2, $3 ), $4 );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $1, $2, $3, $4, NULL ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should be an ancestor of '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $1, $2, $3, $4, $5 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should be ancestor ' || $5 || ' for '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $1, $2, $3, $4, $5 ), $6 );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $1, $2, $3, $4, NULL ), $5 );

is_ancestor_of

Signature: evergreen.is_ancestor_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $1, $2, NULL ), $3 );

is_clustered

Signature: evergreen.is_clustered(name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisclustered
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
     WHERE ci.relname = $1
      INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Table should be clustered on index ' || quote_ident($1)
      );
END;

is_clustered

Signature: evergreen.is_clustered(name, name)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisclustered
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
     WHERE ct.relname = $1
       AND ci.relname = $2
      INTO res;

      RETURN ok(
          COALESCE(res, false),
          'Table ' || quote_ident($1) || ' should be clustered on index ' || quote_ident($2)
      );
END;

is_clustered

Signature: evergreen.is_clustered(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_clustered(
        $1, $2, $3,
        'Table ' || quote_ident($1) || '.' || quote_ident($2) ||
        ' should be clustered on index ' || quote_ident($3)
    );

is_clustered

Signature: evergreen.is_clustered(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res boolean;
BEGIN
    SELECT x.indisclustered
      FROM pg_catalog.pg_index x
      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
     WHERE ct.relname = $2
       AND ci.relname = $3
       AND n.nspname  = $1
      INTO res;

      RETURN ok( COALESCE(res, false), $4 );
END;

is_definer

Signature: evergreen.is_definer(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _definer($1), 'Function ' || quote_ident($1) || '() should be security definer' );

is_definer

Signature: evergreen.is_definer(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _definer($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should be security definer'
    );

is_definer

Signature: evergreen.is_definer(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _definer($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be security definer'
    );

is_definer

Signature: evergreen.is_definer(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _definer($1, $2, $3), $4 );

is_definer

Signature: evergreen.is_definer(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _definer($1, $2), $3 );

is_definer

Signature: evergreen.is_definer(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _definer($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be security definer'
    );

is_definer

Signature: evergreen.is_definer(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _definer($1, $2), $3 );

is_definer

Signature: evergreen.is_definer(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _definer($1), $2 );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $2, $1, NULL ),
        'Table ' || quote_ident( $1 ) || ' should be a descendent of ' || quote_ident( $2)
    );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $2, $1, $3 ),
        'Table ' || quote_ident( $1 ) || ' should be descendent ' || $3 || ' from ' || quote_ident( $2)
    );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $2, $1, $3 ), $4 );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $3, $4, $1, $2, NULL ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should be a descendent of '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _ancestor_of( $3, $4, $1, $2, $5 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should be descendent ' || $5 || ' from '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $3, $4, $1, $2, $5 ), $6 );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $3, $4, $1, $2, NULL ), $5 );

is_descendent_of

Signature: evergreen.is_descendent_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _ancestor_of( $2, $1, NULL ), $3 );

is_empty

Signature: evergreen.is_empty(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_empty( $1, NULL );

is_empty

Signature: evergreen.is_empty(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    extras  TEXT[]  := '{}';
    res     BOOLEAN := TRUE;
    msg     TEXT    := '';
    rec     RECORD;
BEGIN
    -- Find extra records.
    FOR rec in EXECUTE _query($1) LOOP
        extras := extras || rec::text;
    END LOOP;

    -- What extra records do we have?
    IF extras[1] IS NOT NULL THEN
        res := FALSE;
        msg := E'\n' || diag(
            E'    Unexpected records:\n        '
            ||  array_to_string( extras, E'\n        ' )
        );
    END IF;

    RETURN ok(res, $2) || msg;
END;

is_indexed

Signature: evergreen.is_indexed(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok ( _is_indexed( NULL, $1, ARRAY[$2]::NAME[]) );

is_indexed

Signature: evergreen.is_indexed(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT CASE WHEN _is_schema( $1 ) THEN
                -- Looking for schema.table index.
                is_indexed( $1, $2, ARRAY[$3]::NAME[] )
           ELSE
                -- Looking for particular columns.
                is_indexed( $1, ARRAY[$2]::NAME[], $3 )
           END;

is_indexed

Signature: evergreen.is_indexed(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok ( _is_indexed( $1, $2, ARRAY[$3]::NAME[]), $4);

is_indexed

Signature: evergreen.is_indexed(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
       _is_indexed($1, $2, $3),
       'Should have an index on ' ||  quote_ident($1) || '.' || quote_ident($2) || '(' || array_to_string( $3, ', ' ) || ')'
    );

is_indexed

Signature: evergreen.is_indexed(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( _is_indexed($1, $2, $3), $4 );

is_indexed

Signature: evergreen.is_indexed(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok(
       _is_indexed(NULL, $1, $2),
       'Should have an index on ' ||  quote_ident($1) || '(' || array_to_string( $2, ', ' ) || ')'
   );

is_indexed

Signature: evergreen.is_indexed(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
   SELECT ok( _is_indexed(NULL, $1, $2), $3 );

is_json

Signature: evergreen.is_json(text)

Returns: boolean

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    use JSON::XS;
    my $json = shift();
    eval { JSON::XS->new->allow_nonref->decode( $json ) };
    return $@ ? 0 : 1;

is_member_of

Signature: evergreen.is_member_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_member_of( $1, ARRAY[$2] );

is_member_of

Signature: evergreen.is_member_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_member_of( $1, ARRAY[$2], $3 );

is_member_of

Signature: evergreen.is_member_of(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_member_of( $1, $2, 'Should have members of role ' || quote_ident($1) );

is_member_of

Signature: evergreen.is_member_of(name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    missing text[];
BEGIN
    IF NOT _has_role($1) THEN
        RETURN fail( $3 ) || E'\n' || diag (
            '    Role ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    SELECT ARRAY(
        SELECT quote_ident($2[i])
          FROM generate_series(1, array_upper($2, 1)) s(i)
          LEFT JOIN pg_catalog.pg_roles r ON rolname = $2[i]
         WHERE r.oid IS NULL
            OR NOT r.oid = ANY ( _grolist($1) )
         ORDER BY s.i
    ) INTO missing;
    IF missing[1] IS NULL THEN
        RETURN ok( true, $3 );
    END IF;
    RETURN ok( false, $3 ) || E'\n' || diag(
        '    Members missing from the ' || quote_ident($1) || E' role:\n        ' ||
        array_to_string( missing, E'\n        ')
    );
END;

is_partition_of

Signature: evergreen.is_partition_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _partof($1, $2),
        'Table ' || quote_ident($1) || ' should be a partition of ' || quote_ident($2)
    );

is_partition_of

Signature: evergreen.is_partition_of(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _partof($1, $2, $3, $4),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should be a partition of '
        || quote_ident($3) || '.' || quote_ident($4)
    );

is_partition_of

Signature: evergreen.is_partition_of(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _partof($1, $2, $3, $4), $5);

is_partition_of

Signature: evergreen.is_partition_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _partof($1, $2), $3);

is_partitioned

Signature: evergreen.is_partitioned(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _rexists('p', $1),
        'Table ' || quote_ident($1) || ' should be partitioned'
    );

is_partitioned

Signature: evergreen.is_partitioned(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _rexists('p', $1, $2),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should be partitioned'
    );

is_partitioned

Signature: evergreen.is_partitioned(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists('p', $1, $2), $3);

is_partitioned

Signature: evergreen.is_partitioned(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _rexists('p', $1), $2);

is_strict

Signature: evergreen.is_strict(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( _strict($1), 'Function ' || quote_ident($1) || '() should be strict' );

is_strict

Signature: evergreen.is_strict(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _strict($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should be strict'
    );

is_strict

Signature: evergreen.is_strict(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _strict($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be strict'
    );

is_strict

Signature: evergreen.is_strict(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _strict($1, $2, $3), $4 );

is_strict

Signature: evergreen.is_strict(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _strict($1, $2), $3 );

is_strict

Signature: evergreen.is_strict(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        _strict($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be strict'
    );

is_strict

Signature: evergreen.is_strict(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _strict($1, $2), $3 );

is_strict

Signature: evergreen.is_strict(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _strict($1), $2 );

is_superuser

Signature: evergreen.is_superuser(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT is_superuser( $1, 'User ' || quote_ident($1) || ' should be a super user' );

is_superuser

Signature: evergreen.is_superuser(name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    is_super boolean := _is_super($1);
BEGIN
    IF is_super IS NULL THEN
        RETURN fail( $2 ) || E'\n' || diag( '    User ' || quote_ident($1) || ' does not exist') ;
    END IF;
    RETURN ok( is_super, $2 );
END;

isa_ok

Signature: evergreen.isa_ok(anyelement, regtype)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isa_ok($1, $2, 'the value');

isa_ok

Signature: evergreen.isa_ok(anyelement, regtype, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    typeof regtype := pg_typeof($1);
BEGIN
    IF typeof = $2 THEN RETURN ok(true, $3 || ' isa ' || $2 ); END IF;
    RETURN ok(false, $3 || ' isa ' || $2 ) || E'\n' ||
        diag('    ' || $3 || ' isn''t a "' || $2 || '" it''s a "' || typeof || '"');
END;

isnt

Signature: evergreen.isnt(anyelement, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isnt( $1, $2, NULL);

isnt

Signature: evergreen.isnt(anyelement, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    result BOOLEAN;
    output TEXT;
BEGIN
    result := $1 IS DISTINCT FROM $2;
    output := ok( result, $3 );
    RETURN output || CASE result WHEN TRUE THEN '' ELSE E'\n' || diag(
           '        have: ' || COALESCE( $1::text, 'NULL' ) ||
        E'\n        want: anything else'
    ) END;
END;

isnt_aggregate

Signature: evergreen.isnt_aggregate(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _agg($1), 'Function ' || quote_ident($1) || '() should not be an aggregate function' );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _agg($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should not be an aggregate function'
    );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _agg($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should not be an aggregate function'
    );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, NOT _agg($1, $2, $3), $4 );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, NOT _agg($1, $2), $3 );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _agg($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should not be an aggregate function'
    );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, NOT _agg($1, $2), $3 );

isnt_aggregate

Signature: evergreen.isnt_aggregate(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, NOT _agg($1), $2 );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT  _ancestor_of( $1, $2, NULL ),
        'Table ' || quote_ident( $1 ) || ' should not be an ancestor of ' || quote_ident( $2)
    );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT  _ancestor_of( $1, $2, $3 ),
        'Table ' || quote_ident( $1 ) || ' should not be ancestor ' || $3 || ' of ' || quote_ident( $2)
    );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT  _ancestor_of( $1, $2, $3 ), $4 );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT  _ancestor_of( $1, $2, $3, $4, NULL ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should not be an ancestor of '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT  _ancestor_of( $1, $2, $3, $4, $5 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should not be ancestor ' || $5 || ' for '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT  _ancestor_of( $1, $2, $3, $4, $5 ), $6 );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT  _ancestor_of( $1, $2, $3, $4, NULL ), $5 );

isnt_ancestor_of

Signature: evergreen.isnt_ancestor_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT  _ancestor_of( $1, $2, NULL ), $3 );

isnt_definer

Signature: evergreen.isnt_definer(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _definer($1), 'Function ' || quote_ident($1) || '() should not be security definer' );

isnt_definer

Signature: evergreen.isnt_definer(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _definer($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should not be security definer'
    );

isnt_definer

Signature: evergreen.isnt_definer(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _definer($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should not be security definer'
    );

isnt_definer

Signature: evergreen.isnt_definer(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, NOT _definer($1, $2, $3), $4 );

isnt_definer

Signature: evergreen.isnt_definer(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, NOT _definer($1, $2), $3 );

isnt_definer

Signature: evergreen.isnt_definer(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _definer($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should not be security definer'
    );

isnt_definer

Signature: evergreen.isnt_definer(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, NOT _definer($1, $2), $3 );

isnt_definer

Signature: evergreen.isnt_definer(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, NOT _definer($1), $2 );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
       NOT  _ancestor_of( $2, $1, NULL ),
        'Table ' || quote_ident( $1 ) || ' should not be a descendent of ' || quote_ident( $2)
    );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
       NOT  _ancestor_of( $2, $1, $3 ),
        'Table ' || quote_ident( $1 ) || ' should not be descendent ' || $3 || ' from ' || quote_ident( $2)
    );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(NOT  _ancestor_of( $2, $1, $3 ), $4 );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
       NOT  _ancestor_of( $3, $4, $1, $2, NULL ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should not be a descendent of '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, name, name, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
       NOT  _ancestor_of( $3, $4, $1, $2, $5 ),
        'Table ' || quote_ident( $1 ) || '.' || quote_ident( $2 )
        || ' should not be descendent ' || $5 || ' from '
        || quote_ident( $3 ) || '.' || quote_ident( $4 )
    );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, name, name, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(NOT  _ancestor_of( $3, $4, $1, $2, $5 ), $6 );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(NOT  _ancestor_of( $3, $4, $1, $2, NULL ), $5 );

isnt_descendent_of

Signature: evergreen.isnt_descendent_of(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(NOT  _ancestor_of( $2, $1, NULL ), $3 );

isnt_empty

Signature: evergreen.isnt_empty(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isnt_empty( $1, NULL );

isnt_empty

Signature: evergreen.isnt_empty(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    res  BOOLEAN := FALSE;
    rec  RECORD;
BEGIN
    -- Find extra records.
    FOR rec in EXECUTE _query($1) LOOP
        res := TRUE;
        EXIT;
    END LOOP;

    RETURN ok(res, $2);
END;

isnt_partitioned

Signature: evergreen.isnt_partitioned(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _rexists('p', $1),
        'Table ' || quote_ident($1) || ' should not be partitioned'
    );

isnt_partitioned

Signature: evergreen.isnt_partitioned(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _rexists('p', $1, $2),
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should not be partitioned'
    );

isnt_partitioned

Signature: evergreen.isnt_partitioned(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists('p', $1, $2), $3);

isnt_partitioned

Signature: evergreen.isnt_partitioned(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _rexists('p', $1), $2);

isnt_strict

Signature: evergreen.isnt_strict(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( NOT _strict($1), 'Function ' || quote_ident($1) || '() should not be strict' );

isnt_strict

Signature: evergreen.isnt_strict(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _strict($1, $2),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '() should not be strict'
    );

isnt_strict

Signature: evergreen.isnt_strict(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _strict($1, $2, $3),
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should not be strict'
    );

isnt_strict

Signature: evergreen.isnt_strict(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, NOT _strict($1, $2, $3), $4 );

isnt_strict

Signature: evergreen.isnt_strict(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, NOT _strict($1, $2), $3 );

isnt_strict

Signature: evergreen.isnt_strict(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok(
        NOT _strict($1, $2),
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should not be strict'
    );

isnt_strict

Signature: evergreen.isnt_strict(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, NOT _strict($1, $2), $3 );

isnt_strict

Signature: evergreen.isnt_strict(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, NOT _strict($1), $2 );

isnt_superuser

Signature: evergreen.isnt_superuser(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT isnt_superuser( $1, 'User ' || quote_ident($1) || ' should not be a super user' );

isnt_superuser

Signature: evergreen.isnt_superuser(name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    is_super boolean := _is_super($1);
BEGIN
    IF is_super IS NULL THEN
        RETURN fail( $2 ) || E'\n' || diag( '    User ' || quote_ident($1) || ' does not exist') ;
    END IF;
    RETURN ok( NOT is_super, $2 );
END;

json_delta

Signature: evergreen.json_delta(old_obj json, new_obj json, only_keys text[] DEFAULT '{}'::text[])

Returns: jsonb

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
use JSON;
use List::Util qw/uniq/;

my $old = shift;
my $new = shift;
my $keylist = shift;

$old = from_json($old) if (!ref($old));
$new = from_json($new) if (!ref($new));

my $delta = {};

my @keys = @$keylist;
@keys = (keys(%$old), keys(%$new)) if (!@keys);

for my $key (uniq @keys) {
    $$delta{$key} = [$$old{$key},$$new{$key}] if ((
        ((!exists($$old{$key}) or !exists($$new{$key})) and not (!exists($$old{$key}) and !exists($$new{$key}))) # one exists
        or ((!defined($$old{$key}) or !defined($$new{$key})) and not (!defined($$old{$key}) and !defined($$new{$key}))) # or one is defined
        or ((defined($$old{$key}) and defined($$new{$key})) and $$old{$key} ne $$new{$key}) # or they do not match
    ) and grep {defined} $$old{$key},$$new{$key}); # there is data
}

return to_json($delta);

language_is_trusted

Signature: evergreen.language_is_trusted(name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT language_is_trusted($1, 'Procedural language ' || quote_ident($1) || ' should be trusted' );

language_is_trusted

Signature: evergreen.language_is_trusted(name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    is_trusted boolean := _is_trusted($1);
BEGIN
    IF is_trusted IS NULL THEN
        RETURN fail( $2 ) || E'\n' || diag( '    Procedural language ' || quote_ident($1) || ' does not exist') ;
    END IF;
    RETURN ok( is_trusted, $2 );
END;

language_owner_is

Signature: evergreen.language_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT language_owner_is(
        $1, $2,
        'Language ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

language_owner_is

Signature: evergreen.language_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_language_owner($1);
BEGIN
    -- Make sure the language exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Language ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

language_privs_are

Signature: evergreen.language_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT language_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on language ' || quote_ident($1)
    );

language_privs_are

Signature: evergreen.language_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_lang_privs( $2, quote_ident($1) );
BEGIN
    IF grants[1] = 'undefined_language' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Language ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

languages_are

Signature: evergreen.languages_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT languages_are( $1, 'There should be the correct procedural languages' );

languages_are

Signature: evergreen.languages_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'languages',
        ARRAY(
            SELECT lanname
              FROM pg_catalog.pg_language
             WHERE lanispl
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT lanname
              FROM pg_catalog.pg_language
             WHERE lanispl
        ),
        $2
    );

levenshtein_damerau_edistance

Signature: evergreen.levenshtein_damerau_edistance(a text, b text, integer)

Returns: numeric

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
use Text::Levenshtein::Damerau::XS qw/xs_edistance/;
return xs_edistance(@_);

limit_oustl

Signature: evergreen.limit_oustl()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    BEGIN
        -- Only keeps the most recent five settings changes.
        DELETE FROM config.org_unit_setting_type_log WHERE field_name = NEW.field_name AND org = NEW.org AND date_applied NOT IN
        (SELECT date_applied FROM config.org_unit_setting_type_log WHERE field_name = NEW.field_name AND org = NEW.org ORDER BY date_applied DESC LIMIT 4);

        IF (TG_OP = 'UPDATE') THEN
            RETURN NEW;
        ELSIF (TG_OP = 'INSERT') THEN
            RETURN NEW;
        END IF;
        RETURN NULL;
    END;

lives_ok

Signature: evergreen.lives_ok(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT lives_ok( $1, NULL );

lives_ok

Signature: evergreen.lives_ok(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    code  TEXT := _query($1);
    descr ALIAS FOR $2;
    detail  text;
    hint    text;
    context text;
    schname text;
    tabname text;
    colname text;
    chkname text;
    typname text;
BEGIN
    EXECUTE code;
    RETURN ok( TRUE, descr );
EXCEPTION WHEN OTHERS OR ASSERT_FAILURE THEN
    -- There should have been no exception.
    GET STACKED DIAGNOSTICS
        detail  = PG_EXCEPTION_DETAIL,
        hint    = PG_EXCEPTION_HINT,
        context = PG_EXCEPTION_CONTEXT,
        schname = SCHEMA_NAME,
        tabname = TABLE_NAME,
        colname = COLUMN_NAME,
        chkname = CONSTRAINT_NAME,
        typname = PG_DATATYPE_NAME;
    RETURN ok( FALSE, descr ) || E'\n' || diag(
           '    died: ' || _error_diag(SQLSTATE, SQLERRM, detail, hint, context, schname, tabname, colname, chkname, typname)
    );
END;

located_uris

Signature: evergreen.located_uris(bibid bigint, ouid integer, pref_lib integer DEFAULT NULL::integer)

Returns: TABLE(id bigint, name text, label_sortkey text, rank integer)

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
 SELECT * FROM evergreen.located_uris(ARRAY[$1],$2,$3)

located_uris

Signature: evergreen.located_uris(bibid bigint[], ouid integer, pref_lib integer DEFAULT NULL::integer)

Returns: TABLE(id bigint, name text, label_sortkey text, rank integer)

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    WITH all_orgs AS (SELECT COALESCE( enabled, FALSE ) AS flag FROM config.global_flag WHERE name = 'opac.located_uri.act_as_copy')
    SELECT DISTINCT ON (id) * FROM (
    SELECT acn.id, COALESCE(aou.name,aoud.name), acn.label_sortkey, evergreen.rank_ou(aou.id, $2, $3) AS pref_ou
      FROM asset.call_number acn
           INNER JOIN asset.uri_call_number_map auricnm ON acn.id = auricnm.call_number
           INNER JOIN asset.uri auri ON auri.id = auricnm.uri
           LEFT JOIN actor.org_unit_ancestors( COALESCE($3, $2) ) aou ON (acn.owning_lib = aou.id)
           LEFT JOIN actor.org_unit_descendants( COALESCE($3, $2) ) aoud ON (acn.owning_lib = aoud.id),
           all_orgs
      WHERE acn.record = ANY ($1)
          AND acn.deleted IS FALSE
          AND auri.active IS TRUE
          AND ((NOT all_orgs.flag AND aou.id IS NOT NULL) OR (all_orgs.flag AND COALESCE(aou.id,aoud.id) IS NOT NULL))
    UNION
    SELECT acn.id, COALESCE(aou.name,aoud.name) AS name, acn.label_sortkey, evergreen.rank_ou(aou.id, $2, $3) AS pref_ou
      FROM asset.call_number acn
           INNER JOIN asset.uri_call_number_map auricnm ON acn.id = auricnm.call_number
           INNER JOIN asset.uri auri ON auri.id = auricnm.uri
           LEFT JOIN actor.org_unit_ancestors( $2 ) aou ON (acn.owning_lib = aou.id)
           LEFT JOIN actor.org_unit_descendants( $2 ) aoud ON (acn.owning_lib = aoud.id),
           all_orgs
      WHERE acn.record = ANY ($1)
          AND acn.deleted IS FALSE
          AND auri.active IS TRUE
          AND ((NOT all_orgs.flag AND aou.id IS NOT NULL) OR (all_orgs.flag AND COALESCE(aou.id,aoud.id) IS NOT NULL)))x
    ORDER BY id, pref_ou DESC;

located_uris_as_uris

Signature: evergreen.located_uris_as_uris(bibid bigint, ouid integer, pref_lib integer DEFAULT NULL::integer)

Returns: SETOF asset.uri

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    /* Maps a bib directly to its scoped asset.uri's */

    SELECT uri.*
    FROM evergreen.located_uris($1, $2, $3) located_uri
    JOIN asset.uri_call_number_map map ON (map.call_number = located_uri.id)
    JOIN asset.uri uri ON (uri.id = map.uri)

lowercase

Signature: evergreen.lowercase(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    return lc(shift);

lpad_number_substrings

Signature: evergreen.lpad_number_substrings(text, text, integer)

Returns: text

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    my $string = shift;            # Source string
    my $pad = shift;               # string to fill. Typically '0'. This should be a single character.
    my $len = shift;               # length of resultant padded field

    $string =~ s/([0-9]+)/$pad x ($len - length($1)) . $1/eg;

    return $string;

maintain_901

Signature: evergreen.maintain_901()

Returns: trigger

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
use strict;
use MARC::Record;
use MARC::File::XML (BinaryEncoding => 'UTF-8');
use MARC::Charset;
use Encode;
use Unicode::Normalize;

MARC::Charset->assume_unicode(1);

my $schema = $_TD->{table_schema};
my $marc = MARC::Record->new_from_xml($_TD->{new}{marc});

my @old901s = $marc->field('901');
$marc->delete_fields(@old901s);

if ($schema eq 'biblio') {
    my $tcn_value = $_TD->{new}{tcn_value};

    # Set TCN value to record ID?
    my $id_as_tcn = spi_exec_query("
        SELECT enabled
        FROM config.global_flag
        WHERE name = 'cat.bib.use_id_for_tcn'
    ");
    if (($id_as_tcn->{processed}) && $id_as_tcn->{rows}[0]->{enabled} eq 't') {
        $tcn_value = $_TD->{new}{id};
        $_TD->{new}{tcn_value} = $tcn_value;
    }

    my $new_901 = MARC::Field->new("901", " ", " ",
        "a" => $tcn_value,
        "b" => $_TD->{new}{tcn_source},
        "c" => $_TD->{new}{id},
        "t" => $schema
    );

    if ($_TD->{new}{owner}) {
        $new_901->add_subfields("o" => $_TD->{new}{owner});
    }

    if ($_TD->{new}{share_depth}) {
        $new_901->add_subfields("d" => $_TD->{new}{share_depth});
    }

    if ($_TD->{new}{source}) {
        my $plan = spi_prepare('
            SELECT source
            FROM config.bib_source
            WHERE id = $1
        ', 'INTEGER');
        my $source_name =
            spi_exec_prepared($plan, {limit => 1}, $_TD->{new}{source})->{rows}[0]{source};
        spi_freeplan($plan);
        $new_901->add_subfields("s" => $source_name) if $source_name;
    }

    $marc->append_fields($new_901);
} elsif ($schema eq 'authority') {
    my $new_901 = MARC::Field->new("901", " ", " ",
        "c" => $_TD->{new}{id},
        "t" => $schema,
    );
    $marc->append_fields($new_901);
} elsif ($schema eq 'serial') {
    my $new_901 = MARC::Field->new("901", " ", " ",
        "c" => $_TD->{new}{id},
        "t" => $schema,
        "o" => $_TD->{new}{owning_lib},
    );

    if ($_TD->{new}{record}) {
        $new_901->add_subfields("r" => $_TD->{new}{record});
    }

    $marc->append_fields($new_901);
} else {
    my $new_901 = MARC::Field->new("901", " ", " ",
        "c" => $_TD->{new}{id},
        "t" => $schema,
    );
    $marc->append_fields($new_901);
}

my $xml = $marc->as_xml_record();
$xml =~ s/\n//sgo;
$xml =~ s/^<\?xml.+\?\s*>//go;
$xml =~ s/>\s+</></go;
$xml =~ s/\p{Cc}//go;

# Embed a version of OpenILS::Application::AppUtils->entityize()
# to avoid having to set PERL5LIB for PostgreSQL as well

$xml = NFC($xml);

# Convert raw ampersands to entities
$xml =~ s/&(?!\S+;)/&amp;/gso;

# Convert Unicode characters to entities
$xml =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;

$xml =~ s/[\x00-\x1f]//go;
$_TD->{new}{marc} = $xml;

return "MODIFY";

maintain_control_numbers

Signature: evergreen.maintain_control_numbers()

Returns: trigger

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
use strict;
use MARC::Record;
use MARC::File::XML (BinaryEncoding => 'UTF-8');
use MARC::Charset;
use Encode;
use Unicode::Normalize;

MARC::Charset->assume_unicode(1);

my $record = MARC::Record->new_from_xml($_TD->{new}{marc});
my $schema = $_TD->{table_schema};
my $rec_id = $_TD->{new}{id};

# Short-circuit if maintaining control numbers per MARC21 spec is not enabled
my $enable = spi_exec_query("SELECT enabled FROM config.global_flag WHERE name = 'cat.maintain_control_numbers'");
if (!($enable->{processed}) or $enable->{rows}[0]->{enabled} eq 'f') {
    return;
}

# Get the control number identifier from an OU setting based on $_TD->{new}{owner}
my $ou_cni = 'EVRGRN';

my $owner;
if ($schema eq 'serial') {
    $owner = $_TD->{new}{owning_lib};
} else {
    # are.owner and bre.owner can be null, so fall back to the consortial setting
    $owner = $_TD->{new}{owner} || 1;
}

my $ous_rv = spi_exec_query("SELECT value FROM actor.org_unit_ancestor_setting('cat.marc_control_number_identifier', $owner)");
if ($ous_rv->{processed}) {
    $ou_cni = $ous_rv->{rows}[0]->{value};
    $ou_cni =~ s/"//g; # Stupid VIM syntax highlighting"
} else {
    # Fall back to the shortname of the OU if there was no OU setting
    $ous_rv = spi_exec_query("SELECT shortname FROM actor.org_unit WHERE id = $owner");
    if ($ous_rv->{processed}) {
        $ou_cni = $ous_rv->{rows}[0]->{shortname};
    }
}

my ($create, $munge) = (0, 0);

my @scns = $record->field('035');

foreach my $id_field ('001', '003') {
    my $spec_value;
    my @controls = $record->field($id_field);

    if ($id_field eq '001') {
        $spec_value = $rec_id;
    } else {
        $spec_value = $ou_cni;
    }

    # Create the 001/003 if none exist
    if (scalar(@controls) == 1) {
        # Only one field; check to see if we need to munge it
        unless (grep $_->data() eq $spec_value, @controls) {
            $munge = 1;
        }
    } else {
        # Delete the other fields, as with more than 1 001/003 we do not know which 003/001 to match
        foreach my $control (@controls) {
            $record->delete_field($control);
        }
        $record->insert_fields_ordered(MARC::Field->new($id_field, $spec_value));
        $create = 1;
    }
}

my $cn = $record->field('001')->data();
# Special handling of OCLC numbers, often found in records that lack 003
if ($cn =~ /^o(c[nm]|n)\d/) {
    $cn =~ s/^o(c[nm]|n)0*(\d+)/$2/;
    $record->field('003')->data('OCoLC');
    $create = 0;
}

# Now, if we need to munge the 001, we will first push the existing 001/003
# into the 035; but if the record did not have one (and one only) 001 and 003
# to begin with, skip this process
if ($munge and not $create) {

    my $scn = "(" . $record->field('003')->data() . ")" . $cn;

    # Do not create duplicate 035 fields
    unless (grep $_->subfield('a') eq $scn, @scns) {
        $record->insert_fields_ordered(MARC::Field->new('035', '', '', 'a' => $scn));
    }
}

# Set the 001/003 and update the MARC
if ($create or $munge) {
    $record->field('001')->data($rec_id);
    $record->field('003')->data($ou_cni);

    my $xml = $record->as_xml_record();
    $xml =~ s/\n//sgo;
    $xml =~ s/^<\?xml.+\?\s*>//go;
    $xml =~ s/>\s+</></go;
    $xml =~ s/\p{Cc}//go;

    # Embed a version of OpenILS::Application::AppUtils->entityize()
    # to avoid having to set PERL5LIB for PostgreSQL as well

    $xml = NFC($xml);

    # Convert raw ampersands to entities
    $xml =~ s/&(?!\S+;)/&amp;/gso;

    # Convert Unicode characters to entities
    $xml =~ s/([\x{0080}-\x{fffd}])/sprintf('&#x%X;',ord($1))/sgoe;

    $xml =~ s/[\x00-\x1f]//go;
    $_TD->{new}{marc} = $xml;

    return "MODIFY";
}

return;

marc_to

Signature: evergreen.marc_to(marc text, xfrm text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT evergreen.xml_pretty_print(xslt_process($1,xslt)::XML)::TEXT FROM config.xml_transform WHERE name = $2;

matches

Signature: evergreen.matches(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~ $2, $1, $2, NULL );

matches

Signature: evergreen.matches(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _alike( $1 ~ $2, $1, $2, $3 );

materialized_view_owner_is

Signature: evergreen.materialized_view_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT materialized_view_owner_is(
        $1, $2,
        'Materialized view ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

materialized_view_owner_is

Signature: evergreen.materialized_view_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT materialized_view_owner_is(
        $1, $2, $3,
        'Materialized view ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

materialized_view_owner_is

Signature: evergreen.materialized_view_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('m'::char, $1, $2);
BEGIN
    -- Make sure the materialized view exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Materialized view ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

materialized_view_owner_is

Signature: evergreen.materialized_view_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('m'::char, $1);
BEGIN
    -- Make sure the materialized view exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Materialized view ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

materialized_views_are

Signature: evergreen.materialized_views_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'Materialized views', _extras('m', $1, $2), _missing('m', $1, $2),
        'Schema ' || quote_ident($1) || ' should have the correct materialized views'
    );

materialized_views_are

Signature: evergreen.materialized_views_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'Materialized views', _extras('m', $1, $2), _missing('m', $1, $2), $3);

materialized_views_are

Signature: evergreen.materialized_views_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'Materialized views', _extras('m', $1), _missing('m', $1),
        'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct materialized views'
    );

materialized_views_are

Signature: evergreen.materialized_views_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'Materialized views', _extras('m', $1), _missing('m', $1), $2);

no_plan

Signature: evergreen.no_plan()

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
BEGIN
    PERFORM plan(0);
    RETURN;
END;

num_failed

Signature: evergreen.num_failed()

Returns: integer

Language

sql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    SELECT _get('failed');

oils_i18n_code_tracking

Signature: evergreen.oils_i18n_code_tracking()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM oils_i18n_update_apply( OLD.code::TEXT, NEW.code::TEXT, TG_ARGV[0]::TEXT );
    RETURN NEW;
END;

oils_i18n_gettext

Signature: evergreen.oils_i18n_gettext(integer, text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT $2;

oils_i18n_gettext

Signature: evergreen.oils_i18n_gettext(text, text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT $2;

oils_i18n_id_tracking

Signature: evergreen.oils_i18n_id_tracking()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM oils_i18n_update_apply( OLD.id::TEXT, NEW.id::TEXT, TG_ARGV[0]::TEXT );
    RETURN NEW;
END;

oils_i18n_update_apply

Signature: evergreen.oils_i18n_update_apply(old_ident text, new_ident text, hint text)

Returns: void

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN

    EXECUTE $$
        UPDATE  config.i18n_core
          SET   identity_value = $$ || quote_literal(new_ident) || $$
          WHERE fq_field LIKE '$$ || hint || $$.%'
                AND identity_value = $$ || quote_literal(old_ident) || $$::TEXT;$$;

    RETURN;

END;

oils_i18n_xlate

Signature: evergreen.oils_i18n_xlate(keytable text, keyclass text, keycol text, identcol text, keyvalue text, raw_locale text)

Returns: text

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    locale      TEXT := REGEXP_REPLACE( REGEXP_REPLACE( raw_locale, E'[;, ].+$', '' ), E'_', '-', 'g' );
    language    TEXT := REGEXP_REPLACE( locale, E'-.+$', '' );
    result      config.i18n_core%ROWTYPE;
    fallback    TEXT;
    keyfield    TEXT := keyclass || '.' || keycol;
BEGIN

    -- Try the full locale
    SELECT  * INTO result
      FROM  config.i18n_core
      WHERE fq_field = keyfield
            AND identity_value = keyvalue
            AND translation = locale;

    -- Try just the language
    IF NOT FOUND THEN
        SELECT  * INTO result
          FROM  config.i18n_core
          WHERE fq_field = keyfield
                AND identity_value = keyvalue
                AND translation = language;
    END IF;

    -- Fall back to the string we passed in in the first place
    IF NOT FOUND THEN
	EXECUTE
            'SELECT ' ||
                keycol ||
            ' FROM ' || keytable ||
            ' WHERE ' || identcol || ' = ' || quote_literal(keyvalue)
                INTO fallback;
        RETURN fallback;
    END IF;

    RETURN result.string;
END;

oils_json_to_text

Signature: evergreen.oils_json_to_text(text)

Returns: text

Language

plperlu

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    use JSON::XS;
    my $json = shift();
    my $txt;
    eval { $txt = JSON::XS->new->allow_nonref->decode( $json ) };
    return undef if ($@);
    return $txt

oils_text_as_bytea

Signature: evergreen.oils_text_as_bytea(text)

Returns: bytea

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT CAST(REGEXP_REPLACE(UPPER($1), $$\\$$, $$\\\\$$, 'g') AS BYTEA);

oils_xpath

Signature: evergreen.oils_xpath(text, text)

Returns: text[]

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT  ARRAY_AGG(
                CASE WHEN strpos(x,'<') = 1 THEN -- It's an element node
                    x
                ELSE -- it's text-ish
                    evergreen.xml_famous5_to_text(x)
                END
            )
      FROM  UNNEST(XPATH( $1, $2::XML)::TEXT[]) x;

oils_xpath

Signature: evergreen.oils_xpath(text, text, text[])

Returns: text[]

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT  ARRAY_AGG(
                CASE WHEN strpos(x,'<') = 1 THEN -- It's an element node
                    x
                ELSE -- it's text-ish
                    evergreen.xml_famous5_to_text(x)
                END
            )
      FROM  UNNEST(XPATH( $1, $2::XML, $3 )::TEXT[]) x;

oils_xpath_string

Signature: evergreen.oils_xpath_string(text, text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT oils_xpath_string( $1, $2, '{}'::TEXT[] );

oils_xpath_string

Signature: evergreen.oils_xpath_string(text, text, anyarray)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT oils_xpath_string( $1, $2, '', $3 );

oils_xpath_string

Signature: evergreen.oils_xpath_string(text, text, text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT oils_xpath_string( $1, $2, $3, '{}'::TEXT[] );

oils_xpath_string

Signature: evergreen.oils_xpath_string(text, text, text, anyarray)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT  ARRAY_TO_STRING(
                oils_xpath(
                    $1 ||
                        CASE WHEN $1 ~ $re$/[^/[]*@[^]]+$$re$ OR $1 ~ $re$\)$$re$ THEN '' ELSE '//text()' END,
                    $2,
                    $4
                ),
                $3
            );

oils_xpath_table

Signature: evergreen.oils_xpath_table(key text, document_field text, relation_name text, xpaths text, criteria text)

Returns: SETOF record

Language

plpgsql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
DECLARE
    xpath_list  TEXT[];
    select_list TEXT[];
    where_list  TEXT[];
    q           TEXT;
    out_record  RECORD;
    empty_test  RECORD;
BEGIN
    xpath_list := STRING_TO_ARRAY( xpaths, '|' );

    select_list := ARRAY_APPEND( select_list, key || '::INT AS key' );

    FOR i IN 1 .. ARRAY_UPPER(xpath_list,1) LOOP
        IF xpath_list[i] = 'null()' THEN
            select_list := ARRAY_APPEND( select_list, 'NULL::TEXT AS c_' || i );
        ELSE
            select_list := ARRAY_APPEND(
                select_list,
                $sel$
                unnest(
                    COALESCE(
                        NULLIF(
                            oils_xpath(
                                $sel$ ||
                                    quote_literal(
                                        CASE
                                            WHEN xpath_list[i] ~ $re$/[^/[]*@[^/]+$$re$ OR xpath_list[i] ~ $re$text\(\)$$re$ THEN xpath_list[i]
                                            ELSE xpath_list[i] || '//text()'
                                        END
                                    ) ||
                                $sel$,
                                $sel$ || document_field || $sel$
                            ),
                           '{}'::TEXT[]
                        ),
                        '{NULL}'::TEXT[]
                    )
                ) AS c_$sel$ || i
            );
            where_list := ARRAY_APPEND(
                where_list,
                'c_' || i || ' IS NOT NULL'
            );
        END IF;
    END LOOP;

    q := $q$
SELECT * FROM (
    SELECT $q$ || ARRAY_TO_STRING( select_list, ', ' ) || $q$ FROM $q$ || relation_name || $q$ WHERE ($q$ || criteria || $q$)
)x WHERE $q$ || ARRAY_TO_STRING( where_list, ' OR ' );
    -- RAISE NOTICE 'query: %', q;

    FOR out_record IN EXECUTE q LOOP
        RETURN NEXT out_record;
    END LOOP;

    RETURN;
END;

oils_xpath_tag_to_table

Signature: evergreen.oils_xpath_tag_to_table(marc text, tag text, xpaths text[])

Returns: SETOF record

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
-- This function currently populates columns with the FIRST matching value
-- of each XPATH.  It would be reasonable to add a 'return_arrays' option
-- where each column is an array of all matching values for each path, but
-- that remains as a TODO

DECLARE
    field RECORD;
    output RECORD;
    select_list TEXT[];
    from_list TEXT[];
    q TEXT;
BEGIN
    -- setup query select
    FOR i IN 1 .. ARRAY_UPPER(xpaths,1) LOOP
        IF xpaths[i] = 'null()' THEN
            select_list := ARRAY_APPEND(select_list, 'NULL::TEXT AS c_' || i );
        ELSE
            select_list := ARRAY_APPEND(select_list, '(oils_xpath(' ||
                quote_literal(
                    CASE
                        WHEN xpaths[i] ~ $re$/[^/[]*@[^/]+$$re$ -- attribute
                            OR xpaths[i] ~ $re$text\(\)$$re$
                        THEN xpaths[i]
                        ELSE xpaths[i] || '//text()'
                    END
                ) || ', field_marc))[1] AS cl_' || i);
                -- hardcoded to first value for each path
        END IF;
    END LOOP;

    -- run query over tag set
    q := 'SELECT ' || ARRAY_TO_STRING(select_list, ',')
        || ' FROM UNNEST(oils_xpath(' || quote_literal('//*[@tag="' || tag
        || '"]') || ', ' || quote_literal(marc) || ')) AS field_marc;';
    --RAISE NOTICE '%', q;

    RETURN QUERY EXECUTE q;
END;

oils_xslt_process

Signature: evergreen.oils_xslt_process(text, text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
  use strict;

  use XML::LibXSLT;
  use XML::LibXML;

  my $doc = shift;
  my $xslt = shift;

  # The following approach uses the older XML::LibXML 1.69 / XML::LibXSLT 1.68
  # methods of parsing XML documents and stylesheets, in the hopes of broader
  # compatibility with distributions
  my $parser = $_SHARED{'_xslt_process'}{parsers}{xml} || XML::LibXML->new();

  # Cache the XML parser, if we do not already have one
  $_SHARED{'_xslt_process'}{parsers}{xml} = $parser
    unless ($_SHARED{'_xslt_process'}{parsers}{xml});

  my $xslt_parser = $_SHARED{'_xslt_process'}{parsers}{xslt} || XML::LibXSLT->new();

  # Cache the XSLT processor, if we do not already have one
  $_SHARED{'_xslt_process'}{parsers}{xslt} = $xslt_parser
    unless ($_SHARED{'_xslt_process'}{parsers}{xslt});

  my $stylesheet = $_SHARED{'_xslt_process'}{stylesheets}{$xslt} ||
    $xslt_parser->parse_stylesheet( $parser->parse_string($xslt) );

  $_SHARED{'_xslt_process'}{stylesheets}{$xslt} = $stylesheet
    unless ($_SHARED{'_xslt_process'}{stylesheets}{$xslt});

  return $stylesheet->output_as_chars(
    $stylesheet->transform(
      $parser->parse_string($doc)
    )
  );

ok

Signature: evergreen.ok(boolean)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( $1, NULL );

ok

Signature: evergreen.ok(boolean, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
   aok      ALIAS FOR $1;
   descr    text := $2;
   test_num INTEGER;
   todo_why TEXT;
   ok       BOOL;
BEGIN
   todo_why := _todo();
   ok       := CASE
       WHEN aok = TRUE THEN aok
       WHEN todo_why IS NULL THEN COALESCE(aok, false)
       ELSE TRUE
    END;
    IF _get('plan') IS NULL THEN
        RAISE EXCEPTION 'You tried to run a test without a plan! Gotta have a plan';
    END IF;

    test_num := add_result(
        ok,
        COALESCE(aok, false),
        descr,
        CASE WHEN todo_why IS NULL THEN '' ELSE 'todo' END,
        COALESCE(todo_why, '')
    );

    RETURN (CASE aok WHEN TRUE THEN '' ELSE 'not ' END)
           || 'ok ' || _set( 'curr_test', test_num )
           || CASE descr WHEN '' THEN '' ELSE COALESCE( ' - ' || substr(diag( descr ), 3), '' ) END
           || COALESCE( ' ' || diag( 'TODO ' || todo_why ), '')
           || CASE aok WHEN TRUE THEN '' ELSE E'\n' ||
                diag('Failed ' ||
                CASE WHEN todo_why IS NULL THEN '' ELSE '(TODO) ' END ||
                'test ' || test_num ||
                CASE descr WHEN '' THEN '' ELSE COALESCE(': "' || descr || '"', '') END ) ||
                CASE WHEN aok IS NULL THEN E'\n' || diag('    (test result was NULL)') ELSE '' END
           END;
END;

opclass_owner_is

Signature: evergreen.opclass_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT opclass_owner_is(
        $1, $2,
        'Operator class ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

opclass_owner_is

Signature: evergreen.opclass_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT opclass_owner_is(
        $1, $2, $3,
        'Operator class ' || quote_ident($1) || '.' || quote_ident($2) ||
        ' should be owned by ' || quote_ident($3)
    );

opclass_owner_is

Signature: evergreen.opclass_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_opclass_owner($1, $2);
BEGIN
    -- Make sure the opclass exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Operator class ' || quote_ident($1) || '.' || quote_ident($2)
            || ' not found'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

opclass_owner_is

Signature: evergreen.opclass_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_opclass_owner($1);
BEGIN
    -- Make sure the opclass exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Operator class ' || quote_ident($1) || ' not found'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

opclasses_are

Signature: evergreen.opclasses_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT opclasses_are( $1, $2, 'Schema ' || quote_ident($1) || ' should have the correct operator classes' );

opclasses_are

Signature: evergreen.opclasses_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'operator classes',
        ARRAY(
            SELECT oc.opcname
              FROM pg_catalog.pg_opclass oc
              JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
             WHERE n.nspname  = $1
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
               FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT oc.opcname
              FROM pg_catalog.pg_opclass oc
              JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
             WHERE n.nspname  = $1
        ),
        $3
    );

opclasses_are

Signature: evergreen.opclasses_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT opclasses_are( $1, 'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct operator classes' );

opclasses_are

Signature: evergreen.opclasses_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'operator classes',
        ARRAY(
            SELECT oc.opcname
              FROM pg_catalog.pg_opclass oc
              JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_opclass_is_visible(oc.oid)
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
               FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT oc.opcname
              FROM pg_catalog.pg_opclass oc
              JOIN pg_catalog.pg_namespace n ON oc.opcnamespace = n.oid
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_opclass_is_visible(oc.oid)
        ),
        $2
    );

operators_are

Signature: evergreen.operators_are(name, text[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT operators_are($1, $2, 'Schema ' || quote_ident($1) || ' should have the correct operators' );

operators_are

Signature: evergreen.operators_are(name, text[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _areni(
        'operators',
        ARRAY(
            SELECT display_oper(o.oprname, o.oid) || ' RETURNS ' || o.oprresult::regtype
              FROM pg_catalog.pg_operator o
              JOIN pg_catalog.pg_namespace n ON o.oprnamespace = n.oid
             WHERE n.nspname = $1
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT display_oper(o.oprname, o.oid) || ' RETURNS ' || o.oprresult::regtype
              FROM pg_catalog.pg_operator o
              JOIN pg_catalog.pg_namespace n ON o.oprnamespace = n.oid
             WHERE n.nspname = $1
        ),
        $3
    );

operators_are

Signature: evergreen.operators_are(text[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT operators_are($1, 'There should be the correct operators')

operators_are

Signature: evergreen.operators_are(text[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _areni(
        'operators',
        ARRAY(
            SELECT display_oper(o.oprname, o.oid) || ' RETURNS ' || o.oprresult::regtype
              FROM pg_catalog.pg_operator o
              JOIN pg_catalog.pg_namespace n ON o.oprnamespace = n.oid
             WHERE pg_catalog.pg_operator_is_visible(o.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT display_oper(o.oprname, o.oid) || ' RETURNS ' || o.oprresult::regtype
              FROM pg_catalog.pg_operator o
              JOIN pg_catalog.pg_namespace n ON o.oprnamespace = n.oid
             WHERE pg_catalog.pg_operator_is_visible(o.oid)
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
        ),
        $2
    );

org_top

Signature: evergreen.org_top()

Returns: actor.org_unit

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT * FROM actor.org_unit WHERE parent_ou IS NULL LIMIT 1;

os_name

Signature: evergreen.os_name()

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
SELECT 'linux'::text;

ous_change_log

Signature: evergreen.ous_change_log()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    DECLARE
    original TEXT;
    BEGIN
        -- Check for which setting is being updated, and log it.
        SELECT INTO original value FROM actor.org_unit_setting WHERE name = NEW.name AND org_unit = NEW.org_unit;

        INSERT INTO config.org_unit_setting_type_log (org,original_value,new_value,field_name) VALUES (NEW.org_unit, original, NEW.value, NEW.name);

        RETURN NEW;
    END;

ous_delete_log

Signature: evergreen.ous_delete_log()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    DECLARE
    original TEXT;
    BEGIN
        -- Check for which setting is being updated, and log it.
        SELECT INTO original value FROM actor.org_unit_setting WHERE name = OLD.name AND org_unit = OLD.org_unit;

        INSERT INTO config.org_unit_setting_type_log (org,original_value,new_value,field_name) VALUES (OLD.org_unit, original, 'null', OLD.name);

        RETURN OLD;
    END;

partitions_are

Signature: evergreen.partitions_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT partitions_are(
        $1, $2, $3,
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct partitions'
    );

partitions_are

Signature: evergreen.partitions_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'partitions',
        ARRAY(SELECT _parts($1, $2) EXCEPT SELECT unnest($3)),
        ARRAY(SELECT unnest($3) EXCEPT SELECT _parts($1, $2)),
        $4
    );

partitions_are

Signature: evergreen.partitions_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT partitions_are(
        $1, $2,
        'Table ' || quote_ident($1) || ' should have the correct partitions'
    );

partitions_are

Signature: evergreen.partitions_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'partitions',
        ARRAY(SELECT _parts($1) EXCEPT SELECT unnest($2)),
        ARRAY(SELECT unnest($2) EXCEPT SELECT _parts($1)),
        $3
    );

pass

Signature: evergreen.pass()

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( TRUE, NULL );

pass

Signature: evergreen.pass(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( TRUE, $1 );

performs_ok

Signature: evergreen.performs_ok(text, numeric)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT performs_ok(
        $1, $2, 'Should run in less than ' || $2 || ' ms'
    );

performs_ok

Signature: evergreen.performs_ok(text, numeric, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    query     TEXT := _query($1);
    max_time  ALIAS FOR $2;
    descr     ALIAS FOR $3;
    starts_at TEXT;
    act_time  NUMERIC;
BEGIN
    starts_at := timeofday();
    EXECUTE query;
    act_time := extract( millisecond from timeofday()::timestamptz - starts_at::timestamptz);
    IF act_time < max_time THEN RETURN ok(TRUE, descr); END IF;
    RETURN ok( FALSE, descr ) || E'\n' || diag(
           '      runtime: ' || act_time || ' ms' ||
        E'\n      exceeds: ' || max_time || ' ms'
    );
END;

performs_within

Signature: evergreen.performs_within(text, numeric, numeric)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT performs_within(
          $1, $2, $3, 10,
          'Should run within ' || $2 || ' +/- ' || $3 || ' ms');

performs_within

Signature: evergreen.performs_within(text, numeric, numeric, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT performs_within(
          $1, $2, $3, $4,
          'Should run within ' || $2 || ' +/- ' || $3 || ' ms');

performs_within

Signature: evergreen.performs_within(text, numeric, numeric, integer, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    query          TEXT := _query($1);
    expected_avg   ALIAS FOR $2;
    within         ALIAS FOR $3;
    iterations     ALIAS FOR $4;
    descr          ALIAS FOR $5;
    avg_time       NUMERIC;
BEGIN
  SELECT avg(a_time) FROM _time_trials(query, iterations, 0.8) t1 INTO avg_time;
  IF abs(avg_time - expected_avg) < within THEN RETURN ok(TRUE, descr); END IF;
  RETURN ok(FALSE, descr) || E'\n' || diag(' average runtime: ' || avg_time || ' ms'
     || E'\n desired average: ' || expected_avg || ' +/- ' || within || ' ms'
    );
END;

performs_within

Signature: evergreen.performs_within(text, numeric, numeric, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT performs_within(
          $1, $2, $3, 10, $4
        );

pg_statistics

Signature: evergreen.pg_statistics(tab text, col text)

Returns: TABLE(element text, frequency integer)

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    -- This query will die on PG < 9.2, but the function can be created. We just won't use it where we can't.
    RETURN QUERY
        SELECT  e,
                f
          FROM  (SELECT ROW_NUMBER() OVER (),
                        (f * 100)::INT AS f
                  FROM  (SELECT UNNEST(most_common_elem_freqs) AS f
                          FROM  pg_stats
                          WHERE tablename = tab
                                AND attname = col
                        )x
                ) AS f
                JOIN (SELECT ROW_NUMBER() OVER (),
                             e
                       FROM (SELECT UNNEST(most_common_elems::text::text[]) AS e
                              FROM  pg_stats
                              WHERE tablename = tab
                                    AND attname = col
                            )y
                ) AS elems USING (row_number);
END;

pg_version

Signature: evergreen.pg_version()

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
SELECT current_setting('server_version')

pg_version_num

Signature: evergreen.pg_version_num()

Returns: integer

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT current_setting('server_version_num')::integer;

pgtap_version

Signature: evergreen.pgtap_version()

Returns: numeric

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
SELECT 1.1;

plan

Signature: evergreen.plan(integer)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    rcount INTEGER;
BEGIN
    BEGIN
        EXECUTE '
            CREATE TEMP SEQUENCE __tcache___id_seq;
            CREATE TEMP TABLE __tcache__ (
                id    INTEGER NOT NULL DEFAULT nextval(''__tcache___id_seq''),
                label TEXT    NOT NULL,
                value INTEGER NOT NULL,
                note  TEXT    NOT NULL DEFAULT ''''
            );
            CREATE UNIQUE INDEX __tcache___key ON __tcache__(id);
            GRANT ALL ON TABLE __tcache__ TO PUBLIC;
            GRANT ALL ON TABLE __tcache___id_seq TO PUBLIC;

            CREATE TEMP SEQUENCE __tresults___numb_seq;
            GRANT ALL ON TABLE __tresults___numb_seq TO PUBLIC;
        ';

    EXCEPTION WHEN duplicate_table THEN
        -- Raise an exception if there's already a plan.
        EXECUTE 'SELECT TRUE FROM __tcache__ WHERE label = ''plan''';
      GET DIAGNOSTICS rcount = ROW_COUNT;
        IF rcount > 0 THEN
           RAISE EXCEPTION 'You tried to plan twice!';
        END IF;
    END;

    -- Save the plan and return.
    PERFORM _set('plan', $1 );
    PERFORM _set('failed', 0 );
    RETURN '1..' || $1;
END;

policies_are

Signature: evergreen.policies_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policies_are( $1, $2, $3, 'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct policies' );

policies_are

Signature: evergreen.policies_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'policies',
        ARRAY(
            SELECT p.polname
              FROM pg_catalog.pg_policy p
              JOIN pg_catalog.pg_class c     ON c.oid = p.polrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE n.nspname = $1
               AND c.relname = $2
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT p.polname
              FROM pg_catalog.pg_policy p
              JOIN pg_catalog.pg_class c     ON c.oid = p.polrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE n.nspname = $1
               AND c.relname = $2
        ),
        $4
    );

policies_are

Signature: evergreen.policies_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policies_are( $1, $2, 'Table ' || quote_ident($1) || ' should have the correct policies' );

policies_are

Signature: evergreen.policies_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'policies',
        ARRAY(
            SELECT p.polname
              FROM pg_catalog.pg_policy p
              JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE c.relname = $1
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT p.polname
              FROM pg_catalog.pg_policy p
              JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
        ),
        $3
    );

policy_cmd_is

Signature: evergreen.policy_cmd_is(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policy_cmd_is(
        $1, $2, $3, $4,
        'Policy ' || quote_ident($3)
        || ' for table ' || quote_ident($1) || '.' || quote_ident($2)
        || ' should apply to ' || upper($4) || ' command'
    );

policy_cmd_is

Signature: evergreen.policy_cmd_is(name, name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    cmd text;
BEGIN
    SELECT
      CASE pp.polcmd WHEN 'r' THEN 'SELECT'
                     WHEN 'a' THEN 'INSERT'
                     WHEN 'w' THEN 'UPDATE'
                     WHEN 'd' THEN 'DELETE'
                     ELSE 'ALL'
       END
      FROM pg_catalog.pg_policy AS pp
      JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
      JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
     WHERE pn.nspname = $1
       AND pc.relname = $2
       AND pp.polname = $3
      INTO cmd;

    RETURN is( cmd, upper($4), $5 );
END;

policy_cmd_is

Signature: evergreen.policy_cmd_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policy_cmd_is(
        $1, $2, $3,
        'Policy ' || quote_ident($2)
        || ' for table ' || quote_ident($1)
        || ' should apply to ' || upper($3) || ' command'
    );

policy_cmd_is

Signature: evergreen.policy_cmd_is(name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    cmd text;
BEGIN
    SELECT
      CASE pp.polcmd WHEN 'r' THEN 'SELECT'
                     WHEN 'a' THEN 'INSERT'
                     WHEN 'w' THEN 'UPDATE'
                     WHEN 'd' THEN 'DELETE'
                     ELSE 'ALL'
       END
      FROM pg_catalog.pg_policy AS pp
      JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
      JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
     WHERE pc.relname = $1
       AND pp.polname = $2
       AND pn.nspname NOT IN ('pg_catalog', 'information_schema')
      INTO cmd;

    RETURN is( cmd, upper($3), $4 );
END;

policy_roles_are

Signature: evergreen.policy_roles_are(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policy_roles_are( $1, $2, $3, $4, 'Policy ' || quote_ident($3) || ' for table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct roles' );

policy_roles_are

Signature: evergreen.policy_roles_are(name, name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'policy roles',
        ARRAY(
            SELECT pr.rolname
              FROM pg_catalog.pg_policy AS pp
              JOIN pg_catalog.pg_roles AS pr ON pr.oid = ANY (pp.polroles)
              JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
              JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
             WHERE pn.nspname = $1
               AND pc.relname = $2
               AND pp.polname = $3
            EXCEPT
            SELECT $4[i]
              FROM generate_series(1, array_upper($4, 1)) s(i)
        ),
        ARRAY(
            SELECT $4[i]
              FROM generate_series(1, array_upper($4, 1)) s(i)
            EXCEPT
            SELECT pr.rolname
              FROM pg_catalog.pg_policy AS pp
              JOIN pg_catalog.pg_roles AS pr ON pr.oid = ANY (pp.polroles)
              JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
              JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
             WHERE pn.nspname = $1
               AND pc.relname = $2
               AND pp.polname = $3
        ),
        $5
    );

policy_roles_are

Signature: evergreen.policy_roles_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT policy_roles_are( $1, $2, $3, 'Policy ' || quote_ident($2) || ' for table ' || quote_ident($1) || ' should have the correct roles' );

policy_roles_are

Signature: evergreen.policy_roles_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'policy roles',
        ARRAY(
            SELECT pr.rolname
              FROM pg_catalog.pg_policy AS pp
              JOIN pg_catalog.pg_roles AS pr ON pr.oid = ANY (pp.polroles)
              JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
              JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
             WHERE pc.relname = $1
               AND pp.polname = $2
               AND pn.nspname NOT IN ('pg_catalog', 'information_schema')
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT pr.rolname
              FROM pg_catalog.pg_policy AS pp
              JOIN pg_catalog.pg_roles AS pr ON pr.oid = ANY (pp.polroles)
              JOIN pg_catalog.pg_class AS pc ON pc.oid = pp.polrelid
              JOIN pg_catalog.pg_namespace AS pn ON pn.oid = pc.relnamespace
             WHERE pc.relname = $1
               AND pp.polname = $2
               AND pn.nspname NOT IN ('pg_catalog', 'information_schema')
        ),
        $4
    );

protect_reserved_rows_from_delete

Signature: evergreen.protect_reserved_rows_from_delete()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
IF OLD.id < TG_ARGV[0]::INT THEN
    RAISE EXCEPTION 'Cannot delete row with reserved ID %', OLD.id;
END IF;
RETURN OLD;
END

query_int_wrapper

Signature: evergreen.query_int_wrapper(integer[], text)

Returns: boolean

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
BEGIN
    RETURN $1 @@ $2::query_int;
END;

qwerty_keyboard_distance

Signature: evergreen.qwerty_keyboard_distance(a text, b text)

Returns: numeric

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
use String::KeyboardDistance qw(:all);
return qwerty_keyboard_distance(@_);

qwerty_keyboard_distance_match

Signature: evergreen.qwerty_keyboard_distance_match(a text, b text)

Returns: numeric

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
use String::KeyboardDistance qw(:all);
return qwerty_keyboard_distance_match(@_);

raise_protected_row_exception

Signature: evergreen.raise_protected_row_exception()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    RAISE EXCEPTION 'Cannot % %.% with % of %', TG_OP, TG_TABLE_SCHEMA, TG_TABLE_NAME, COALESCE(TG_ARGV[0]::TEXT,'id'), COALESCE(TG_ARGV[1]::TEXT,'-1');
END;

rank_cp

Signature: evergreen.rank_cp(copy asset.copy)

Returns: integer

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    rank INT;
BEGIN
    WITH totally_available AS (
        SELECT id, 0 AS avail_rank
        FROM config.copy_status
        WHERE opac_visible IS TRUE
            AND copy_active IS TRUE
            AND id != 1 -- "Checked out"
    ), almost_available AS (
        SELECT id, 10 AS avail_rank
        FROM config.copy_status
        WHERE holdable IS TRUE
            AND opac_visible IS TRUE
            AND copy_active IS FALSE
            OR id = 1 -- "Checked out"
    )
    SELECT COALESCE(
        CASE WHEN NOT copy.opac_visible THEN 100 END,
        (SELECT avail_rank FROM totally_available WHERE copy.status IN (id)),
        CASE WHEN copy.holdable THEN
            (SELECT avail_rank FROM almost_available WHERE copy.status IN (id))
        END,
        100
    ) INTO rank;

    RETURN rank;
END;

rank_cp

Signature: evergreen.rank_cp(copy_id bigint)

Returns: integer

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    copy asset.copy%ROWTYPE;
BEGIN
    SELECT * INTO copy FROM asset.copy WHERE id = copy_id;
    RETURN evergreen.rank_cp(copy);
END;

rank_ou

Signature: evergreen.rank_ou(lib integer, search_lib integer, pref_lib integer DEFAULT NULL::integer)

Returns: integer

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT COALESCE(

        -- lib matches search_lib
        (SELECT CASE WHEN $1 = $2 THEN -20000 END),

        -- lib matches pref_lib
        (SELECT CASE WHEN $1 = $3 THEN -10000 END),


        -- pref_lib is a child of search_lib and lib is a child of pref lib.
        -- For example, searching CONS, pref lib is SYS1,
        -- copies at BR1 and BR2 sort to the front.
        (SELECT distance - 5000
            FROM actor.org_unit_descendants_distance($3)
            WHERE id = $1 AND $3 IN (
                SELECT id FROM actor.org_unit_descendants($2))),

        -- lib is a child of search_lib
        (SELECT distance FROM actor.org_unit_descendants_distance($2) WHERE id = $1),

        -- all others pay cash
        1000
    );

rank_ou

Signature: evergreen.rank_ou(lib integer, search_lib integer, pref_lib integer, plat double precision, plon double precision)

Returns: integer

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    SELECT COALESCE(

        -- lib matches search_lib
        (SELECT CASE WHEN $1 = $2 THEN -20000 END),

        -- lib matches pref_lib
        (SELECT CASE WHEN $1 = $3 THEN -10000 END),


        -- pref_lib is a child of search_lib and lib is a child of pref lib.
        -- For example, searching CONS, pref lib is SYS1,
        -- copies at BR1 and BR2 sort to the front.
        (SELECT distance - 5000
            FROM actor.org_unit_descendants_distance($3)
            WHERE id = $1 AND $3 IN (
                SELECT id FROM actor.org_unit_descendants($2))),

        -- lib is a child of search_lib
        (SELECT distance FROM actor.org_unit_descendants_distance($2) WHERE id = $1),

        -- all others pay cash
        1000
    ) + ((SELECT CASE WHEN addr.latitude IS NULL THEN 0 ELSE -20038 END) + (earth_distance( -- shortest GC distance is returned, only half the circumfrence is needed
            ll_to_earth(
                COALESCE(addr.latitude,plat), -- if the org has no coords, we just
                COALESCE(addr.longitude,plon) -- force 0 distance and let the above tie-break
            ),ll_to_earth(plat,plon)
        ) / 1000)::INT ) -- earth_distance is in meters, convert to kilometers and subtract from largest distance
    FROM actor.org_unit org
		 LEFT JOIN actor.org_address addr ON (org.billing_address = addr.id)
	WHERE org.id = $1;

ranked_volumes

Signature: evergreen.ranked_volumes(bibid bigint, ouid integer, depth integer DEFAULT NULL::integer, slimit hstore DEFAULT NULL::hstore, soffset hstore DEFAULT NULL::hstore, pref_lib integer DEFAULT NULL::integer, includes text[] DEFAULT NULL::text[])

Returns: TABLE(id bigint, name text, label_sortkey text, rank bigint)

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
 SELECT * FROM evergreen.ranked_volumes(ARRAY[$1],$2,$3,$4,$5,$6,$7)

ranked_volumes

Signature: evergreen.ranked_volumes(bibid bigint[], ouid integer, depth integer DEFAULT NULL::integer, slimit hstore DEFAULT NULL::hstore, soffset hstore DEFAULT NULL::hstore, pref_lib integer DEFAULT NULL::integer, includes text[] DEFAULT NULL::text[])

Returns: TABLE(id bigint, name text, label_sortkey text, rank bigint)

Language

sql

Volatility

STABLE

Strict

No

Security Definer

No

 
    WITH RECURSIVE ou_depth AS (
        SELECT COALESCE(
            $3,
            (
                SELECT depth
                FROM actor.org_unit_type aout
                    INNER JOIN actor.org_unit ou ON ou_type = aout.id
                WHERE ou.id = $2
            )
        ) AS depth
    ), descendant_depth AS (
        SELECT  ou.id,
                ou.parent_ou,
                out.depth
        FROM  actor.org_unit ou
                JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
                JOIN anscestor_depth ad ON (ad.id = ou.id),
                ou_depth
        WHERE ad.depth = ou_depth.depth
            UNION ALL
        SELECT  ou.id,
                ou.parent_ou,
                out.depth
        FROM  actor.org_unit ou
                JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
                JOIN descendant_depth ot ON (ot.id = ou.parent_ou)
    ), anscestor_depth AS (
        SELECT  ou.id,
                ou.parent_ou,
                out.depth
        FROM  actor.org_unit ou
                JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
        WHERE ou.id = $2
            UNION ALL
        SELECT  ou.id,
                ou.parent_ou,
                out.depth
        FROM  actor.org_unit ou
                JOIN actor.org_unit_type out ON (out.id = ou.ou_type)
                JOIN anscestor_depth ot ON (ot.parent_ou = ou.id)
    ), descendants as (
        SELECT ou.* FROM actor.org_unit ou JOIN descendant_depth USING (id)
    )

    SELECT ua.id, ua.name, ua.label_sortkey, MIN(ua.rank) AS rank FROM (
        SELECT acn.id, owning_lib.name, acn.label_sortkey,
            evergreen.rank_cp(acp),
            RANK() OVER w
        FROM asset.call_number acn
            JOIN asset.copy acp ON (acn.id = acp.call_number)
            JOIN descendants AS aou ON (acp.circ_lib = aou.id)
            JOIN actor.org_unit AS owning_lib ON (acn.owning_lib = owning_lib.id)
        WHERE acn.record = ANY ($1)
            AND acn.deleted IS FALSE
            AND acp.deleted IS FALSE
            AND CASE WHEN ('exclude_invisible_acn' = ANY($7)) THEN
                EXISTS (
                    WITH basevm AS (SELECT c_attrs FROM  asset.patron_default_visibility_mask()),
                         circvm AS (SELECT search.calculate_visibility_attribute_test('circ_lib', ARRAY[acp.circ_lib]) AS mask)
                    SELECT  1
                      FROM  basevm, circvm, asset.copy_vis_attr_cache acvac
                      WHERE acvac.vis_attr_vector @@ (basevm.c_attrs || '&' || circvm.mask)::query_int
                            AND acvac.target_copy = acp.id
                            AND acvac.record = acn.record
                ) ELSE TRUE END
        GROUP BY acn.id, evergreen.rank_cp(acp), owning_lib.name, acn.label_sortkey, aou.id
        WINDOW w AS (
            ORDER BY
                COALESCE(
                    CASE WHEN aou.id = $2 THEN -20000 END,
                    CASE WHEN aou.id = $6 THEN -10000 END,
                    (SELECT distance - 5000
                        FROM actor.org_unit_descendants_distance($6) as x
                        WHERE x.id = aou.id AND $6 IN (
                            SELECT q.id FROM actor.org_unit_descendants($2) as q)),
                    (SELECT e.distance FROM actor.org_unit_descendants_distance($2) as e WHERE e.id = aou.id),
                    1000
                ),
                evergreen.rank_cp(acp)
        )
    ) AS ua
    GROUP BY ua.id, ua.name, ua.label_sortkey
    ORDER BY rank, ua.name, ua.label_sortkey
    LIMIT ($4 -> 'acn')::INT
    OFFSET ($5 -> 'acn')::INT;

redact_value

Signature: evergreen.redact_value(input_data anyelement, skip_redaction boolean DEFAULT false, redact_with anyelement DEFAULT NULL::unknown)

Returns: anyelement

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

 
DECLARE
    result ALIAS FOR $0;
BEGIN
    IF skip_redaction THEN
        result := input_data;
    ELSE
        result := redact_with;
    END IF;

    RETURN result;
END;

regexp_split_to_array

Signature: evergreen.regexp_split_to_array(text, text)

Returns: text[]

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    return encode_array_literal([split $_[1], $_[0]]);

rel_bump

Signature: evergreen.rel_bump(terms text[], value text, bumps text[], mults numeric[])

Returns: numeric

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
use strict;
my ($terms,$value,$bumps,$mults) = @_;

my $retval = 1;

for (my $id = 0; $id < @$bumps; $id++) {
        if ($bumps->[$id] eq 'first_word') {
                $retval *= $mults->[$id] if ($value =~ /^$terms->[0]/);
        } elsif ($bumps->[$id] eq 'full_match') {
                my $fullmatch = join(' ', @$terms);
                $retval *= $mults->[$id] if ($value =~ /^$fullmatch$/);
        } elsif ($bumps->[$id] eq 'word_order') {
                my $wordorder = join('.*', @$terms);
                $retval *= $mults->[$id] if ($value =~ /$wordorder/);
        }
}
return $retval;

relation_owner_is

Signature: evergreen.relation_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT relation_owner_is(
        $1, $2,
        'Relation ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

relation_owner_is

Signature: evergreen.relation_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT relation_owner_is(
        $1, $2, $3,
        'Relation ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

relation_owner_is

Signature: evergreen.relation_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner($1, $2);
BEGIN
    -- Make sure the relation exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Relation ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

relation_owner_is

Signature: evergreen.relation_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner($1);
BEGIN
    -- Make sure the relation exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Relation ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

results_eq

Signature: evergreen.results_eq(refcursor, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(refcursor, anyarray, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN want FOR SELECT $2[i]
    FROM generate_series(array_lower($2, 1), array_upper($2, 1)) s(i);
    res := results_eq($1, want, $3);
    CLOSE want;
    RETURN res;
END;

results_eq

Signature: evergreen.results_eq(refcursor, refcursor)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(refcursor, refcursor, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have       ALIAS FOR $1;
    want       ALIAS FOR $2;
    have_rec   RECORD;
    want_rec   RECORD;
    have_found BOOLEAN;
    want_found BOOLEAN;
    rownum     INTEGER := 1;
BEGIN
    FETCH have INTO have_rec;
    have_found := FOUND;
    FETCH want INTO want_rec;
    want_found := FOUND;
    WHILE have_found OR want_found LOOP
        IF have_rec IS DISTINCT FROM want_rec OR have_found <> want_found THEN
            RETURN ok( false, $3 ) || E'\n' || diag(
                '    Results differ beginning at row ' || rownum || E':\n' ||
                '        have: ' || CASE WHEN have_found THEN have_rec::text ELSE 'NULL' END || E'\n' ||
                '        want: ' || CASE WHEN want_found THEN want_rec::text ELSE 'NULL' END
            );
        END IF;
        rownum = rownum + 1;
        FETCH have INTO have_rec;
        have_found := FOUND;
        FETCH want INTO want_rec;
        want_found := FOUND;
    END LOOP;

    RETURN ok( true, $3 );
EXCEPTION
    WHEN datatype_mismatch THEN
        RETURN ok( false, $3 ) || E'\n' || diag(
            E'    Number of columns or their types differ between the queries' ||
            CASE WHEN have_rec::TEXT = want_rec::text THEN '' ELSE E':\n' ||
                '        have: ' || CASE WHEN have_found THEN have_rec::text ELSE 'NULL' END || E'\n' ||
                '        want: ' || CASE WHEN want_found THEN want_rec::text ELSE 'NULL' END
            END
        );
END;

results_eq

Signature: evergreen.results_eq(refcursor, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(refcursor, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN want FOR EXECUTE _query($2);
    res := results_eq($1, want, $3);
    CLOSE want;
    RETURN res;
END;

results_eq

Signature: evergreen.results_eq(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(text, anyarray, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    OPEN want FOR SELECT $2[i]
    FROM generate_series(array_lower($2, 1), array_upper($2, 1)) s(i);
    res := results_eq(have, want, $3);
    CLOSE have;
    CLOSE want;
    RETURN res;
END;

results_eq

Signature: evergreen.results_eq(text, refcursor)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(text, refcursor, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    res := results_eq(have, $2, $3);
    CLOSE have;
    RETURN res;
END;

results_eq

Signature: evergreen.results_eq(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_eq( $1, $2, NULL::text );

results_eq

Signature: evergreen.results_eq(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    OPEN want FOR EXECUTE _query($2);
    res := results_eq(have, want, $3);
    CLOSE have;
    CLOSE want;
    RETURN res;
END;

results_ne

Signature: evergreen.results_ne(refcursor, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(refcursor, anyarray, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN want FOR SELECT $2[i]
    FROM generate_series(array_lower($2, 1), array_upper($2, 1)) s(i);
    res := results_ne($1, want, $3);
    CLOSE want;
    RETURN res;
END;

results_ne

Signature: evergreen.results_ne(refcursor, refcursor)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(refcursor, refcursor, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have       ALIAS FOR $1;
    want       ALIAS FOR $2;
    have_rec   RECORD;
    want_rec   RECORD;
    have_found BOOLEAN;
    want_found BOOLEAN;
BEGIN
    FETCH have INTO have_rec;
    have_found := FOUND;
    FETCH want INTO want_rec;
    want_found := FOUND;
    WHILE have_found OR want_found LOOP
        IF have_rec IS DISTINCT FROM want_rec OR have_found <> want_found THEN
            RETURN ok( true, $3 );
        ELSE
            FETCH have INTO have_rec;
            have_found := FOUND;
            FETCH want INTO want_rec;
            want_found := FOUND;
        END IF;
    END LOOP;
    RETURN ok( false, $3 );
EXCEPTION
    WHEN datatype_mismatch THEN
        RETURN ok( false, $3 ) || E'\n' || diag(
            E'    Columns differ between queries:\n' ||
            '        have: ' || CASE WHEN have_found THEN have_rec::text ELSE 'NULL' END || E'\n' ||
            '        want: ' || CASE WHEN want_found THEN want_rec::text ELSE 'NULL' END
        );
END;

results_ne

Signature: evergreen.results_ne(refcursor, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(refcursor, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN want FOR EXECUTE _query($2);
    res := results_ne($1, want, $3);
    CLOSE want;
    RETURN res;
END;

results_ne

Signature: evergreen.results_ne(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(text, anyarray, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    OPEN want FOR SELECT $2[i]
    FROM generate_series(array_lower($2, 1), array_upper($2, 1)) s(i);
    res := results_ne(have, want, $3);
    CLOSE have;
    CLOSE want;
    RETURN res;
END;

results_ne

Signature: evergreen.results_ne(text, refcursor)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(text, refcursor, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    res := results_ne(have, $2, $3);
    CLOSE have;
    RETURN res;
END;

results_ne

Signature: evergreen.results_ne(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT results_ne( $1, $2, NULL::text );

results_ne

Signature: evergreen.results_ne(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    have REFCURSOR;
    want REFCURSOR;
    res  TEXT;
BEGIN
    OPEN have FOR EXECUTE _query($1);
    OPEN want FOR EXECUTE _query($2);
    res := results_ne(have, want, $3);
    CLOSE have;
    CLOSE want;
    RETURN res;
END;

roles_are

Signature: evergreen.roles_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT roles_are( $1, 'There should be the correct roles' );

roles_are

Signature: evergreen.roles_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'roles',
        ARRAY(
            SELECT rolname
              FROM pg_catalog.pg_roles
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT rolname
              FROM pg_catalog.pg_roles
        ),
        $2
    );

row_eq

Signature: evergreen.row_eq(text, anyelement)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT row_eq($1, $2, NULL );

row_eq

Signature: evergreen.row_eq(text, anyelement, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    rec    RECORD;
BEGIN
    EXECUTE _query($1) INTO rec;
    IF NOT rec IS DISTINCT FROM $2 THEN RETURN ok(true, $3); END IF;
    RETURN ok(false, $3 ) || E'\n' || diag(
           '        have: ' || CASE WHEN rec IS NULL THEN 'NULL' ELSE rec::text END ||
        E'\n        want: ' || CASE WHEN $2  IS NULL THEN 'NULL' ELSE $2::text  END
    );
END;

rule_is_instead

Signature: evergreen.rule_is_instead(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rule_is_instead($1, $2, 'Rule ' || quote_ident($2) || ' on relation ' || quote_ident($1) || ' should be an INSTEAD rule' );

rule_is_instead

Signature: evergreen.rule_is_instead(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rule_is_instead( $1, $2, $3, 'Rule ' || quote_ident($3) || ' on relation ' || quote_ident($1) || '.' || quote_ident($2) || ' should be an INSTEAD rule' );

rule_is_instead

Signature: evergreen.rule_is_instead(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    is_it boolean := _is_instead($1, $2, $3);
BEGIN
    IF is_it IS NOT NULL THEN RETURN ok( is_it, $4 ); END IF;
    RETURN ok( FALSE, $4 ) || E'\n' || diag(
        '    Rule ' || quote_ident($3) || ' does not exist'
    );
END;

rule_is_instead

Signature: evergreen.rule_is_instead(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    is_it boolean := _is_instead($1, $2);
BEGIN
    IF is_it IS NOT NULL THEN RETURN ok( is_it, $3 ); END IF;
    RETURN ok( FALSE, $3 ) || E'\n' || diag(
        '    Rule ' || quote_ident($2) || ' does not exist'
    );
END;

rule_is_on

Signature: evergreen.rule_is_on(name, name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rule_is_on(
        $1, $2, $3, $4,
        'Rule ' || quote_ident($3) || ' should be on ' || _expand_on(_contract_on($4)::char)
        || ' to ' || quote_ident($1) || '.' || quote_ident($2)
    );

rule_is_on

Signature: evergreen.rule_is_on(name, name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want char := _contract_on($4);
    have char := _rule_on($1, $2, $3);
BEGIN
    IF have IS NOT NULL THEN
        RETURN is( _expand_on(have), _expand_on(want), $5 );
    END IF;

    RETURN ok( false, $5 ) || E'\n' || diag(
        '    Rule ' || quote_ident($3) || ' does not exist on '
        || quote_ident($1) || '.' || quote_ident($2)
    );
END;

rule_is_on

Signature: evergreen.rule_is_on(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rule_is_on(
        $1, $2, $3,
        'Rule ' || quote_ident($2) || ' should be on '
        || _expand_on(_contract_on($3)::char) || ' to ' || quote_ident($1)
    );

rule_is_on

Signature: evergreen.rule_is_on(name, name, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    want char := _contract_on($3);
    have char := _rule_on($1, $2);
BEGIN
    IF have IS NOT NULL THEN
        RETURN is( _expand_on(have), _expand_on(want), $4 );
    END IF;

    RETURN ok( false, $4 ) || E'\n' || diag(
        '    Rule ' || quote_ident($2) || ' does not exist on '
        || quote_ident($1)
    );
END;

rules_are

Signature: evergreen.rules_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rules_are( $1, $2, $3, 'Relation ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct rules' );

rules_are

Signature: evergreen.rules_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'rules',
        ARRAY(
            SELECT r.rulename
              FROM pg_catalog.pg_rewrite r
              JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
              JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
             WHERE c.relname = $2
               AND n.nspname = $1
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT r.rulename
              FROM pg_catalog.pg_rewrite r
              JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
              JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
             WHERE c.relname = $2
               AND n.nspname = $1
        ),
        $4
    );

rules_are

Signature: evergreen.rules_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT rules_are( $1, $2, 'Relation ' || quote_ident($1) || ' should have the correct rules' );

rules_are

Signature: evergreen.rules_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'rules',
        ARRAY(
            SELECT r.rulename
              FROM pg_catalog.pg_rewrite r
              JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
              JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
             WHERE c.relname = $1
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_table_is_visible(c.oid)
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT r.rulename
              FROM pg_catalog.pg_rewrite r
              JOIN pg_catalog.pg_class c     ON c.oid = r.ev_class
              JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
               AND c.relname = $1
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND pg_catalog.pg_table_is_visible(c.oid)
        ),
        $3
    );

runtests

Signature: evergreen.runtests()

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM runtests( '^test' );

runtests

Signature: evergreen.runtests(name)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM runtests( $1, '^test' );

runtests

Signature: evergreen.runtests(name, text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runner(
        findfuncs( $1, '^startup' ),
        findfuncs( $1, '^shutdown' ),
        findfuncs( $1, '^setup' ),
        findfuncs( $1, '^teardown' ),
        findfuncs( $1, $2, '^(startup|shutdown|setup|teardown)' )
    );

runtests

Signature: evergreen.runtests(text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT * FROM _runner(
        findfuncs( '^startup' ),
        findfuncs( '^shutdown' ),
        findfuncs( '^setup' ),
        findfuncs( '^teardown' ),
        findfuncs( $1, '^(startup|shutdown|setup|teardown)' )
    );

schema_owner_is

Signature: evergreen.schema_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT schema_owner_is(
        $1, $2,
        'Schema ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

schema_owner_is

Signature: evergreen.schema_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_schema_owner($1);
BEGIN
    -- Make sure the schema exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Schema ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

schema_privs_are

Signature: evergreen.schema_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT schema_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on schema ' || quote_ident($1)
    );

schema_privs_are

Signature: evergreen.schema_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_schema_privs( $2, $1::TEXT );
BEGIN
    IF grants[1] = 'invalid_schema_name' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Schema ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

schemas_are

Signature: evergreen.schemas_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT schemas_are( $1, 'There should be the correct schemas' );

schemas_are

Signature: evergreen.schemas_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'schemas',
        ARRAY(
            SELECT nspname
              FROM pg_catalog.pg_namespace
             WHERE nspname NOT LIKE 'pg_%'
               AND nspname <> 'information_schema'
             EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT nspname
              FROM pg_catalog.pg_namespace
             WHERE nspname NOT LIKE 'pg_%'
               AND nspname <> 'information_schema'
        ),
        $2
    );

sequence_owner_is

Signature: evergreen.sequence_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT sequence_owner_is(
        $1, $2,
        'Sequence ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

sequence_owner_is

Signature: evergreen.sequence_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT sequence_owner_is(
        $1, $2, $3,
        'Sequence ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

sequence_owner_is

Signature: evergreen.sequence_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('S'::char, $1, $2);
BEGIN
    -- Make sure the sequence exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Sequence ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

sequence_owner_is

Signature: evergreen.sequence_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('S'::char, $1);
BEGIN
    -- Make sure the sequence exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Sequence ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

sequence_privs_are

Signature: evergreen.sequence_privs_are(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT sequence_privs_are(
        $1, $2, $3, $4,
        'Role ' || quote_ident($3) || ' should be granted '
            || CASE WHEN $4[1] IS NULL THEN 'no privileges' ELSE array_to_string($4, ', ') END
            || ' on sequence '|| quote_ident($1) || '.' || quote_ident($2)
    );

sequence_privs_are

Signature: evergreen.sequence_privs_are(name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_sequence_privs( $3, quote_ident($1) || '.' || quote_ident($2) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Sequence ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Role ' || quote_ident($3) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $4, $5);
END;

sequence_privs_are

Signature: evergreen.sequence_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT sequence_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on sequence ' || quote_ident($1)
    );

sequence_privs_are

Signature: evergreen.sequence_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_sequence_privs( $2, quote_ident($1) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Sequence ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

sequences_are

Signature: evergreen.sequences_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'sequences', _extras('S', $1, $2), _missing('S', $1, $2),
        'Schema ' || quote_ident($1) || ' should have the correct sequences'
    );

sequences_are

Signature: evergreen.sequences_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'sequences', _extras('S', $1, $2), _missing('S', $1, $2), $3);

sequences_are

Signature: evergreen.sequences_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'sequences', _extras('S', $1), _missing('S', $1),
        'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct sequences'
    );

sequences_are

Signature: evergreen.sequences_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'sequences', _extras('S', $1), _missing('S', $1), $2);

server_privs_are

Signature: evergreen.server_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT server_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on server ' || quote_ident($1)
    );

server_privs_are

Signature: evergreen.server_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_server_privs( $2, $1::TEXT );
BEGIN
    IF grants[1] = 'undefined_server' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Server ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

set_eq

Signature: evergreen.set_eq(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::text, '' );

set_eq

Signature: evergreen.set_eq(text, anyarray, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, '' );

set_eq

Signature: evergreen.set_eq(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::text, '' );

set_eq

Signature: evergreen.set_eq(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, '' );

set_has

Signature: evergreen.set_has(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::TEXT, 'EXCEPT', 'Missing' );

set_has

Signature: evergreen.set_has(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'EXCEPT', 'Missing' );

set_hasnt

Signature: evergreen.set_hasnt(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, NULL::TEXT, 'INTERSECT', 'Extra' );

set_hasnt

Signature: evergreen.set_hasnt(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relcomp( $1, $2, $3, 'INTERSECT', 'Extra' );

set_ne

Signature: evergreen.set_ne(text, anyarray)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, NULL::text, '' );

set_ne

Signature: evergreen.set_ne(text, anyarray, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, $3, '' );

set_ne

Signature: evergreen.set_ne(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, NULL::text, '' );

set_ne

Signature: evergreen.set_ne(text, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _relne( $1, $2, $3, '' );

setup_delete_protect_rule

Signature: evergreen.setup_delete_protect_rule(t_schema text, t_table text, t_additional text DEFAULT ''::text, t_pkey text DEFAULT 'id'::text, t_deleted text DEFAULT 'deleted'::text)

Returns: void

Language

plpgsql

Volatility

VOLATILE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
DECLARE
    rule_name   TEXT;
    table_name  TEXT;
    fq_pkey     TEXT;
BEGIN

    rule_name := 'protect_' || t_schema || '_' || t_table || '_delete';
    table_name := t_schema || '.' || t_table;
    fq_pkey := table_name || '.' || t_pkey;

    EXECUTE 'DROP RULE IF EXISTS ' || rule_name || ' ON ' || table_name;
    EXECUTE 'CREATE RULE ' || rule_name
            || ' AS ON DELETE TO ' || table_name
            || ' DO INSTEAD (UPDATE ' || table_name
            || '   SET ' || t_deleted || ' = TRUE '
            || '   WHERE OLD.' || t_pkey || ' = ' || fq_pkey
            || '   ; ' || t_additional || ')';

END;

skip

Signature: evergreen.skip(integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT skip(NULL, $1)

skip

Signature: evergreen.skip(integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
SELECT skip($2, $1)

skip

Signature: evergreen.skip(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT ok( TRUE ) || ' ' || diag( 'SKIP' || COALESCE(' ' || $1, '') );

skip

Signature: evergreen.skip(why text, how_many integer)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    output TEXT[];
BEGIN
    output := '{}';
    FOR i IN 1..how_many LOOP
        output = array_append(
            output,
            ok( TRUE ) || ' ' || diag( 'SKIP' || COALESCE( ' ' || why, '') )
        );
    END LOOP;
    RETURN array_to_string(output, E'\n');
END;

table_owner_is

Signature: evergreen.table_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT table_owner_is(
        $1, $2,
        'Table ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

table_owner_is

Signature: evergreen.table_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT table_owner_is(
        $1, $2, $3,
        'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

table_owner_is

Signature: evergreen.table_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('{r,p}'::char[], $1, $2);
BEGIN
    -- Make sure the table exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

table_owner_is

Signature: evergreen.table_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('{r,p}'::char[], $1);
BEGIN
    -- Make sure the table exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Table ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

table_privs_are

Signature: evergreen.table_privs_are(name, name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT table_privs_are(
        $1, $2, $3, $4,
        'Role ' || quote_ident($3) || ' should be granted '
            || CASE WHEN $4[1] IS NULL THEN 'no privileges' ELSE array_to_string($4, ', ') END
            || ' on table ' || quote_ident($1) || '.' || quote_ident($2)
    );

table_privs_are

Signature: evergreen.table_privs_are(name, name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_table_privs( $3, quote_ident($1) || '.' || quote_ident($2) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $5) || E'\n' || diag(
            '    Role ' || quote_ident($3) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $4, $5);
END;

table_privs_are

Signature: evergreen.table_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT table_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on table ' || quote_ident($1)
    );

table_privs_are

Signature: evergreen.table_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_table_privs( $2, quote_ident($1) );
BEGIN
    IF grants[1] = 'undefined_table' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Table ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

tableoid2name

Signature: evergreen.tableoid2name(oid)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
	BEGIN
		RETURN $1::regclass;
	END;

tables_are

Signature: evergreen.tables_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'tables', _extras('{r,p}'::char[], $1, $2), _missing('{r,p}'::char[], $1, $2),
        'Schema ' || quote_ident($1) || ' should have the correct tables'
    );

tables_are

Signature: evergreen.tables_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'tables', _extras('{r,p}'::char[], $1, $2), _missing('{r,p}'::char[], $1, $2), $3);

tables_are

Signature: evergreen.tables_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'tables', _extras('{r,p}'::char[], $1), _missing('{r,p}'::char[], $1),
        'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct tables'
    );

tables_are

Signature: evergreen.tables_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'tables', _extras('{r,p}'::char[], $1), _missing('{r,p}'::char[], $1), $2);

tablespace_owner_is

Signature: evergreen.tablespace_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT tablespace_owner_is(
        $1, $2,
        'Tablespace ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

tablespace_owner_is

Signature: evergreen.tablespace_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_tablespace_owner($1);
BEGIN
    -- Make sure the tablespace exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Tablespace ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

tablespace_privs_are

Signature: evergreen.tablespace_privs_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT tablespace_privs_are(
        $1, $2, $3,
        'Role ' || quote_ident($2) || ' should be granted '
            || CASE WHEN $3[1] IS NULL THEN 'no privileges' ELSE array_to_string($3, ', ') END
            || ' on tablespace ' || quote_ident($1)
    );

tablespace_privs_are

Signature: evergreen.tablespace_privs_are(name, name, name[], text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    grants TEXT[] := _get_tablespaceprivs( $2, $1::TEXT );
BEGIN
    IF grants[1] = 'undefined_tablespace' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Tablespace ' || quote_ident($1) || ' does not exist'
        );
    ELSIF grants[1] = 'undefined_role' THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            '    Role ' || quote_ident($2) || ' does not exist'
        );
    END IF;
    RETURN _assets_are('privileges', grants, $3, $4);
END;

tablespaces_are

Signature: evergreen.tablespaces_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT tablespaces_are( $1, 'There should be the correct tablespaces' );

tablespaces_are

Signature: evergreen.tablespaces_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'tablespaces',
        ARRAY(
            SELECT spcname
              FROM pg_catalog.pg_tablespace
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
               FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT spcname
              FROM pg_catalog.pg_tablespace
        ),
        $2
    );

text_array_merge_unique

Signature: evergreen.text_array_merge_unique(text[], text[])

Returns: text[]

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT NULLIF(ARRAY(
        SELECT * FROM UNNEST($1) x
            UNION
        SELECT * FROM UNNEST($2) y
    ),'{}');

throws_ilike

Signature: evergreen.throws_ilike(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_ilike($1, $2, 'Should throw exception like ' || quote_literal($2) );

throws_ilike

Signature: evergreen.throws_ilike(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE _query($1);
    RETURN ok( FALSE, $3 ) || E'\n' || diag( '    no exception thrown' );
EXCEPTION WHEN OTHERS THEN
    return _tlike( SQLERRM ~~* $2, SQLERRM, $2, $3 );
END;

throws_imatching

Signature: evergreen.throws_imatching(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_imatching($1, $2, 'Should throw exception matching ' || quote_literal($2) );

throws_imatching

Signature: evergreen.throws_imatching(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE _query($1);
    RETURN ok( FALSE, $3 ) || E'\n' || diag( '    no exception thrown' );
EXCEPTION WHEN OTHERS THEN
    return _tlike( SQLERRM ~* $2, SQLERRM, $2, $3 );
END;

throws_like

Signature: evergreen.throws_like(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_like($1, $2, 'Should throw exception like ' || quote_literal($2) );

throws_like

Signature: evergreen.throws_like(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE _query($1);
    RETURN ok( FALSE, $3 ) || E'\n' || diag( '    no exception thrown' );
EXCEPTION WHEN OTHERS THEN
    return _tlike( SQLERRM ~~ $2, SQLERRM, $2, $3 );
END;

throws_matching

Signature: evergreen.throws_matching(text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_matching($1, $2, 'Should throw exception matching ' || quote_literal($2) );

throws_matching

Signature: evergreen.throws_matching(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    EXECUTE _query($1);
    RETURN ok( FALSE, $3 ) || E'\n' || diag( '    no exception thrown' );
EXCEPTION WHEN OTHERS THEN
    return _tlike( SQLERRM ~ $2, SQLERRM, $2, $3 );
END;

throws_ok

Signature: evergreen.throws_ok(text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_ok( $1, NULL, NULL, NULL );

throws_ok

Signature: evergreen.throws_ok(text, character, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    query     TEXT := _query($1);
    errcode   ALIAS FOR $2;
    errmsg    ALIAS FOR $3;
    desctext  ALIAS FOR $4;
    descr     TEXT;
BEGIN
    descr := COALESCE(
          desctext,
          'threw ' || errcode || ': ' || errmsg,
          'threw ' || errcode,
          'threw ' || errmsg,
          'threw an exception'
    );
    EXECUTE query;
    RETURN ok( FALSE, descr ) || E'\n' || diag(
           '      caught: no exception' ||
        E'\n      wanted: ' || COALESCE( errcode, 'an exception' )
    );
EXCEPTION WHEN OTHERS OR ASSERT_FAILURE THEN
    IF (errcode IS NULL OR SQLSTATE = errcode)
        AND ( errmsg IS NULL OR SQLERRM = errmsg)
    THEN
        -- The expected errcode and/or message was thrown.
        RETURN ok( TRUE, descr );
    ELSE
        -- This was not the expected errcode or errmsg.
        RETURN ok( FALSE, descr ) || E'\n' || diag(
               '      caught: ' || SQLSTATE || ': ' || SQLERRM ||
            E'\n      wanted: ' || COALESCE( errcode, 'an exception' ) ||
            COALESCE( ': ' || errmsg, '')
        );
    END IF;
END;

throws_ok

Signature: evergreen.throws_ok(text, integer)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_ok( $1, $2::char(5), NULL, NULL );

throws_ok

Signature: evergreen.throws_ok(text, integer, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_ok( $1, $2::char(5), $3, NULL );

throws_ok

Signature: evergreen.throws_ok(text, integer, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT throws_ok( $1, $2::char(5), $3, $4 );

throws_ok

Signature: evergreen.throws_ok(text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF octet_length($2) = 5 THEN
        RETURN throws_ok( $1, $2::char(5), NULL, NULL );
    ELSE
        RETURN throws_ok( $1, NULL, $2, NULL );
    END IF;
END;

throws_ok

Signature: evergreen.throws_ok(text, text, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    IF octet_length($2) = 5 THEN
        RETURN throws_ok( $1, $2::char(5), $3, NULL );
    ELSE
        RETURN throws_ok( $1, NULL, $2, $3 );
    END IF;
END;

todo

Signature: evergreen.todo(how_many integer)

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', COALESCE(how_many, 1), '');
    RETURN;
END;

todo

Signature: evergreen.todo(how_many integer, why text)

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', COALESCE(how_many, 1), COALESCE(why, ''));
    RETURN;
END;

todo

Signature: evergreen.todo(why text)

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', 1, COALESCE(why, ''));
    RETURN;
END;

todo

Signature: evergreen.todo(why text, how_many integer)

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', COALESCE(how_many, 1), COALESCE(why, ''));
    RETURN;
END;

todo_end

Signature: evergreen.todo_end()

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    id integer;
BEGIN
    id := _get_latest( 'todo', -1 );
    IF id IS NULL THEN
        RAISE EXCEPTION 'todo_end() called without todo_start()';
    END IF;
    EXECUTE 'DELETE FROM __tcache__ WHERE id = ' || id;
    RETURN;
END;

todo_start

Signature: evergreen.todo_start()

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', -1, '');
    RETURN;
END;

todo_start

Signature: evergreen.todo_start(text)

Returns: SETOF boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
    PERFORM _add('todo', -1, COALESCE($1, ''));
    RETURN;
END;

trigger_is

Signature: evergreen.trigger_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT trigger_is(
        $1, $2, $3,
        'Trigger ' || quote_ident($2) || ' should call ' || quote_ident($3) || '()'
    );

trigger_is

Signature: evergreen.trigger_is(name, name, name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT trigger_is(
        $1, $2, $3, $4, $5,
        'Trigger ' || quote_ident($3) || ' should call ' || quote_ident($4) || '.' || quote_ident($5) || '()'
    );

trigger_is

Signature: evergreen.trigger_is(name, name, name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    pname text;
BEGIN
    SELECT quote_ident(ni.nspname) || '.' || quote_ident(p.proname)
      FROM pg_catalog.pg_trigger t
      JOIN pg_catalog.pg_class ct     ON ct.oid = t.tgrelid
      JOIN pg_catalog.pg_namespace nt ON nt.oid = ct.relnamespace
      JOIN pg_catalog.pg_proc p       ON p.oid = t.tgfoid
      JOIN pg_catalog.pg_namespace ni ON ni.oid = p.pronamespace
     WHERE nt.nspname = $1
       AND ct.relname = $2
       AND t.tgname   = $3
      INTO pname;

    RETURN is( pname, quote_ident($4) || '.' || quote_ident($5), $6 );
END;

trigger_is

Signature: evergreen.trigger_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    pname text;
BEGIN
    SELECT p.proname
      FROM pg_catalog.pg_trigger t
      JOIN pg_catalog.pg_class ct ON ct.oid = t.tgrelid
      JOIN pg_catalog.pg_proc p   ON p.oid = t.tgfoid
     WHERE ct.relname = $1
       AND t.tgname   = $2
       AND pg_catalog.pg_table_is_visible(ct.oid)
      INTO pname;

    RETURN is( pname, $3::text, $4 );
END;

triggers_are

Signature: evergreen.triggers_are(name, name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT triggers_are( $1, $2, $3, 'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have the correct triggers' );

triggers_are

Signature: evergreen.triggers_are(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'triggers',
        ARRAY(
            SELECT t.tgname
              FROM pg_catalog.pg_trigger t
              JOIN pg_catalog.pg_class c     ON c.oid = t.tgrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE n.nspname = $1
               AND c.relname = $2
               AND NOT t.tgisinternal
            EXCEPT
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
        ),
        ARRAY(
            SELECT $3[i]
              FROM generate_series(1, array_upper($3, 1)) s(i)
            EXCEPT
            SELECT t.tgname
              FROM pg_catalog.pg_trigger t
              JOIN pg_catalog.pg_class c     ON c.oid = t.tgrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE n.nspname = $1
               AND c.relname = $2
               AND NOT t.tgisinternal
        ),
        $4
    );

triggers_are

Signature: evergreen.triggers_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT triggers_are( $1, $2, 'Table ' || quote_ident($1) || ' should have the correct triggers' );

triggers_are

Signature: evergreen.triggers_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'triggers',
        ARRAY(
            SELECT t.tgname
              FROM pg_catalog.pg_trigger t
              JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE c.relname = $1
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND NOT t.tgisinternal
            EXCEPT
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
        ),
        ARRAY(
            SELECT $2[i]
              FROM generate_series(1, array_upper($2, 1)) s(i)
            EXCEPT
            SELECT t.tgname
              FROM pg_catalog.pg_trigger t
              JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
              JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
               AND NOT t.tgisinternal
        ),
        $3
    );

type_owner_is

Signature: evergreen.type_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT type_owner_is(
        $1, $2,
        'Type ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

type_owner_is

Signature: evergreen.type_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT type_owner_is(
        $1, $2, $3,
        'Type ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

type_owner_is

Signature: evergreen.type_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_type_owner($1, $2);
BEGIN
    -- Make sure the type exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    Type ' || quote_ident($1) || '.' || quote_ident($2) || ' not found'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

type_owner_is

Signature: evergreen.type_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_type_owner($1);
BEGIN
    -- Make sure the type exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    Type ' || quote_ident($1) || ' not found'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

types_are

Signature: evergreen.types_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, 'Schema ' || quote_ident($1) || ' should have the correct types', NULL );

types_are

Signature: evergreen.types_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, $3, NULL );

types_are

Signature: evergreen.types_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, 'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct types', NULL );

types_are

Signature: evergreen.types_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _types_are( $1, $2, NULL );

unaccent_and_squash

Signature: evergreen.unaccent_and_squash(arg text)

Returns: text

Language

plpgsql

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
	BEGIN
	RETURN evergreen.lowercase(public.unaccent('public.unaccent', regexp_replace(arg, '[\s[:punct:]]','','g')));
	END;

unalike

Signature: evergreen.unalike(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~~ $2, $1, $2, NULL );

unalike

Signature: evergreen.unalike(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~~ $2, $1, $2, $3 );

unialike

Signature: evergreen.unialike(anyelement, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~~* $2, $1, $2, NULL );

unialike

Signature: evergreen.unialike(anyelement, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _unalike( $1 !~~* $2, $1, $2, $3 );

upgrade_deps_block_check

Signature: evergreen.upgrade_deps_block_check(my_db_patch text, my_applied_to text)

Returns: boolean

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    deprecates TEXT;
    supersedes TEXT;
BEGIN
    IF NOT evergreen.upgrade_verify_no_dep_conflicts( my_db_patch ) THEN
        SELECT  STRING_AGG(patch, ', ') INTO deprecates FROM evergreen.upgrade_list_applied_deprecates(my_db_patch);
        SELECT  STRING_AGG(patch, ', ') INTO supersedes FROM evergreen.upgrade_list_applied_supersedes(my_db_patch);
        RAISE EXCEPTION '
Upgrade script % can not be applied:
  applied deprecated scripts %
  applied superseded scripts %
  deprecated by %
  superseded by %',
            my_db_patch,
            (SELECT ARRAY_AGG(patch) FROM evergreen.upgrade_list_applied_deprecates(my_db_patch)),
            (SELECT ARRAY_AGG(patch) FROM evergreen.upgrade_list_applied_supersedes(my_db_patch)),
            evergreen.upgrade_list_applied_deprecated(my_db_patch),
            evergreen.upgrade_list_applied_superseded(my_db_patch);
    END IF;

    INSERT INTO config.upgrade_log (version, applied_to) VALUES (my_db_patch, my_applied_to);
    RETURN TRUE;
END;

upgrade_list_applied_deprecated

Signature: evergreen.upgrade_list_applied_deprecated(my_db_patch text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT  db_patch
      FROM  config.db_patch_dependencies
      WHERE ARRAY[$1]::TEXT[] && deprecates

upgrade_list_applied_deprecates

Signature: evergreen.upgrade_list_applied_deprecates(my_db_patch text)

Returns: SETOF patch

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT  DISTINCT l.version
      FROM  config.upgrade_log l
            JOIN config.db_patch_dependencies d ON (l.version = ANY(d.deprecates))
      WHERE d.db_patch = $1

upgrade_list_applied_superseded

Signature: evergreen.upgrade_list_applied_superseded(my_db_patch text)

Returns: SETOF text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT  db_patch
      FROM  config.db_patch_dependencies
      WHERE ARRAY[$1]::TEXT[] && supersedes

upgrade_list_applied_supersedes

Signature: evergreen.upgrade_list_applied_supersedes(my_db_patch text)

Returns: SETOF patch

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT  DISTINCT l.version
      FROM  config.upgrade_log l
            JOIN config.db_patch_dependencies d ON (l.version = ANY(d.supersedes))
      WHERE d.db_patch = $1

upgrade_verify_no_dep_conflicts

Signature: evergreen.upgrade_verify_no_dep_conflicts(my_db_patch text)

Returns: boolean

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT  COUNT(*) = 0
      FROM  (SELECT * FROM evergreen.upgrade_list_applied_deprecates( $1 )
                UNION
             SELECT * FROM evergreen.upgrade_list_applied_supersedes( $1 )
                UNION
             SELECT * FROM evergreen.upgrade_list_applied_deprecated( $1 )
                UNION
             SELECT * FROM evergreen.upgrade_list_applied_superseded( $1 ))x

uppercase

Signature: evergreen.uppercase(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
    return uc(shift);

uri_escape

Signature: evergreen.uri_escape(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
  use URI::Escape;
  my $input = shift;
  return uri_escape_utf8($input);

uri_unescape

Signature: evergreen.uri_unescape(text)

Returns: text

Language

plperlu

Volatility

IMMUTABLE

Strict

Yes (returns NULL on NULL input)

Security Definer

No

 
  my $input = shift;
  $input =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg; # inline the RE, it is 700% faster than URI::Escape::uri_unescape
  return $input;

users_are

Signature: evergreen.users_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT users_are( $1, 'There should be the correct users' );

users_are

Signature: evergreen.users_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'users',
        ARRAY(
            SELECT usename
              FROM pg_catalog.pg_user
            EXCEPT
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
        ),
        ARRAY(
            SELECT $1[i]
              FROM generate_series(1, array_upper($1, 1)) s(i)
            EXCEPT
            SELECT usename
              FROM pg_catalog.pg_user
        ),
        $2
    );

vandelay_import_item_imported_as_inh_fkey

Signature: evergreen.vandelay_import_item_imported_as_inh_fkey()

Returns: trigger

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
BEGIN
        IF NEW.imported_as IS NULL THEN
                RETURN NEW;
        END IF;
        PERFORM 1 FROM asset.copy WHERE id = NEW.imported_as;
        IF NOT FOUND THEN
                RAISE foreign_key_violation USING MESSAGE = FORMAT(
                        $$Referenced asset.copy id not found, imported_as:%s$$, NEW.imported_as
                );
        END IF;
        RETURN NEW;
END;

view_owner_is

Signature: evergreen.view_owner_is(name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT view_owner_is(
        $1, $2,
        'View ' || quote_ident($1) || ' should be owned by ' || quote_ident($2)
    );

view_owner_is

Signature: evergreen.view_owner_is(name, name, name)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT view_owner_is(
        $1, $2, $3,
        'View ' || quote_ident($1) || '.' || quote_ident($2) || ' should be owned by ' || quote_ident($3)
    );

view_owner_is

Signature: evergreen.view_owner_is(name, name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('v'::char, $1, $2);
BEGIN
    -- Make sure the view exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $4) || E'\n' || diag(
            E'    View ' || quote_ident($1) || '.' || quote_ident($2) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $3, $4);
END;

view_owner_is

Signature: evergreen.view_owner_is(name, name, text)

Returns: text

Language

plpgsql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
DECLARE
    owner NAME := _get_rel_owner('v'::char, $1);
BEGIN
    -- Make sure the view exists.
    IF owner IS NULL THEN
        RETURN ok(FALSE, $3) || E'\n' || diag(
            E'    View ' || quote_ident($1) || ' does not exist'
        );
    END IF;

    RETURN is(owner, $2, $3);
END;

views_are

Signature: evergreen.views_are(name, name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'views', _extras('v', $1, $2), _missing('v', $1, $2),
        'Schema ' || quote_ident($1) || ' should have the correct views'
    );

views_are

Signature: evergreen.views_are(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'views', _extras('v', $1, $2), _missing('v', $1, $2), $3);

views_are

Signature: evergreen.views_are(name[])

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are(
        'views', _extras('v', $1), _missing('v', $1),
        'Search path ' || pg_catalog.current_setting('search_path') || ' should have the correct views'
    );

views_are

Signature: evergreen.views_are(name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _are( 'views', _extras('v', $1), _missing('v', $1), $2);

volatility_is

Signature: evergreen.volatility_is(name, name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT volatility_is(
        $1, $2, $3, $4,
        'Function ' || quote_ident($1) || '.' || quote_ident($2) || '(' ||
        array_to_string($3, ', ') || ') should be ' || _refine_vol($4)
    );

volatility_is

Signature: evergreen.volatility_is(name, name, name[], text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, $3, _vol($1, $2, $3), _refine_vol($4), $5 );

volatility_is

Signature: evergreen.volatility_is(name, name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT volatility_is(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '.' || quote_ident($2)
        || '() should be ' || _refine_vol($3)
    );

volatility_is

Signature: evergreen.volatility_is(name, name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare($1, $2, _vol($1, $2), _refine_vol($3), $4 );

volatility_is

Signature: evergreen.volatility_is(name, name[], text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT volatility_is(
        $1, $2, $3,
        'Function ' || quote_ident($1) || '(' ||
        array_to_string($2, ', ') || ') should be ' || _refine_vol($3)
    );

volatility_is

Signature: evergreen.volatility_is(name, name[], text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, $2, _vol($1, $2), _refine_vol($3), $4 );

volatility_is

Signature: evergreen.volatility_is(name, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT volatility_is(
        $1, $2,
        'Function ' || quote_ident($1) || '() should be ' || _refine_vol($2)
    );

volatility_is

Signature: evergreen.volatility_is(name, text, text)

Returns: text

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

 
    SELECT _func_compare(NULL, $1, _vol($1), _refine_vol($2), $3 );

xml_escape

Signature: evergreen.xml_escape(str text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
    SELECT REPLACE(REPLACE(REPLACE($1,
       '&', '&amp;'),
       '<', '&lt;'),
       '>', '&gt;');

xml_famous5_to_text

Signature: evergreen.xml_famous5_to_text(text)

Returns: text

Language

sql

Volatility

IMMUTABLE

Strict

No

Security Definer

No

 
 SELECT REPLACE(
            REPLACE(
                REPLACE(
                    REPLACE(
                        REPLACE( $1, '&lt;', '<'),
                        '&gt;',
                        '>'
                    ),
                    '&apos;',
                    $$'$$
                ), -- ' ... vim
                '&quot;',
                '"'
            ),
            '&amp;',
            '&'
        );

xml_pretty_print

Signature: evergreen.xml_pretty_print(input xml)

Returns: xml

Language

sql

Volatility

VOLATILE

Strict

No

Security Definer

No

Simple pretty printer for XML, as written by Andrew Dunstan at http://goo.gl/zBHIk

SELECT xslt_process($1::text,
$$<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    version="1.0">
   <xsl:output method="xml" omit-xml-declaration="yes" indent="yes"/>
   <xsl:strip-space elements="*"/>
   <xsl:template match="@*|node()">
     <xsl:copy>
       <xsl:apply-templates select="@*|node()"/>
     </xsl:copy>
   </xsl:template>
 </xsl:stylesheet>
$$::text)::XML

z3950_attr_name_is_valid

Signature: evergreen.z3950_attr_name_is_valid()

Returns: trigger

Language

plpgsql

Volatility

STABLE

Strict

No

Security Definer

No

Used by a config.z3950_index_field_map constraint trigger to verify z3950_attr_type maps.

    BEGIN

      PERFORM * FROM config.z3950_attr WHERE name = NEW.z3950_attr_type;

      IF FOUND THEN
        RETURN NULL;
      END IF;

      RAISE EXCEPTION '% is not a valid Z39.50 attribute type', NEW.z3950_attr_type;

    END;
Previous
Next