Project

General

Profile

« Previous | Next » 

Revision 12235

schemas/*.sql: make sure every COMMENT starts and ends on its own line, so that it appears correctly in the formats it's most likely to be read in (ie. in the DDL export, not the COMMENT edit box in pgAdmin)

View differences:

util.sql
20 20
-- Name: SCHEMA util; Type: COMMENT; Schema: -; Owner: -
21 21
--
22 22

  
23
COMMENT ON SCHEMA util IS 'IMPORTANT: Functions must always return NULL in place of '''' (the empty string). This ensures that empty strings do not find their way into VegBIEN.
23
COMMENT ON SCHEMA util IS '
24
IMPORTANT: Functions must always return NULL in place of '''' (the empty string). This ensures that empty strings do not find their way into VegBIEN.
24 25

  
25
NOTE: IMMUTABLE SQL-language functions should never be declared STRICT, because this prevents them from being inlined. inlining can create a significant speed improvement (7x+), by avoiding function calls and enabling additional constant folding.';
26
NOTE: IMMUTABLE SQL-language functions should never be declared STRICT, because this prevents them from being inlined. inlining can create a significant speed improvement (7x+), by avoiding function calls and enabling additional constant folding.
27
';
26 28

  
27 29

  
28 30
SET search_path = util, pg_catalog;
......
104 106
-- Name: FUNCTION _and("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean); Type: COMMENT; Schema: util; Owner: -
105 107
--
106 108

  
107
COMMENT ON FUNCTION _and("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean) IS '_and() ignores NULL values, while AND combines them with the other values to potentially convert true to NULL. AND should be used with required fields, and _and() with optional fields.';
109
COMMENT ON FUNCTION _and("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean) IS '
110
_and() ignores NULL values, while AND combines them with the other values to potentially convert true to NULL. AND should be used with required fields, and _and() with optional fields.
111
';
108 112

  
109 113

  
110 114
--
......
499 503
-- Name: FUNCTION _or("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean); Type: COMMENT; Schema: util; Owner: -
500 504
--
501 505

  
502
COMMENT ON FUNCTION _or("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean) IS '_or() ignores NULL values, while OR combines them with the other values to potentially convert false to NULL. OR should be used with required fields, and _or() with optional fields.';
506
COMMENT ON FUNCTION _or("0" boolean, "1" boolean, "2" boolean, "3" boolean, "4" boolean) IS '
507
_or() ignores NULL values, while OR combines them with the other values to potentially convert false to NULL. OR should be used with required fields, and _or() with optional fields.
508
';
503 509

  
504 510

  
505 511
--
......
546 552
-- Name: FUNCTION added_cols(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
547 553
--
548 554

  
549
COMMENT ON FUNCTION added_cols(table_ regclass, names regclass) IS 'gets table_''s added columns (all the columns not in the original data)';
555
COMMENT ON FUNCTION added_cols(table_ regclass, names regclass) IS '
556
gets table_''s added columns (all the columns not in the original data)
557
';
550 558

  
551 559

  
552 560
--
......
614 622
-- Name: FUNCTION array_length("array" anyarray, dimension integer); Type: COMMENT; Schema: util; Owner: -
615 623
--
616 624

  
617
COMMENT ON FUNCTION array_length("array" anyarray, dimension integer) IS 'returns 0 instead of NULL for empty arrays';
625
COMMENT ON FUNCTION array_length("array" anyarray, dimension integer) IS '
626
returns 0 instead of NULL for empty arrays
627
';
618 628

  
619 629

  
620 630
--
......
648 658
-- Name: FUNCTION cluster_once(table_ regclass, index regclass); Type: COMMENT; Schema: util; Owner: -
649 659
--
650 660

  
651
COMMENT ON FUNCTION cluster_once(table_ regclass, index regclass) IS 'idempotent';
661
COMMENT ON FUNCTION cluster_once(table_ regclass, index regclass) IS '
662
idempotent
663
';
652 664

  
653 665

  
654 666
--
......
729 741
-- Name: FUNCTION col_default_value(col col_ref, ret_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
730 742
--
731 743

  
732
COMMENT ON FUNCTION col_default_value(col col_ref, ret_type_null anyelement) IS 'ret_type_null: NULL::ret_type';
744
COMMENT ON FUNCTION col_default_value(col col_ref, ret_type_null anyelement) IS '
745
ret_type_null: NULL::ret_type
746
';
733 747

  
734 748

  
735 749
--
......
862 876
-- Name: FUNCTION create_if_not_exists(sql text); Type: COMMENT; Schema: util; Owner: -
863 877
--
864 878

  
865
COMMENT ON FUNCTION create_if_not_exists(sql text) IS 'idempotent';
879
COMMENT ON FUNCTION create_if_not_exists(sql text) IS '
880
idempotent
881
';
866 882

  
867 883

  
868 884
--
......
885 901
-- Name: FUNCTION derived_cols(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
886 902
--
887 903

  
888
COMMENT ON FUNCTION derived_cols(table_ regclass, names regclass) IS 'gets table_''s derived columns (all the columns not in the names table)';
904
COMMENT ON FUNCTION derived_cols(table_ regclass, names regclass) IS '
905
gets table_''s derived columns (all the columns not in the names table)
906
';
889 907

  
890 908

  
891 909
--
......
916 934
-- Name: FUNCTION diff_cols(left_query text, right_query text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement); Type: COMMENT; Schema: util; Owner: -
917 935
--
918 936

  
919
COMMENT ON FUNCTION diff_cols(left_query text, right_query text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS 'col_type_null (*required*): NULL::col_type
937
COMMENT ON FUNCTION diff_cols(left_query text, right_query text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS '
938
col_type_null (*required*): NULL::col_type
920 939
usage:
921 940
SELECT * FROM util.diff_cols($$VALUES (''1''), (''2''), (''4'')$$, $$VALUES (''1''), (''3''), (''4'')$$, NULL::text)
922 941

  
......
942 961
-- Name: FUNCTION diff_views(left_view regclass, right_view regclass, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement); Type: COMMENT; Schema: util; Owner: -
943 962
--
944 963

  
945
COMMENT ON FUNCTION diff_views(left_view regclass, right_view regclass, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS 'col_type_null (*required*): NULL::col_type
964
COMMENT ON FUNCTION diff_views(left_view regclass, right_view regclass, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS '
965
col_type_null (*required*): NULL::col_type
946 966
usage:
947 967
SELECT * FROM util.diff_views(''"left_view"'', ''"right_view"'', NULL::text)
948 968
';
......
963 983
-- Name: FUNCTION do_optionally_ignore(sql text, ignore boolean); Type: COMMENT; Schema: util; Owner: -
964 984
--
965 985

  
966
COMMENT ON FUNCTION do_optionally_ignore(sql text, ignore boolean) IS 'idempotent';
986
COMMENT ON FUNCTION do_optionally_ignore(sql text, ignore boolean) IS '
987
idempotent
988
';
967 989

  
968 990

  
969 991
--
......
982 1004
-- Name: FUNCTION drop_column(col col_ref); Type: COMMENT; Schema: util; Owner: -
983 1005
--
984 1006

  
985
COMMENT ON FUNCTION drop_column(col col_ref) IS 'idempotent';
1007
COMMENT ON FUNCTION drop_column(col col_ref) IS '
1008
idempotent
1009
';
986 1010

  
987 1011

  
988 1012
--
......
1000 1024
-- Name: FUNCTION drop_table(table_ text); Type: COMMENT; Schema: util; Owner: -
1001 1025
--
1002 1026

  
1003
COMMENT ON FUNCTION drop_table(table_ text) IS 'idempotent';
1027
COMMENT ON FUNCTION drop_table(table_ text) IS '
1028
idempotent
1029
';
1004 1030

  
1005 1031

  
1006 1032
--
......
1018 1044
-- Name: FUNCTION drop_view(view_ text); Type: COMMENT; Schema: util; Owner: -
1019 1045
--
1020 1046

  
1021
COMMENT ON FUNCTION drop_view(view_ text) IS 'idempotent';
1047
COMMENT ON FUNCTION drop_view(view_ text) IS '
1048
idempotent
1049
';
1022 1050

  
1023 1051

  
1024 1052
--
......
1036 1064
-- Name: FUNCTION empty_array(elem_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
1037 1065
--
1038 1066

  
1039
COMMENT ON FUNCTION empty_array(elem_type_null anyelement) IS 'constructs proper empty 1-dimensional array whose dimensions are not NULL ( ''{}''::text[] does not do this)';
1067
COMMENT ON FUNCTION empty_array(elem_type_null anyelement) IS '
1068
constructs proper empty 1-dimensional array whose dimensions are not NULL ( ''{}''::text[] does not do this)
1069
';
1040 1070

  
1041 1071

  
1042 1072
--
......
1093 1123
-- Name: FUNCTION eval2col_pair(sql text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement); Type: COMMENT; Schema: util; Owner: -
1094 1124
--
1095 1125

  
1096
COMMENT ON FUNCTION eval2col_pair(sql text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS 'col_type_null (*required*): NULL::col_type';
1126
COMMENT ON FUNCTION eval2col_pair(sql text, col_type_null anyelement, OUT left_ anyelement, OUT right_ anyelement) IS '
1127
col_type_null (*required*): NULL::col_type
1128
';
1097 1129

  
1098 1130

  
1099 1131
--
......
1114 1146
-- Name: FUNCTION eval2set(sql text, ret_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
1115 1147
--
1116 1148

  
1117
COMMENT ON FUNCTION eval2set(sql text, ret_type_null anyelement) IS 'ret_type_null: NULL::ret_type';
1149
COMMENT ON FUNCTION eval2set(sql text, ret_type_null anyelement) IS '
1150
ret_type_null: NULL::ret_type
1151
';
1118 1152

  
1119 1153

  
1120 1154
--
......
1138 1172
-- Name: FUNCTION eval2val(sql text, ret_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
1139 1173
--
1140 1174

  
1141
COMMENT ON FUNCTION eval2val(sql text, ret_type_null anyelement) IS 'ret_type_null: NULL::ret_type';
1175
COMMENT ON FUNCTION eval2val(sql text, ret_type_null anyelement) IS '
1176
ret_type_null: NULL::ret_type
1177
';
1142 1178

  
1143 1179

  
1144 1180
--
......
1156 1192
-- Name: FUNCTION eval_expr(sql text, ret_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
1157 1193
--
1158 1194

  
1159
COMMENT ON FUNCTION eval_expr(sql text, ret_type_null anyelement) IS 'ret_type_null: NULL::ret_type';
1195
COMMENT ON FUNCTION eval_expr(sql text, ret_type_null anyelement) IS '
1196
ret_type_null: NULL::ret_type
1197
';
1160 1198

  
1161 1199

  
1162 1200
--
......
1174 1212
-- Name: FUNCTION eval_expr_passthru(sql text, ret_type_null anyelement); Type: COMMENT; Schema: util; Owner: -
1175 1213
--
1176 1214

  
1177
COMMENT ON FUNCTION eval_expr_passthru(sql text, ret_type_null anyelement) IS 'sql: can be NULL, which will be passed through
1178
ret_type_null: NULL::ret_type';
1215
COMMENT ON FUNCTION eval_expr_passthru(sql text, ret_type_null anyelement) IS '
1216
sql: can be NULL, which will be passed through
1217
ret_type_null: NULL::ret_type
1218
';
1179 1219

  
1180 1220

  
1181 1221
--
......
1258 1298
-- Name: FUNCTION explain2table(sql text, table_ regclass); Type: COMMENT; Schema: util; Owner: -
1259 1299
--
1260 1300

  
1261
COMMENT ON FUNCTION explain2table(sql text, table_ regclass) IS 'usage:
1301
COMMENT ON FUNCTION explain2table(sql text, table_ regclass) IS '
1302
usage:
1262 1303
PERFORM util.explain2table($$
1263 1304
query
1264
$$);';
1305
$$);
1306
';
1265 1307

  
1266 1308

  
1267 1309
--
......
1281 1323
-- Name: FUNCTION fix_array("array" anyarray); Type: COMMENT; Schema: util; Owner: -
1282 1324
--
1283 1325

  
1284
COMMENT ON FUNCTION fix_array("array" anyarray) IS 'ensures that an array will always have proper non-NULL dimensions';
1326
COMMENT ON FUNCTION fix_array("array" anyarray) IS '
1327
ensures that an array will always have proper non-NULL dimensions
1328
';
1285 1329

  
1286 1330

  
1287 1331
--
......
1313 1357
-- Name: FUNCTION force_recreate(cmd text, users text[]); Type: COMMENT; Schema: util; Owner: -
1314 1358
--
1315 1359

  
1316
COMMENT ON FUNCTION force_recreate(cmd text, users text[]) IS 'idempotent
1360
COMMENT ON FUNCTION force_recreate(cmd text, users text[]) IS '
1361
idempotent
1317 1362

  
1318
users: not necessary to provide this because it will be autopopulated';
1363
users: not necessary to provide this because it will be autopopulated
1364
';
1319 1365

  
1320 1366

  
1321 1367
--
......
1347 1393
-- Name: FUNCTION force_update_view(view_ text, query text); Type: COMMENT; Schema: util; Owner: -
1348 1394
--
1349 1395

  
1350
COMMENT ON FUNCTION force_update_view(view_ text, query text) IS 'idempotent';
1396
COMMENT ON FUNCTION force_update_view(view_ text, query text) IS '
1397
idempotent
1398
';
1351 1399

  
1352 1400

  
1353 1401
--
......
1387 1435
-- Name: FUNCTION hstore(keys text[], value text); Type: COMMENT; Schema: util; Owner: -
1388 1436
--
1389 1437

  
1390
COMMENT ON FUNCTION hstore(keys text[], value text) IS 'avoids repeating the same value for each key';
1438
COMMENT ON FUNCTION hstore(keys text[], value text) IS '
1439
avoids repeating the same value for each key
1440
';
1391 1441

  
1392 1442

  
1393 1443
--
......
1405 1455
-- Name: FUNCTION ifnull(value anyelement, null_ anyelement); Type: COMMENT; Schema: util; Owner: -
1406 1456
--
1407 1457

  
1408
COMMENT ON FUNCTION ifnull(value anyelement, null_ anyelement) IS 'equivalent to MySQL''s IFNULL() (Postgres auto-lowercases the name)';
1458
COMMENT ON FUNCTION ifnull(value anyelement, null_ anyelement) IS '
1459
equivalent to MySQL''s IFNULL() (Postgres auto-lowercases the name)
1460
';
1409 1461

  
1410 1462

  
1411 1463
--
......
1520 1572
-- Name: FUNCTION map_nulls(nulls text[], value anyelement); Type: COMMENT; Schema: util; Owner: -
1521 1573
--
1522 1574

  
1523
COMMENT ON FUNCTION map_nulls(nulls text[], value anyelement) IS 'due to dynamic inlining[1], this is just as fast as util._map() which it wraps[2].
1575
COMMENT ON FUNCTION map_nulls(nulls text[], value anyelement) IS '
1576
due to dynamic inlining[1], this is just as fast as util._map() which it wraps[2].
1524 1577

  
1525 1578
[1] inlining of function calls, which is different from constant folding
1526 1579
[2] _map()''s profiling query
......
1528 1581
and map_nulls()''s profiling query
1529 1582
SELECT util.map_nulls(array[1, 2, 3]::text[], v) FROM unnest(array_fill(1, array[100000])) f (v)
1530 1583
both take ~920 ms.
1531
also, /inputs/REMIB/Specimen/postprocess.sql > country takes the same amount of time (56000 ms) to build with map_nulls() as with a literal hstore.';
1584
also, /inputs/REMIB/Specimen/postprocess.sql > country takes the same amount of time (56000 ms) to build with map_nulls() as with a literal hstore.
1585
';
1532 1586

  
1533 1587

  
1534 1588
--
......
1560 1614
-- Name: FUNCTION materialize_query(table_ text, sql text); Type: COMMENT; Schema: util; Owner: -
1561 1615
--
1562 1616

  
1563
COMMENT ON FUNCTION materialize_query(table_ text, sql text) IS 'idempotent';
1617
COMMENT ON FUNCTION materialize_query(table_ text, sql text) IS '
1618
idempotent
1619
';
1564 1620

  
1565 1621

  
1566 1622
--
......
1578 1634
-- Name: FUNCTION materialize_view(table_ text, view_ regclass); Type: COMMENT; Schema: util; Owner: -
1579 1635
--
1580 1636

  
1581
COMMENT ON FUNCTION materialize_view(table_ text, view_ regclass) IS 'idempotent';
1637
COMMENT ON FUNCTION materialize_view(table_ text, view_ regclass) IS '
1638
idempotent
1639
';
1582 1640

  
1583 1641

  
1584 1642
--
......
1592 1650
ALTER TABLE $$||$1.table_||$$ ADD COLUMN $$
1593 1651
||quote_ident($1.name)||$$ $$||pg_typeof($2)||util.type_qual($2)||$$ DEFAULT $$
1594 1652
||quote_literal($2)||$$;
1595
COMMENT ON COLUMN $$||$1.table_||$$.$$||quote_ident($1.name)||$$ IS 'constant';
1653
COMMENT ON COLUMN $$||$1.table_||$$.$$||quote_ident($1.name)||$$ IS '
1654
constant
1655
';
1596 1656
$$)
1597 1657
$_$;
1598 1658

  
......
1601 1661
-- Name: FUNCTION mk_const_col(col col_ref, value anyelement); Type: COMMENT; Schema: util; Owner: -
1602 1662
--
1603 1663

  
1604
COMMENT ON FUNCTION mk_const_col(col col_ref, value anyelement) IS 'idempotent';
1664
COMMENT ON FUNCTION mk_const_col(col col_ref, value anyelement) IS '
1665
idempotent
1666
';
1605 1667

  
1606 1668

  
1607 1669
--
......
1628 1690
-- Name: FUNCTION mk_derived_col(col col_ref, expr text, overwrite boolean); Type: COMMENT; Schema: util; Owner: -
1629 1691
--
1630 1692

  
1631
COMMENT ON FUNCTION mk_derived_col(col col_ref, expr text, overwrite boolean) IS 'idempotent';
1693
COMMENT ON FUNCTION mk_derived_col(col col_ref, expr text, overwrite boolean) IS '
1694
idempotent
1695
';
1632 1696

  
1633 1697

  
1634 1698
--
......
1668 1732
-- Name: FUNCTION mk_source_col(table_ regclass); Type: COMMENT; Schema: util; Owner: -
1669 1733
--
1670 1734

  
1671
COMMENT ON FUNCTION mk_source_col(table_ regclass) IS 'idempotent';
1735
COMMENT ON FUNCTION mk_source_col(table_ regclass) IS '
1736
idempotent
1737
';
1672 1738

  
1673 1739

  
1674 1740
--
......
1780 1846
-- Name: FUNCTION mk_subset_by_row_num_no_sort_func(view_ regclass); Type: COMMENT; Schema: util; Owner: -
1781 1847
--
1782 1848

  
1783
COMMENT ON FUNCTION mk_subset_by_row_num_no_sort_func(view_ regclass) IS 'creates subset function which turns off enable_sort';
1849
COMMENT ON FUNCTION mk_subset_by_row_num_no_sort_func(view_ regclass) IS '
1850
creates subset function which turns off enable_sort
1851
';
1784 1852

  
1785 1853

  
1786 1854
--
......
1831 1899
-- Name: FUNCTION nulls_map(nulls text[]); Type: COMMENT; Schema: util; Owner: -
1832 1900
--
1833 1901

  
1834
COMMENT ON FUNCTION nulls_map(nulls text[]) IS 'for use with _map()';
1902
COMMENT ON FUNCTION nulls_map(nulls text[]) IS '
1903
for use with _map()
1904
';
1835 1905

  
1836 1906

  
1837 1907
--
......
1898 1968
-- Name: FUNCTION rename_cols(table_ regclass, renames anyelement); Type: COMMENT; Schema: util; Owner: -
1899 1969
--
1900 1970

  
1901
COMMENT ON FUNCTION rename_cols(table_ regclass, renames anyelement) IS 'idempotent';
1971
COMMENT ON FUNCTION rename_cols(table_ regclass, renames anyelement) IS '
1972
idempotent
1973
';
1902 1974

  
1903 1975

  
1904 1976
--
......
1918 1990
-- Name: FUNCTION reset_col_names(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
1919 1991
--
1920 1992

  
1921
COMMENT ON FUNCTION reset_col_names(table_ regclass, names regclass) IS 'idempotent.
1922
alters the names table, so it will need to be repopulated after running this function.';
1993
COMMENT ON FUNCTION reset_col_names(table_ regclass, names regclass) IS '
1994
idempotent.
1995
alters the names table, so it will need to be repopulated after running this function.
1996
';
1923 1997

  
1924 1998

  
1925 1999
--
......
2006 2080
-- Name: FUNCTION schema_bundle_get_schemas(schema_bundle text); Type: COMMENT; Schema: util; Owner: -
2007 2081
--
2008 2082

  
2009
COMMENT ON FUNCTION schema_bundle_get_schemas(schema_bundle text) IS 'a schema bundle is a group of schemas with a common prefix';
2083
COMMENT ON FUNCTION schema_bundle_get_schemas(schema_bundle text) IS '
2084
a schema bundle is a group of schemas with a common prefix
2085
';
2010 2086

  
2011 2087

  
2012 2088
--
......
2140 2216
-- Name: FUNCTION set_col_names(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
2141 2217
--
2142 2218

  
2143
COMMENT ON FUNCTION set_col_names(table_ regclass, names regclass) IS 'idempotent';
2219
COMMENT ON FUNCTION set_col_names(table_ regclass, names regclass) IS '
2220
idempotent
2221
';
2144 2222

  
2145 2223

  
2146 2224
--
......
2179 2257
-- Name: FUNCTION set_col_names_with_metadata(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
2180 2258
--
2181 2259

  
2182
COMMENT ON FUNCTION set_col_names_with_metadata(table_ regclass, names regclass) IS 'idempotent.
2183
the metadata mappings must be *last* in the names table.';
2260
COMMENT ON FUNCTION set_col_names_with_metadata(table_ regclass, names regclass) IS '
2261
idempotent.
2262
the metadata mappings must be *last* in the names table.
2263
';
2184 2264

  
2185 2265

  
2186 2266
--
......
2218 2298
-- Name: FUNCTION set_col_types(table_ regclass, col_casts col_cast[]); Type: COMMENT; Schema: util; Owner: -
2219 2299
--
2220 2300

  
2221
COMMENT ON FUNCTION set_col_types(table_ regclass, col_casts col_cast[]) IS 'idempotent';
2301
COMMENT ON FUNCTION set_col_types(table_ regclass, col_casts col_cast[]) IS '
2302
idempotent
2303
';
2222 2304

  
2223 2305

  
2224 2306
--
......
2284 2366
-- Name: FUNCTION table_flag__get(table_ regclass, flag text); Type: COMMENT; Schema: util; Owner: -
2285 2367
--
2286 2368

  
2287
COMMENT ON FUNCTION table_flag__get(table_ regclass, flag text) IS 'gets whether a status flag is set by the presence of a table constraint';
2369
COMMENT ON FUNCTION table_flag__get(table_ regclass, flag text) IS '
2370
gets whether a status flag is set by the presence of a table constraint
2371
';
2288 2372

  
2289 2373

  
2290 2374
--
......
2303 2387
-- Name: FUNCTION table_flag__set(table_ regclass, flag text); Type: COMMENT; Schema: util; Owner: -
2304 2388
--
2305 2389

  
2306
COMMENT ON FUNCTION table_flag__set(table_ regclass, flag text) IS 'stores a status flag by the presence of a table constraint.
2307
idempotent.';
2390
COMMENT ON FUNCTION table_flag__set(table_ regclass, flag text) IS '
2391
stores a status flag by the presence of a table constraint.
2392
idempotent.
2393
';
2308 2394

  
2309 2395

  
2310 2396
--
......
2333 2419
-- Name: FUNCTION table_nulls_mapped__get(table_ regclass); Type: COMMENT; Schema: util; Owner: -
2334 2420
--
2335 2421

  
2336
COMMENT ON FUNCTION table_nulls_mapped__get(table_ regclass) IS 'gets whether a table''s NULL-equivalent strings have been replaced with NULL';
2422
COMMENT ON FUNCTION table_nulls_mapped__get(table_ regclass) IS '
2423
gets whether a table''s NULL-equivalent strings have been replaced with NULL
2424
';
2337 2425

  
2338 2426

  
2339 2427
--
......
2351 2439
-- Name: FUNCTION table_nulls_mapped__set(table_ regclass); Type: COMMENT; Schema: util; Owner: -
2352 2440
--
2353 2441

  
2354
COMMENT ON FUNCTION table_nulls_mapped__set(table_ regclass) IS 'sets that a table''s NULL-equivalent strings have been replaced with NULL.
2355
idempotent.';
2442
COMMENT ON FUNCTION table_nulls_mapped__set(table_ regclass) IS '
2443
sets that a table''s NULL-equivalent strings have been replaced with NULL.
2444
idempotent.
2445
';
2356 2446

  
2357 2447

  
2358 2448
--
......
2391 2481
-- Name: FUNCTION to_global_col_names(table_ regclass); Type: COMMENT; Schema: util; Owner: -
2392 2482
--
2393 2483

  
2394
COMMENT ON FUNCTION to_global_col_names(table_ regclass) IS 'idempotent';
2484
COMMENT ON FUNCTION to_global_col_names(table_ regclass) IS '
2485
idempotent
2486
';
2395 2487

  
2396 2488

  
2397 2489
--
......
2410 2502
-- Name: FUNCTION "trim"(table_ regclass, names regclass); Type: COMMENT; Schema: util; Owner: -
2411 2503
--
2412 2504

  
2413
COMMENT ON FUNCTION "trim"(table_ regclass, names regclass) IS 'trims table_ to include only columns in the original data.
2414
idempotent.';
2505
COMMENT ON FUNCTION "trim"(table_ regclass, names regclass) IS '
2506
trims table_ to include only columns in the original data.
2507
idempotent.
2508
';
2415 2509

  
2416 2510

  
2417 2511
--
......
2431 2525
-- Name: FUNCTION truncate(table_ regclass); Type: COMMENT; Schema: util; Owner: -
2432 2526
--
2433 2527

  
2434
COMMENT ON FUNCTION truncate(table_ regclass) IS 'idempotent';
2528
COMMENT ON FUNCTION truncate(table_ regclass) IS '
2529
idempotent
2530
';
2435 2531

  
2436 2532

  
2437 2533
--
......
2455 2551
-- Name: FUNCTION try_create(sql text); Type: COMMENT; Schema: util; Owner: -
2456 2552
--
2457 2553

  
2458
COMMENT ON FUNCTION try_create(sql text) IS 'idempotent';
2554
COMMENT ON FUNCTION try_create(sql text) IS '
2555
idempotent
2556
';
2459 2557

  
2460 2558

  
2461 2559
--
......
2473 2571
-- Name: FUNCTION try_mk_derived_col(col col_ref, expr text); Type: COMMENT; Schema: util; Owner: -
2474 2572
--
2475 2573

  
2476
COMMENT ON FUNCTION try_mk_derived_col(col col_ref, expr text) IS 'idempotent';
2574
COMMENT ON FUNCTION try_mk_derived_col(col col_ref, expr text) IS '
2575
idempotent
2576
';
2477 2577

  
2478 2578

  
2479 2579
--
......
2491 2591
-- Name: FUNCTION type_qual(value anyelement); Type: COMMENT; Schema: util; Owner: -
2492 2592
--
2493 2593

  
2494
COMMENT ON FUNCTION type_qual(value anyelement) IS 'a type''s NOT NULL qualifier';
2594
COMMENT ON FUNCTION type_qual(value anyelement) IS '
2595
a type''s NOT NULL qualifier
2596
';
2495 2597

  
2496 2598

  
2497 2599
--
......
2510 2612
-- Name: FUNCTION type_qual_name(type regtype); Type: COMMENT; Schema: util; Owner: -
2511 2613
--
2512 2614

  
2513
COMMENT ON FUNCTION type_qual_name(type regtype) IS 'a type''s schema-qualified name';
2615
COMMENT ON FUNCTION type_qual_name(type regtype) IS '
2616
a type''s schema-qualified name
2617
';
2514 2618

  
2515 2619

  
2516 2620
--
......
2545 2649
-- Name: AGGREGATE all_same(anyelement); Type: COMMENT; Schema: util; Owner: -
2546 2650
--
2547 2651

  
2548
COMMENT ON AGGREGATE all_same(anyelement) IS 'includes NULLs in comparison';
2652
COMMENT ON AGGREGATE all_same(anyelement) IS '
2653
includes NULLs in comparison
2654
';
2549 2655

  
2550 2656

  
2551 2657
--
......
2584 2690
-- Name: OPERATOR => (text[], text); Type: COMMENT; Schema: util; Owner: -
2585 2691
--
2586 2692

  
2587
COMMENT ON OPERATOR => (text[], text) IS 'usage: array[''key1'', ...]::text[] => ''value''';
2693
COMMENT ON OPERATOR => (text[], text) IS '
2694
usage: array[''key1'', ...]::text[] => ''value''
2695
';
2588 2696

  
2589 2697

  
2590 2698
--
......
2624 2732
-- Name: OPERATOR ||% (text, text); Type: COMMENT; Schema: util; Owner: -
2625 2733
--
2626 2734

  
2627
COMMENT ON OPERATOR ||% (text, text) IS '% indicates an identifier, as in Perl hashes and one of the x86 assembler syntaxes for registers';
2735
COMMENT ON OPERATOR ||% (text, text) IS '
2736
% indicates an identifier, as in Perl hashes and one of the x86 assembler syntaxes for registers
2737
';
2628 2738

  
2629 2739

  
2630 2740
--

Also available in: Unified diff