src/backend/catalog/system_functions.sql

   1 /*
   2  * PostgreSQL System Functions
   3  *
   4  * Copyright (c) 1996-2022, PostgreSQL Global Development Group
   5  *
   6  * src/backend/catalog/system_functions.sql
   7  *
   8  * This file redefines certain built-in functions that it's impractical
   9  * to fully define in pg_proc.dat.  In most cases that's because they use
  10  * SQL-standard function bodies and/or default expressions.  The node
  11  * tree representations of those are too unreadable, platform-dependent,
  12  * and changeable to want to deal with them manually.  Hence, we put stub
  13  * definitions of such functions into pg_proc.dat and then replace them
  14  * here.  The stub definitions would be unnecessary were it not that we'd
  15  * like these functions to have stable OIDs, the same as other built-in
  16  * functions.
  17  *
  18  * This file also takes care of adjusting privileges for those functions
  19  * that should not have the default public-EXECUTE privileges.  (However,
  20  * a small number of functions that exist mainly to underlie system views
  21  * are dealt with in system_views.sql, instead.)
  22  *
  23  * Note: this file is read in single-user -j mode, which means that the
  24  * command terminator is semicolon-newline-newline; whenever the backend
  25  * sees that, it stops and executes what it's got.  If you write a lot of
  26  * statements without empty lines between, they'll all get quoted to you
  27  * in any error message about one of them, so don't do that.  Also, you
  28  * cannot write a semicolon immediately followed by an empty line in a
  29  * string literal (including a function body!) or a multiline comment.
  30  */
  31
  32
  33 CREATE OR REPLACE FUNCTION lpad(text, integer)
  34  RETURNS text
  35  LANGUAGE sql
  36  IMMUTABLE PARALLEL SAFE STRICT COST 1
  37 RETURN lpad($1, $2, ' ');
  38
  39 CREATE OR REPLACE FUNCTION rpad(text, integer)
  40  RETURNS text
  41  LANGUAGE sql
  42  IMMUTABLE PARALLEL SAFE STRICT COST 1
  43 RETURN rpad($1, $2, ' ');
  44
  45 CREATE OR REPLACE FUNCTION "substring"(text, text, text)
  46  RETURNS text
  47  LANGUAGE sql
  48  IMMUTABLE PARALLEL SAFE STRICT COST 1
  49 RETURN substring($1, similar_to_escape($2, $3));
  50
  51 CREATE OR REPLACE FUNCTION bit_length(bit)
  52  RETURNS integer
  53  LANGUAGE sql
  54  IMMUTABLE PARALLEL SAFE STRICT COST 1
  55 RETURN length($1);
  56
  57 CREATE OR REPLACE FUNCTION bit_length(bytea)
  58  RETURNS integer
  59  LANGUAGE sql
  60  IMMUTABLE PARALLEL SAFE STRICT COST 1
  61 RETURN octet_length($1) * 8;
  62
  63 CREATE OR REPLACE FUNCTION bit_length(text)
  64  RETURNS integer
  65  LANGUAGE sql
  66  IMMUTABLE PARALLEL SAFE STRICT COST 1
  67 RETURN octet_length($1) * 8;
  68
  69 CREATE OR REPLACE FUNCTION log(numeric)
  70  RETURNS numeric
  71  LANGUAGE sql
  72  IMMUTABLE PARALLEL SAFE STRICT COST 1
  73 RETURN log(10, $1);
  74
  75 CREATE OR REPLACE FUNCTION log10(numeric)
  76  RETURNS numeric
  77  LANGUAGE sql
  78  IMMUTABLE PARALLEL SAFE STRICT COST 1
  79 RETURN log(10, $1);
  80
  81 CREATE OR REPLACE FUNCTION round(numeric)
  82  RETURNS numeric
  83  LANGUAGE sql
  84  IMMUTABLE PARALLEL SAFE STRICT COST 1
  85 RETURN round($1, 0);
  86
  87 CREATE OR REPLACE FUNCTION trunc(numeric)
  88  RETURNS numeric
  89  LANGUAGE sql
  90  IMMUTABLE PARALLEL SAFE STRICT COST 1
  91 RETURN trunc($1, 0);
  92
  93 CREATE OR REPLACE FUNCTION numeric_pl_pg_lsn(numeric, pg_lsn)
  94  RETURNS pg_lsn
  95  LANGUAGE sql
  96  IMMUTABLE PARALLEL SAFE STRICT COST 1
  97 RETURN $2 + $1;
  98
  99 CREATE OR REPLACE FUNCTION path_contain_pt(path, point)
 100  RETURNS boolean
 101  LANGUAGE sql
 102  IMMUTABLE PARALLEL SAFE STRICT COST 1
 103 RETURN on_ppath($2, $1);
 104
 105 CREATE OR REPLACE FUNCTION polygon(circle)
 106  RETURNS polygon
 107  LANGUAGE sql
 108  IMMUTABLE PARALLEL SAFE STRICT COST 1
 109 RETURN polygon(12, $1);
 110
 111 CREATE OR REPLACE FUNCTION age(timestamptz)
 112  RETURNS interval
 113  LANGUAGE sql
 114  STABLE PARALLEL SAFE STRICT COST 1
 115 RETURN age(cast(current_date as timestamptz), $1);
 116
 117 CREATE OR REPLACE FUNCTION age(timestamp)
 118  RETURNS interval
 119  LANGUAGE sql
 120  STABLE PARALLEL SAFE STRICT COST 1
 121 RETURN age(cast(current_date as timestamp), $1);
 122
 123 CREATE OR REPLACE FUNCTION date_part(text, date)
 124  RETURNS double precision
 125  LANGUAGE sql
 126  IMMUTABLE PARALLEL SAFE STRICT COST 1
 127 RETURN date_part($1, cast($2 as timestamp));
 128
 129 CREATE OR REPLACE FUNCTION timestamptz(date, time)
 130  RETURNS timestamptz
 131  LANGUAGE sql
 132  STABLE PARALLEL SAFE STRICT COST 1
 133 RETURN cast(($1 + $2) as timestamptz);
 134
 135 CREATE OR REPLACE FUNCTION timedate_pl(time, date)
 136  RETURNS timestamp
 137  LANGUAGE sql
 138  IMMUTABLE PARALLEL SAFE STRICT COST 1
 139 RETURN $2 + $1;
 140
 141 CREATE OR REPLACE FUNCTION timetzdate_pl(timetz, date)
 142  RETURNS timestamptz
 143  LANGUAGE sql
 144  IMMUTABLE PARALLEL SAFE STRICT COST 1
 145 RETURN $2 + $1;
 146
 147 CREATE OR REPLACE FUNCTION interval_pl_time(interval, time)
 148  RETURNS time
 149  LANGUAGE sql
 150  IMMUTABLE PARALLEL SAFE STRICT COST 1
 151 RETURN $2 + $1;
 152
 153 CREATE OR REPLACE FUNCTION interval_pl_date(interval, date)
 154  RETURNS timestamp
 155  LANGUAGE sql
 156  IMMUTABLE PARALLEL SAFE STRICT COST 1
 157 RETURN $2 + $1;
 158
 159 CREATE OR REPLACE FUNCTION interval_pl_timetz(interval, timetz)
 160  RETURNS timetz
 161  LANGUAGE sql
 162  IMMUTABLE PARALLEL SAFE STRICT COST 1
 163 RETURN $2 + $1;
 164
 165 CREATE OR REPLACE FUNCTION interval_pl_timestamp(interval, timestamp)
 166  RETURNS timestamp
 167  LANGUAGE sql
 168  IMMUTABLE PARALLEL SAFE STRICT COST 1
 169 RETURN $2 + $1;
 170
 171 CREATE OR REPLACE FUNCTION interval_pl_timestamptz(interval, timestamptz)
 172  RETURNS timestamptz
 173  LANGUAGE sql
 174  STABLE PARALLEL SAFE STRICT COST 1
 175 RETURN $2 + $1;
 176
 177 CREATE OR REPLACE FUNCTION integer_pl_date(integer, date)
 178  RETURNS date
 179  LANGUAGE sql
 180  IMMUTABLE PARALLEL SAFE STRICT COST 1
 181 RETURN $2 + $1;
 182
 183 CREATE OR REPLACE FUNCTION "overlaps"(timestamptz, timestamptz,
 184   timestamptz, interval)
 185  RETURNS boolean
 186  LANGUAGE sql
 187  STABLE PARALLEL SAFE COST 1
 188 RETURN ($1, $2) overlaps ($3, ($3 + $4));
 189
 190 CREATE OR REPLACE FUNCTION "overlaps"(timestamptz, interval,
 191   timestamptz, interval)
 192  RETURNS boolean
 193  LANGUAGE sql
 194  STABLE PARALLEL SAFE COST 1
 195 RETURN ($1, ($1 + $2)) overlaps ($3, ($3 + $4));
 196
 197 CREATE OR REPLACE FUNCTION "overlaps"(timestamptz, interval,
 198   timestamptz, timestamptz)
 199  RETURNS boolean
 200  LANGUAGE sql
 201  STABLE PARALLEL SAFE COST 1
 202 RETURN ($1, ($1 + $2)) overlaps ($3, $4);
 203
 204 CREATE OR REPLACE FUNCTION "overlaps"(timestamp, timestamp,
 205   timestamp, interval)
 206  RETURNS boolean
 207  LANGUAGE sql
 208  IMMUTABLE PARALLEL SAFE COST 1
 209 RETURN ($1, $2) overlaps ($3, ($3 + $4));
 210
 211 CREATE OR REPLACE FUNCTION "overlaps"(timestamp, interval,
 212   timestamp, timestamp)
 213  RETURNS boolean
 214  LANGUAGE sql
 215  IMMUTABLE PARALLEL SAFE COST 1
 216 RETURN ($1, ($1 + $2)) overlaps ($3, $4);
 217
 218 CREATE OR REPLACE FUNCTION "overlaps"(timestamp, interval,
 219   timestamp, interval)
 220  RETURNS boolean
 221  LANGUAGE sql
 222  IMMUTABLE PARALLEL SAFE COST 1
 223 RETURN ($1, ($1 + $2)) overlaps ($3, ($3 + $4));
 224
 225 CREATE OR REPLACE FUNCTION "overlaps"(time, interval,
 226   time, interval)
 227  RETURNS boolean
 228  LANGUAGE sql
 229  IMMUTABLE PARALLEL SAFE COST 1
 230 RETURN ($1, ($1 + $2)) overlaps ($3, ($3 + $4));
 231
 232 CREATE OR REPLACE FUNCTION "overlaps"(time, time,
 233   time, interval)
 234  RETURNS boolean
 235  LANGUAGE sql
 236  IMMUTABLE PARALLEL SAFE COST 1
 237 RETURN ($1, $2) overlaps ($3, ($3 + $4));
 238
 239 CREATE OR REPLACE FUNCTION "overlaps"(time, interval,
 240   time, time)
 241  RETURNS boolean
 242  LANGUAGE sql
 243  IMMUTABLE PARALLEL SAFE COST 1
 244 RETURN ($1, ($1 + $2)) overlaps ($3, $4);
 245
 246 CREATE OR REPLACE FUNCTION int8pl_inet(bigint, inet)
 247  RETURNS inet
 248  LANGUAGE sql
 249  IMMUTABLE PARALLEL SAFE STRICT COST 1
 250 RETURN $2 + $1;
 251
 252 CREATE OR REPLACE FUNCTION xpath(text, xml)
 253  RETURNS xml[]
 254  LANGUAGE sql
 255  IMMUTABLE PARALLEL SAFE STRICT COST 1
 256 RETURN xpath($1, $2, '{}'::text[]);
 257
 258 CREATE OR REPLACE FUNCTION xpath_exists(text, xml)
 259  RETURNS boolean
 260  LANGUAGE sql
 261  IMMUTABLE PARALLEL SAFE STRICT COST 1
 262 RETURN xpath_exists($1, $2, '{}'::text[]);
 263
 264 CREATE OR REPLACE FUNCTION pg_sleep_for(interval)
 265  RETURNS void
 266  LANGUAGE sql
 267  PARALLEL SAFE STRICT COST 1
 268 RETURN pg_sleep(extract(epoch from clock_timestamp() + $1) -
 269                 extract(epoch from clock_timestamp()));
 270
 271 CREATE OR REPLACE FUNCTION pg_sleep_until(timestamptz)
 272  RETURNS void
 273  LANGUAGE sql
 274  PARALLEL SAFE STRICT COST 1
 275 RETURN pg_sleep(extract(epoch from $1) -
 276                 extract(epoch from clock_timestamp()));
 277
 278 CREATE OR REPLACE FUNCTION pg_relation_size(regclass)
 279  RETURNS bigint
 280  LANGUAGE sql
 281  PARALLEL SAFE STRICT COST 1
 282 RETURN pg_relation_size($1, 'main');
 283
 284 CREATE OR REPLACE FUNCTION obj_description(oid, name)
 285  RETURNS text
 286  LANGUAGE sql
 287  STABLE PARALLEL SAFE STRICT
 288 BEGIN ATOMIC
 289 select description from pg_description
 290   where objoid = $1 and
 291     classoid = (select oid from pg_class where relname = $2 and
 292                 relnamespace = 'pg_catalog'::regnamespace) and
 293     objsubid = 0;
 294 END;
 295
 296 CREATE OR REPLACE FUNCTION shobj_description(oid, name)
 297  RETURNS text
 298  LANGUAGE sql
 299  STABLE PARALLEL SAFE STRICT
 300 BEGIN ATOMIC
 301 select description from pg_shdescription
 302   where objoid = $1 and
 303     classoid = (select oid from pg_class where relname = $2 and
 304                 relnamespace = 'pg_catalog'::regnamespace);
 305 END;
 306
 307 CREATE OR REPLACE FUNCTION obj_description(oid)
 308  RETURNS text
 309  LANGUAGE sql
 310  STABLE PARALLEL SAFE STRICT
 311 BEGIN ATOMIC
 312 select description from pg_description where objoid = $1 and objsubid = 0;
 313 END;
 314
 315 CREATE OR REPLACE FUNCTION col_description(oid, integer)
 316  RETURNS text
 317  LANGUAGE sql
 318  STABLE PARALLEL SAFE STRICT
 319 BEGIN ATOMIC
 320 select description from pg_description
 321   where objoid = $1 and classoid = 'pg_class'::regclass and objsubid = $2;
 322 END;
 323
 324 CREATE OR REPLACE FUNCTION ts_debug(config regconfig, document text,
 325     OUT alias text,
 326     OUT description text,
 327     OUT token text,
 328     OUT dictionaries regdictionary[],
 329     OUT dictionary regdictionary,
 330     OUT lexemes text[])
 331  RETURNS SETOF record
 332  LANGUAGE sql
 333  STABLE PARALLEL SAFE STRICT
 334 BEGIN ATOMIC
 335 select
 336     tt.alias AS alias,
 337     tt.description AS description,
 338     parse.token AS token,
 339     ARRAY ( SELECT m.mapdict::regdictionary
 340             FROM pg_ts_config_map AS m
 341             WHERE m.mapcfg = $1 AND m.maptokentype = parse.tokid
 342             ORDER BY m.mapseqno )
 343     AS dictionaries,
 344     ( SELECT mapdict::regdictionary
 345       FROM pg_ts_config_map AS m
 346       WHERE m.mapcfg = $1 AND m.maptokentype = parse.tokid
 347       ORDER BY ts_lexize(mapdict, parse.token) IS NULL, m.mapseqno
 348       LIMIT 1
 349     ) AS dictionary,
 350     ( SELECT ts_lexize(mapdict, parse.token)
 351       FROM pg_ts_config_map AS m
 352       WHERE m.mapcfg = $1 AND m.maptokentype = parse.tokid
 353       ORDER BY ts_lexize(mapdict, parse.token) IS NULL, m.mapseqno
 354       LIMIT 1
 355     ) AS lexemes
 356 FROM ts_parse(
 357         (SELECT cfgparser FROM pg_ts_config WHERE oid = $1 ), $2
 358     ) AS parse,
 359      ts_token_type(
 360         (SELECT cfgparser FROM pg_ts_config WHERE oid = $1 )
 361     ) AS tt
 362 WHERE tt.tokid = parse.tokid;
 363 END;
 364
 365 CREATE OR REPLACE FUNCTION ts_debug(document text,
 366     OUT alias text,
 367     OUT description text,
 368     OUT token text,
 369     OUT dictionaries regdictionary[],
 370     OUT dictionary regdictionary,
 371     OUT lexemes text[])
 372  RETURNS SETOF record
 373  LANGUAGE sql
 374  STABLE PARALLEL SAFE STRICT
 375 BEGIN ATOMIC
 376     SELECT * FROM ts_debug(get_current_ts_config(), $1);
 377 END;
 378
 379 CREATE OR REPLACE FUNCTION
 380   pg_start_backup(label text, fast boolean DEFAULT false, exclusive boolean DEFAULT true)
 381   RETURNS pg_lsn STRICT VOLATILE LANGUAGE internal AS 'pg_start_backup'
 382   PARALLEL RESTRICTED;
 383
 384 CREATE OR REPLACE FUNCTION pg_stop_backup (
 385         exclusive boolean, wait_for_archive boolean DEFAULT true,
 386         OUT lsn pg_lsn, OUT labelfile text, OUT spcmapfile text)
 387   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
 388   PARALLEL RESTRICTED;
 389
 390 CREATE OR REPLACE FUNCTION
 391   pg_promote(wait boolean DEFAULT true, wait_seconds integer DEFAULT 60)
 392   RETURNS boolean STRICT VOLATILE LANGUAGE INTERNAL AS 'pg_promote'
 393   PARALLEL SAFE;
 394
 395 CREATE OR REPLACE FUNCTION
 396   pg_terminate_backend(pid integer, timeout int8 DEFAULT 0)
 397   RETURNS boolean STRICT VOLATILE LANGUAGE INTERNAL AS 'pg_terminate_backend'
 398   PARALLEL SAFE;
 399
 400 -- legacy definition for compatibility with 9.3
 401 CREATE OR REPLACE FUNCTION
 402   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
 403   RETURNS anyelement LANGUAGE internal STABLE AS 'json_populate_record' PARALLEL SAFE;
 404
 405 -- legacy definition for compatibility with 9.3
 406 CREATE OR REPLACE FUNCTION
 407   json_populate_recordset(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
 408   RETURNS SETOF anyelement LANGUAGE internal STABLE ROWS 100  AS 'json_populate_recordset' PARALLEL SAFE;
 409
 410 CREATE OR REPLACE FUNCTION pg_logical_slot_get_changes(
 411     IN slot_name name, IN upto_lsn pg_lsn, IN upto_nchanges int, VARIADIC options text[] DEFAULT '{}',
 412     OUT lsn pg_lsn, OUT xid xid, OUT data text)
 413 RETURNS SETOF RECORD
 414 LANGUAGE INTERNAL
 415 VOLATILE ROWS 1000 COST 1000
 416 AS 'pg_logical_slot_get_changes';
 417
 418 CREATE OR REPLACE FUNCTION pg_logical_slot_peek_changes(
 419     IN slot_name name, IN upto_lsn pg_lsn, IN upto_nchanges int, VARIADIC options text[] DEFAULT '{}',
 420     OUT lsn pg_lsn, OUT xid xid, OUT data text)
 421 RETURNS SETOF RECORD
 422 LANGUAGE INTERNAL
 423 VOLATILE ROWS 1000 COST 1000
 424 AS 'pg_logical_slot_peek_changes';
 425
 426 CREATE OR REPLACE FUNCTION pg_logical_slot_get_binary_changes(
 427     IN slot_name name, IN upto_lsn pg_lsn, IN upto_nchanges int, VARIADIC options text[] DEFAULT '{}',
 428     OUT lsn pg_lsn, OUT xid xid, OUT data bytea)
 429 RETURNS SETOF RECORD
 430 LANGUAGE INTERNAL
 431 VOLATILE ROWS 1000 COST 1000
 432 AS 'pg_logical_slot_get_binary_changes';
 433
 434 CREATE OR REPLACE FUNCTION pg_logical_slot_peek_binary_changes(
 435     IN slot_name name, IN upto_lsn pg_lsn, IN upto_nchanges int, VARIADIC options text[] DEFAULT '{}',
 436     OUT lsn pg_lsn, OUT xid xid, OUT data bytea)
 437 RETURNS SETOF RECORD
 438 LANGUAGE INTERNAL
 439 VOLATILE ROWS 1000 COST 1000
 440 AS 'pg_logical_slot_peek_binary_changes';
 441
 442 CREATE OR REPLACE FUNCTION pg_create_physical_replication_slot(
 443     IN slot_name name, IN immediately_reserve boolean DEFAULT false,
 444     IN temporary boolean DEFAULT false,
 445     OUT slot_name name, OUT lsn pg_lsn)
 446 RETURNS RECORD
 447 LANGUAGE INTERNAL
 448 STRICT VOLATILE
 449 AS 'pg_create_physical_replication_slot';
 450
 451 CREATE OR REPLACE FUNCTION pg_create_logical_replication_slot(
 452     IN slot_name name, IN plugin name,
 453     IN temporary boolean DEFAULT false,
 454     IN twophase boolean DEFAULT false,
 455     OUT slot_name name, OUT lsn pg_lsn)
 456 RETURNS RECORD
 457 LANGUAGE INTERNAL
 458 STRICT VOLATILE
 459 AS 'pg_create_logical_replication_slot';
 460
 461 CREATE OR REPLACE FUNCTION
 462   make_interval(years int4 DEFAULT 0, months int4 DEFAULT 0, weeks int4 DEFAULT 0,
 463                 days int4 DEFAULT 0, hours int4 DEFAULT 0, mins int4 DEFAULT 0,
 464                 secs double precision DEFAULT 0.0)
 465 RETURNS interval
 466 LANGUAGE INTERNAL
 467 STRICT IMMUTABLE PARALLEL SAFE
 468 AS 'make_interval';
 469
 470 CREATE OR REPLACE FUNCTION
 471   jsonb_set(jsonb_in jsonb, path text[] , replacement jsonb,
 472             create_if_missing boolean DEFAULT true)
 473 RETURNS jsonb
 474 LANGUAGE INTERNAL
 475 STRICT IMMUTABLE PARALLEL SAFE
 476 AS 'jsonb_set';
 477
 478 CREATE OR REPLACE FUNCTION
 479   jsonb_set_lax(jsonb_in jsonb, path text[] , replacement jsonb,
 480             create_if_missing boolean DEFAULT true,
 481             null_value_treatment text DEFAULT 'use_json_null')
 482 RETURNS jsonb
 483 LANGUAGE INTERNAL
 484 CALLED ON NULL INPUT IMMUTABLE PARALLEL SAFE
 485 AS 'jsonb_set_lax';
 486
 487 CREATE OR REPLACE FUNCTION
 488   parse_ident(str text, strict boolean DEFAULT true)
 489 RETURNS text[]
 490 LANGUAGE INTERNAL
 491 STRICT IMMUTABLE PARALLEL SAFE
 492 AS 'parse_ident';
 493
 494 CREATE OR REPLACE FUNCTION
 495   jsonb_insert(jsonb_in jsonb, path text[] , replacement jsonb,
 496             insert_after boolean DEFAULT false)
 497 RETURNS jsonb
 498 LANGUAGE INTERNAL
 499 STRICT IMMUTABLE PARALLEL SAFE
 500 AS 'jsonb_insert';
 501
 502 CREATE OR REPLACE FUNCTION
 503   jsonb_path_exists(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 504                     silent boolean DEFAULT false)
 505 RETURNS boolean
 506 LANGUAGE INTERNAL
 507 STRICT IMMUTABLE PARALLEL SAFE
 508 AS 'jsonb_path_exists';
 509
 510 CREATE OR REPLACE FUNCTION
 511   jsonb_path_match(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 512                    silent boolean DEFAULT false)
 513 RETURNS boolean
 514 LANGUAGE INTERNAL
 515 STRICT IMMUTABLE PARALLEL SAFE
 516 AS 'jsonb_path_match';
 517
 518 CREATE OR REPLACE FUNCTION
 519   jsonb_path_query(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 520                    silent boolean DEFAULT false)
 521 RETURNS SETOF jsonb
 522 LANGUAGE INTERNAL
 523 STRICT IMMUTABLE PARALLEL SAFE
 524 AS 'jsonb_path_query';
 525
 526 CREATE OR REPLACE FUNCTION
 527   jsonb_path_query_array(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 528                          silent boolean DEFAULT false)
 529 RETURNS jsonb
 530 LANGUAGE INTERNAL
 531 STRICT IMMUTABLE PARALLEL SAFE
 532 AS 'jsonb_path_query_array';
 533
 534 CREATE OR REPLACE FUNCTION
 535   jsonb_path_query_first(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 536                          silent boolean DEFAULT false)
 537 RETURNS jsonb
 538 LANGUAGE INTERNAL
 539 STRICT IMMUTABLE PARALLEL SAFE
 540 AS 'jsonb_path_query_first';
 541
 542 CREATE OR REPLACE FUNCTION
 543   jsonb_path_exists_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 544                     silent boolean DEFAULT false)
 545 RETURNS boolean
 546 LANGUAGE INTERNAL
 547 STRICT STABLE PARALLEL SAFE
 548 AS 'jsonb_path_exists_tz';
 549
 550 CREATE OR REPLACE FUNCTION
 551   jsonb_path_match_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 552                    silent boolean DEFAULT false)
 553 RETURNS boolean
 554 LANGUAGE INTERNAL
 555 STRICT STABLE PARALLEL SAFE
 556 AS 'jsonb_path_match_tz';
 557
 558 CREATE OR REPLACE FUNCTION
 559   jsonb_path_query_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 560                    silent boolean DEFAULT false)
 561 RETURNS SETOF jsonb
 562 LANGUAGE INTERNAL
 563 STRICT STABLE PARALLEL SAFE
 564 AS 'jsonb_path_query_tz';
 565
 566 CREATE OR REPLACE FUNCTION
 567   jsonb_path_query_array_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 568                          silent boolean DEFAULT false)
 569 RETURNS jsonb
 570 LANGUAGE INTERNAL
 571 STRICT STABLE PARALLEL SAFE
 572 AS 'jsonb_path_query_array_tz';
 573
 574 CREATE OR REPLACE FUNCTION
 575   jsonb_path_query_first_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}',
 576                          silent boolean DEFAULT false)
 577 RETURNS jsonb
 578 LANGUAGE INTERNAL
 579 STRICT STABLE PARALLEL SAFE
 580 AS 'jsonb_path_query_first_tz';
 581
 582 -- default normalization form is NFC, per SQL standard
 583 CREATE OR REPLACE FUNCTION
 584   "normalize"(text, text DEFAULT 'NFC')
 585 RETURNS text
 586 LANGUAGE internal
 587 STRICT IMMUTABLE PARALLEL SAFE
 588 AS 'unicode_normalize_func';
 589
 590 CREATE OR REPLACE FUNCTION
 591   is_normalized(text, text DEFAULT 'NFC')
 592 RETURNS boolean
 593 LANGUAGE internal
 594 STRICT IMMUTABLE PARALLEL SAFE
 595 AS 'unicode_is_normalized';
 596
 597 --
 598 -- The default permissions for functions mean that anyone can execute them.
 599 -- A number of functions shouldn't be executable by just anyone, but rather
 600 -- than use explicit 'superuser()' checks in those functions, we use the GRANT
 601 -- system to REVOKE access to those functions at initdb time.  Administrators
 602 -- can later change who can access these functions, or leave them as only
 603 -- available to superuser / cluster owner, if they choose.
 604 --
 605
 606 REVOKE EXECUTE ON FUNCTION pg_start_backup(text, boolean, boolean) FROM public;
 607
 608 REVOKE EXECUTE ON FUNCTION pg_stop_backup() FROM public;
 609
 610 REVOKE EXECUTE ON FUNCTION pg_stop_backup(boolean, boolean) FROM public;
 611
 612 REVOKE EXECUTE ON FUNCTION pg_create_restore_point(text) FROM public;
 613
 614 REVOKE EXECUTE ON FUNCTION pg_switch_wal() FROM public;
 615
 616 REVOKE EXECUTE ON FUNCTION pg_wal_replay_pause() FROM public;
 617
 618 REVOKE EXECUTE ON FUNCTION pg_wal_replay_resume() FROM public;
 619
 620 REVOKE EXECUTE ON FUNCTION pg_rotate_logfile() FROM public;
 621
 622 REVOKE EXECUTE ON FUNCTION pg_reload_conf() FROM public;
 623
 624 REVOKE EXECUTE ON FUNCTION pg_current_logfile() FROM public;
 625
 626 REVOKE EXECUTE ON FUNCTION pg_current_logfile(text) FROM public;
 627
 628 REVOKE EXECUTE ON FUNCTION pg_promote(boolean, integer) FROM public;
 629
 630 REVOKE EXECUTE ON FUNCTION pg_stat_reset() FROM public;
 631
 632 REVOKE EXECUTE ON FUNCTION pg_stat_reset_shared(text) FROM public;
 633
 634 REVOKE EXECUTE ON FUNCTION pg_stat_reset_slru(text) FROM public;
 635
 636 REVOKE EXECUTE ON FUNCTION pg_stat_reset_single_table_counters(oid) FROM public;
 637
 638 REVOKE EXECUTE ON FUNCTION pg_stat_reset_single_function_counters(oid) FROM public;
 639
 640 REVOKE EXECUTE ON FUNCTION pg_stat_reset_replication_slot(text) FROM public;
 641
 642 REVOKE EXECUTE ON FUNCTION pg_stat_reset_subscription_worker(oid) FROM public;
 643
 644 REVOKE EXECUTE ON FUNCTION pg_stat_reset_subscription_worker(oid, oid) FROM public;
 645
 646 REVOKE EXECUTE ON FUNCTION lo_import(text) FROM public;
 647
 648 REVOKE EXECUTE ON FUNCTION lo_import(text, oid) FROM public;
 649
 650 REVOKE EXECUTE ON FUNCTION lo_export(oid, text) FROM public;
 651
 652 REVOKE EXECUTE ON FUNCTION pg_ls_logdir() FROM public;
 653
 654 REVOKE EXECUTE ON FUNCTION pg_ls_waldir() FROM public;
 655
 656 REVOKE EXECUTE ON FUNCTION pg_ls_archive_statusdir() FROM public;
 657
 658 REVOKE EXECUTE ON FUNCTION pg_ls_tmpdir() FROM public;
 659
 660 REVOKE EXECUTE ON FUNCTION pg_ls_tmpdir(oid) FROM public;
 661
 662 REVOKE EXECUTE ON FUNCTION pg_read_file(text) FROM public;
 663
 664 REVOKE EXECUTE ON FUNCTION pg_read_file(text,bigint,bigint) FROM public;
 665
 666 REVOKE EXECUTE ON FUNCTION pg_read_file(text,bigint,bigint,boolean) FROM public;
 667
 668 REVOKE EXECUTE ON FUNCTION pg_read_binary_file(text) FROM public;
 669
 670 REVOKE EXECUTE ON FUNCTION pg_read_binary_file(text,bigint,bigint) FROM public;
 671
 672 REVOKE EXECUTE ON FUNCTION pg_read_binary_file(text,bigint,bigint,boolean) FROM public;
 673
 674 REVOKE EXECUTE ON FUNCTION pg_replication_origin_advance(text, pg_lsn) FROM public;
 675
 676 REVOKE EXECUTE ON FUNCTION pg_replication_origin_create(text) FROM public;
 677
 678 REVOKE EXECUTE ON FUNCTION pg_replication_origin_drop(text) FROM public;
 679
 680 REVOKE EXECUTE ON FUNCTION pg_replication_origin_oid(text) FROM public;
 681
 682 REVOKE EXECUTE ON FUNCTION pg_replication_origin_progress(text, boolean) FROM public;
 683
 684 REVOKE EXECUTE ON FUNCTION pg_replication_origin_session_is_setup() FROM public;
 685
 686 REVOKE EXECUTE ON FUNCTION pg_replication_origin_session_progress(boolean) FROM public;
 687
 688 REVOKE EXECUTE ON FUNCTION pg_replication_origin_session_reset() FROM public;
 689
 690 REVOKE EXECUTE ON FUNCTION pg_replication_origin_session_setup(text) FROM public;
 691
 692 REVOKE EXECUTE ON FUNCTION pg_replication_origin_xact_reset() FROM public;
 693
 694 REVOKE EXECUTE ON FUNCTION pg_replication_origin_xact_setup(pg_lsn, timestamp with time zone) FROM public;
 695
 696 REVOKE EXECUTE ON FUNCTION pg_show_replication_origin_status() FROM public;
 697
 698 REVOKE EXECUTE ON FUNCTION pg_stat_file(text) FROM public;
 699
 700 REVOKE EXECUTE ON FUNCTION pg_stat_file(text,boolean) FROM public;
 701
 702 REVOKE EXECUTE ON FUNCTION pg_ls_dir(text) FROM public;
 703
 704 REVOKE EXECUTE ON FUNCTION pg_ls_dir(text,boolean,boolean) FROM public;
 705
 706 REVOKE EXECUTE ON FUNCTION pg_log_backend_memory_contexts(integer) FROM PUBLIC;
 707
 708 REVOKE EXECUTE ON FUNCTION pg_ls_logicalsnapdir() FROM PUBLIC;
 709
 710 REVOKE EXECUTE ON FUNCTION pg_ls_logicalmapdir() FROM PUBLIC;
 711
 712 REVOKE EXECUTE ON FUNCTION pg_ls_replslotdir(text) FROM PUBLIC;
 713
 714 --
 715 -- We also set up some things as accessible to standard roles.
 716 --
 717
 718 GRANT EXECUTE ON FUNCTION pg_ls_logdir() TO pg_monitor;
 719
 720 GRANT EXECUTE ON FUNCTION pg_ls_waldir() TO pg_monitor;
 721
 722 GRANT EXECUTE ON FUNCTION pg_ls_archive_statusdir() TO pg_monitor;
 723
 724 GRANT EXECUTE ON FUNCTION pg_ls_tmpdir() TO pg_monitor;
 725
 726 GRANT EXECUTE ON FUNCTION pg_ls_tmpdir(oid) TO pg_monitor;
 727
 728 GRANT EXECUTE ON FUNCTION pg_ls_logicalsnapdir() TO pg_monitor;
 729
 730 GRANT EXECUTE ON FUNCTION pg_ls_logicalmapdir() TO pg_monitor;
 731
 732 GRANT EXECUTE ON FUNCTION pg_ls_replslotdir(text) TO pg_monitor;
 733
 734 GRANT pg_read_all_settings TO pg_monitor;
 735
 736 GRANT pg_read_all_stats TO pg_monitor;
 737
 738 GRANT pg_stat_scan_tables TO pg_monitor;