1CREATE TYPE pgroonga_full_text_search_condition AS ( 2 query text, 3 weigths int[], 4 indexName text 5); 6 7CREATE TYPE pgroonga_full_text_search_condition_with_scorers AS ( 8 query text, 9 weigths int[], 10 scorers text[], 11 indexName text 12); 13 14CREATE FUNCTION pgroonga_score("row" record) 15 RETURNS float8 16 AS 'MODULE_PATHNAME', 'pgroonga_score_row' 17 LANGUAGE C 18 VOLATILE 19 STRICT 20 PARALLEL SAFE; 21 22CREATE FUNCTION pgroonga_score(tableoid oid, ctid tid) 23 RETURNS float8 24 AS 'MODULE_PATHNAME', 'pgroonga_score_ctid' 25 LANGUAGE C 26 VOLATILE 27 STRICT 28 PARALLEL SAFE; 29 30CREATE FUNCTION pgroonga_table_name(indexName cstring) 31 RETURNS text 32 AS 'MODULE_PATHNAME', 'pgroonga_table_name' 33 LANGUAGE C 34 STABLE 35 STRICT 36 PARALLEL SAFE; 37 38CREATE FUNCTION pgroonga_command(groongaCommand text) 39 RETURNS text 40 AS 'MODULE_PATHNAME', 'pgroonga_command' 41 LANGUAGE C 42 VOLATILE 43 STRICT 44 PARALLEL SAFE; 45 46CREATE FUNCTION pgroonga_command(groongaCommand text, arguments text[]) 47 RETURNS text 48 AS 'MODULE_PATHNAME', 'pgroonga_command' 49 LANGUAGE C 50 VOLATILE 51 STRICT 52 PARALLEL SAFE; 53 54CREATE FUNCTION pgroonga_query_expand(tableName cstring, 55 termColumnName text, 56 synonymsColumnName text, 57 query text) 58 RETURNS text 59 AS 'MODULE_PATHNAME', 'pgroonga_query_expand' 60 LANGUAGE C 61 STABLE 62 STRICT 63 PARALLEL SAFE; 64 65CREATE FUNCTION pgroonga_snippet_html(target text, keywords text[]) 66 RETURNS text[] 67 AS 'MODULE_PATHNAME', 'pgroonga_snippet_html' 68 LANGUAGE C 69 IMMUTABLE 70 STRICT 71 PARALLEL SAFE; 72 73CREATE FUNCTION pgroonga_highlight_html(target text, keywords text[]) 74 RETURNS text 75 AS 'MODULE_PATHNAME', 'pgroonga_highlight_html' 76 LANGUAGE C 77 IMMUTABLE 78 STRICT 79 PARALLEL SAFE; 80 81CREATE FUNCTION pgroonga_highlight_html(target text, 82 keywords text[], 83 indexName cstring) 84 RETURNS text 85 AS 'MODULE_PATHNAME', 'pgroonga_highlight_html' 86 LANGUAGE C 87 IMMUTABLE 88 STRICT 89 PARALLEL SAFE; 90 91CREATE FUNCTION pgroonga_match_positions_byte(target text, keywords text[]) 92 RETURNS integer[2][] 93 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_byte' 94 LANGUAGE C 95 IMMUTABLE 96 STRICT 97 PARALLEL SAFE; 98 99CREATE FUNCTION pgroonga_match_positions_byte(target text, 100 keywords text[], 101 indexName cstring) 102 RETURNS integer[2][] 103 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_byte' 104 LANGUAGE C 105 IMMUTABLE 106 STRICT 107 PARALLEL SAFE; 108 109CREATE FUNCTION pgroonga_match_positions_character(target text, keywords text[]) 110 RETURNS integer[2][] 111 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_character' 112 LANGUAGE C 113 IMMUTABLE 114 STRICT 115 PARALLEL SAFE; 116 117CREATE FUNCTION pgroonga_match_positions_character(target text, 118 keywords text[], 119 indexName cstring) 120 RETURNS integer[2][] 121 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_character' 122 LANGUAGE C 123 IMMUTABLE 124 STRICT 125 PARALLEL SAFE; 126 127CREATE FUNCTION pgroonga_query_extract_keywords(query text) 128 RETURNS text[] 129 AS 'MODULE_PATHNAME', 'pgroonga_query_extract_keywords' 130 LANGUAGE C 131 IMMUTABLE 132 STRICT 133 PARALLEL SAFE; 134 135CREATE FUNCTION pgroonga_flush(indexName cstring) 136 RETURNS bool 137 AS 'MODULE_PATHNAME', 'pgroonga_flush' 138 LANGUAGE C 139 VOLATILE 140 STRICT 141 PARALLEL SAFE; 142 143CREATE FUNCTION pgroonga_command_escape_value(value text) 144 RETURNS text 145 AS 'MODULE_PATHNAME', 'pgroonga_command_escape_value' 146 LANGUAGE C 147 IMMUTABLE 148 STRICT 149 PARALLEL SAFE; 150 151CREATE FUNCTION pgroonga_query_escape(query text) 152 RETURNS text 153 AS 'MODULE_PATHNAME', 'pgroonga_query_escape' 154 LANGUAGE C 155 IMMUTABLE 156 STRICT 157 PARALLEL SAFE; 158 159CREATE FUNCTION pgroonga_escape(value text) 160 RETURNS text 161 AS 'MODULE_PATHNAME', 'pgroonga_escape_string' 162 LANGUAGE C 163 IMMUTABLE 164 STRICT 165 PARALLEL SAFE; 166 167CREATE FUNCTION pgroonga_escape(value text, special_characters text) 168 RETURNS text 169 AS 'MODULE_PATHNAME', 'pgroonga_escape_string' 170 LANGUAGE C 171 IMMUTABLE 172 STRICT 173 PARALLEL SAFE; 174 175CREATE FUNCTION pgroonga_escape(value boolean) 176 RETURNS text 177 AS 'MODULE_PATHNAME', 'pgroonga_escape_boolean' 178 LANGUAGE C 179 IMMUTABLE 180 STRICT 181 PARALLEL SAFE; 182 183CREATE FUNCTION pgroonga_escape(value int2) 184 RETURNS text 185 AS 'MODULE_PATHNAME', 'pgroonga_escape_int2' 186 LANGUAGE C 187 IMMUTABLE 188 STRICT 189 PARALLEL SAFE; 190 191CREATE FUNCTION pgroonga_escape(value int4) 192 RETURNS text 193 AS 'MODULE_PATHNAME', 'pgroonga_escape_int4' 194 LANGUAGE C 195 IMMUTABLE 196 STRICT 197 PARALLEL SAFE; 198 199CREATE FUNCTION pgroonga_escape(value int8) 200 RETURNS text 201 AS 'MODULE_PATHNAME', 'pgroonga_escape_int8' 202 LANGUAGE C 203 IMMUTABLE 204 STRICT 205 PARALLEL SAFE; 206 207CREATE FUNCTION pgroonga_escape(value float4) 208 RETURNS text 209 AS 'MODULE_PATHNAME', 'pgroonga_escape_float4' 210 LANGUAGE C 211 IMMUTABLE 212 STRICT 213 PARALLEL SAFE; 214 215CREATE FUNCTION pgroonga_escape(value float8) 216 RETURNS text 217 AS 'MODULE_PATHNAME', 'pgroonga_escape_float8' 218 LANGUAGE C 219 IMMUTABLE 220 STRICT 221 PARALLEL SAFE; 222 223CREATE FUNCTION pgroonga_escape(value timestamp) 224 RETURNS text 225 AS 'MODULE_PATHNAME', 'pgroonga_escape_timestamptz' 226 LANGUAGE C 227 IMMUTABLE 228 STRICT 229 PARALLEL SAFE; 230 231CREATE FUNCTION pgroonga_escape(value timestamptz) 232 RETURNS text 233 AS 'MODULE_PATHNAME', 'pgroonga_escape_timestamptz' 234 LANGUAGE C 235 IMMUTABLE 236 STRICT 237 PARALLEL SAFE; 238 239CREATE FUNCTION pgroonga_wal_apply() 240 RETURNS bigint 241 AS 'MODULE_PATHNAME', 'pgroonga_wal_apply_all' 242 LANGUAGE C 243 IMMUTABLE 244 STRICT; 245 246CREATE FUNCTION pgroonga_wal_apply(indexName cstring) 247 RETURNS bigint 248 AS 'MODULE_PATHNAME', 'pgroonga_wal_apply_index' 249 LANGUAGE C 250 IMMUTABLE 251 STRICT; 252 253CREATE FUNCTION pgroonga_wal_truncate() 254 RETURNS bigint 255 AS 'MODULE_PATHNAME', 'pgroonga_wal_truncate_all' 256 LANGUAGE C 257 IMMUTABLE 258 STRICT; 259 260CREATE FUNCTION pgroonga_wal_truncate(indexName cstring) 261 RETURNS bigint 262 AS 'MODULE_PATHNAME', 'pgroonga_wal_truncate_index' 263 LANGUAGE C 264 IMMUTABLE 265 STRICT; 266 267CREATE FUNCTION pgroonga_is_writable() 268 RETURNS bool 269 AS 'MODULE_PATHNAME', 'pgroonga_is_writable' 270 LANGUAGE C 271 IMMUTABLE 272 STRICT 273 PARALLEL SAFE; 274 275CREATE FUNCTION pgroonga_set_writable(newWritable bool) 276 RETURNS bool 277 AS 'MODULE_PATHNAME', 'pgroonga_set_writable' 278 LANGUAGE C 279 VOLATILE 280 STRICT; 281 282CREATE FUNCTION pgroonga_normalize(target text) 283 RETURNS text 284 AS 'MODULE_PATHNAME', 'pgroonga_normalize' 285 LANGUAGE C 286 IMMUTABLE 287 STRICT 288 PARALLEL SAFE; 289 290CREATE FUNCTION pgroonga_normalize(target text, normalizerName text) 291 RETURNS text 292 AS 'MODULE_PATHNAME', 'pgroonga_normalize' 293 LANGUAGE C 294 IMMUTABLE 295 STRICT 296 PARALLEL SAFE; 297 298CREATE FUNCTION pgroonga_tokenize(target text, VARIADIC options text[]) 299 RETURNS json[] 300 AS 'MODULE_PATHNAME', 'pgroonga_tokenize' 301 LANGUAGE C 302 IMMUTABLE 303 STRICT 304 PARALLEL SAFE; 305 306CREATE FUNCTION pgroonga_vacuum() 307 RETURNS bool 308 AS 'MODULE_PATHNAME', 'pgroonga_vacuum' 309 LANGUAGE C 310 VOLATILE 311 STRICT; 312 313CREATE FUNCTION pgroonga_index_column_name(indexName cstring, columnName text) 314 RETURNS text 315 AS 'MODULE_PATHNAME', 'pgroonga_index_column_name_name' 316 LANGUAGE C 317 STABLE 318 STRICT 319 PARALLEL SAFE; 320 321CREATE FUNCTION pgroonga_index_column_name(indexName cstring, columnIndex int4) 322 RETURNS text 323 AS 'MODULE_PATHNAME', 'pgroonga_index_column_name_index' 324 LANGUAGE C 325 STABLE 326 STRICT 327 PARALLEL SAFE; 328 329CREATE FUNCTION pgroonga_result_to_recordset(result jsonb) 330 RETURNS SETOF RECORD 331 AS 'MODULE_PATHNAME', 'pgroonga_result_to_recordset' 332 LANGUAGE C 333 IMMUTABLE 334 STRICT 335 PARALLEL SAFE; 336 337CREATE FUNCTION pgroonga_result_to_jsonb_objects(result jsonb) 338 RETURNS jsonb 339 AS 'MODULE_PATHNAME', 'pgroonga_result_to_jsonb_objects' 340 LANGUAGE C 341 IMMUTABLE 342 STRICT 343 PARALLEL SAFE; 344 345 346/* v1 */ 347CREATE FUNCTION pgroonga_match_term(target text, term text) 348 RETURNS bool 349 AS 'MODULE_PATHNAME', 'pgroonga_match_term_text' 350 LANGUAGE C 351 IMMUTABLE 352 STRICT 353 PARALLEL SAFE; 354 355CREATE FUNCTION pgroonga_match_term(target text[], term text) 356 RETURNS bool 357 AS 'MODULE_PATHNAME', 'pgroonga_match_term_text_array' 358 LANGUAGE C 359 IMMUTABLE 360 STRICT 361 PARALLEL SAFE; 362 363CREATE FUNCTION pgroonga_match_term(target varchar, term varchar) 364 RETURNS bool 365 AS 'MODULE_PATHNAME', 'pgroonga_match_term_varchar' 366 LANGUAGE C 367 IMMUTABLE 368 STRICT 369 PARALLEL SAFE; 370 371CREATE FUNCTION pgroonga_match_term(target varchar[], term varchar) 372 RETURNS bool 373 AS 'MODULE_PATHNAME', 'pgroonga_match_term_varchar_array' 374 LANGUAGE C 375 IMMUTABLE 376 STRICT 377 PARALLEL SAFE; 378 379CREATE OPERATOR %% ( 380 PROCEDURE = pgroonga_match_term, 381 LEFTARG = text, 382 RIGHTARG = text, 383 RESTRICT = contsel, 384 JOIN = contjoinsel 385); 386 387CREATE OPERATOR %% ( 388 PROCEDURE = pgroonga_match_term, 389 LEFTARG = text[], 390 RIGHTARG = text, 391 RESTRICT = contsel, 392 JOIN = contjoinsel 393); 394 395CREATE OPERATOR %% ( 396 PROCEDURE = pgroonga_match_term, 397 LEFTARG = varchar, 398 RIGHTARG = varchar, 399 RESTRICT = contsel, 400 JOIN = contjoinsel 401); 402 403CREATE OPERATOR %% ( 404 PROCEDURE = pgroonga_match_term, 405 LEFTARG = varchar[], 406 RIGHTARG = varchar, 407 RESTRICT = contsel, 408 JOIN = contjoinsel 409); 410 411 412CREATE FUNCTION pgroonga_match_query(text, text) 413 RETURNS bool 414 AS 'MODULE_PATHNAME', 'pgroonga_match_query_text' 415 LANGUAGE C 416 IMMUTABLE 417 STRICT 418 PARALLEL SAFE; 419 420CREATE FUNCTION pgroonga_match_query(text[], text) 421 RETURNS bool 422 AS 'MODULE_PATHNAME', 'pgroonga_match_query_text_array' 423 LANGUAGE C 424 IMMUTABLE 425 STRICT 426 PARALLEL SAFE; 427 428CREATE FUNCTION pgroonga_match_query(varchar, varchar) 429 RETURNS bool 430 AS 'MODULE_PATHNAME', 'pgroonga_match_query_varchar' 431 LANGUAGE C 432 IMMUTABLE 433 STRICT 434 PARALLEL SAFE; 435 436CREATE OPERATOR @@ ( 437 PROCEDURE = pgroonga_match_query, 438 LEFTARG = text, 439 RIGHTARG = text, 440 RESTRICT = contsel, 441 JOIN = contjoinsel 442); 443 444CREATE OPERATOR @@ ( 445 PROCEDURE = pgroonga_match_query, 446 LEFTARG = text[], 447 RIGHTARG = text, 448 RESTRICT = contsel, 449 JOIN = contjoinsel 450); 451 452CREATE OPERATOR @@ ( 453 PROCEDURE = pgroonga_match_query, 454 LEFTARG = varchar, 455 RIGHTARG = varchar, 456 RESTRICT = contsel, 457 JOIN = contjoinsel 458); 459 460 461CREATE FUNCTION pgroonga_match_regexp(text, text) 462 RETURNS bool 463 AS 'MODULE_PATHNAME', 'pgroonga_match_regexp_text' 464 LANGUAGE C 465 IMMUTABLE 466 STRICT 467 PARALLEL SAFE; 468 469CREATE FUNCTION pgroonga_match_regexp(varchar, varchar) 470 RETURNS bool 471 AS 'MODULE_PATHNAME', 'pgroonga_match_regexp_varchar' 472 LANGUAGE C 473 IMMUTABLE 474 STRICT 475 PARALLEL SAFE; 476 477CREATE OPERATOR @~ ( 478 PROCEDURE = pgroonga_match_regexp, 479 LEFTARG = text, 480 RIGHTARG = text, 481 RESTRICT = contsel, 482 JOIN = contjoinsel 483); 484 485CREATE OPERATOR @~ ( 486 PROCEDURE = pgroonga_match_regexp, 487 LEFTARG = varchar, 488 RIGHTARG = varchar, 489 RESTRICT = contsel, 490 JOIN = contjoinsel 491); 492 493 494/* v2 */ 495CREATE FUNCTION pgroonga_match_text(text, text) 496 RETURNS bool 497 AS 'MODULE_PATHNAME', 'pgroonga_match_text' 498 LANGUAGE C 499 IMMUTABLE 500 STRICT 501 LEAKPROOF 502 PARALLEL SAFE 503 COST 300; 504 505CREATE OPERATOR &@ ( 506 PROCEDURE = pgroonga_match_text, 507 LEFTARG = text, 508 RIGHTARG = text, 509 RESTRICT = contsel, 510 JOIN = contjoinsel 511); 512 513CREATE FUNCTION pgroonga_match_text_condition 514 (target text, condition pgroonga_full_text_search_condition) 515 RETURNS bool 516 AS 'MODULE_PATHNAME', 'pgroonga_match_text_condition' 517 LANGUAGE C 518 IMMUTABLE 519 STRICT 520 LEAKPROOF 521 PARALLEL SAFE 522 COST 300; 523 524CREATE OPERATOR &@ ( 525 PROCEDURE = pgroonga_match_text_condition, 526 LEFTARG = text, 527 RIGHTARG = pgroonga_full_text_search_condition, 528 RESTRICT = contsel, 529 JOIN = contjoinsel 530); 531 532CREATE FUNCTION pgroonga_match_text_condition_with_scorers 533 (target text, 534 condition pgroonga_full_text_search_condition_with_scorers) 535 RETURNS bool 536 AS 'MODULE_PATHNAME', 'pgroonga_match_text_condition_with_scorers' 537 LANGUAGE C 538 IMMUTABLE 539 STRICT 540 LEAKPROOF 541 PARALLEL SAFE 542 COST 300; 543 544CREATE OPERATOR &@ ( 545 PROCEDURE = pgroonga_match_text_condition_with_scorers, 546 LEFTARG = text, 547 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 548 RESTRICT = contsel, 549 JOIN = contjoinsel 550); 551 552CREATE FUNCTION pgroonga_match_text_array(text[], text) 553 RETURNS bool 554 AS 'MODULE_PATHNAME', 'pgroonga_match_text_array' 555 LANGUAGE C 556 IMMUTABLE 557 STRICT 558 LEAKPROOF 559 PARALLEL SAFE 560 COST 300; 561 562CREATE OPERATOR &@ ( 563 PROCEDURE = pgroonga_match_text_array, 564 LEFTARG = text[], 565 RIGHTARG = text, 566 RESTRICT = contsel, 567 JOIN = contjoinsel 568); 569 570CREATE FUNCTION pgroonga_match_text_array_condition 571 (target text[], condition pgroonga_full_text_search_condition) 572 RETURNS bool 573 AS 'MODULE_PATHNAME', 'pgroonga_match_text_array_condition' 574 LANGUAGE C 575 IMMUTABLE 576 STRICT 577 LEAKPROOF 578 PARALLEL SAFE 579 COST 300; 580 581CREATE OPERATOR &@ ( 582 PROCEDURE = pgroonga_match_text_array_condition, 583 LEFTARG = text[], 584 RIGHTARG = pgroonga_full_text_search_condition, 585 RESTRICT = contsel, 586 JOIN = contjoinsel 587); 588 589CREATE FUNCTION pgroonga_match_text_array_condition_with_scorers 590 (target text[], 591 condition pgroonga_full_text_search_condition_with_scorers) 592 RETURNS bool 593 AS 'MODULE_PATHNAME', 'pgroonga_match_text_array_condition_with_scorers' 594 LANGUAGE C 595 IMMUTABLE 596 STRICT 597 LEAKPROOF 598 PARALLEL SAFE 599 COST 300; 600 601CREATE OPERATOR &@ ( 602 PROCEDURE = pgroonga_match_text_array_condition_with_scorers, 603 LEFTARG = text[], 604 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 605 RESTRICT = contsel, 606 JOIN = contjoinsel 607); 608 609CREATE FUNCTION pgroonga_match_varchar(varchar, varchar) 610 RETURNS bool 611 AS 'MODULE_PATHNAME', 'pgroonga_match_varchar' 612 LANGUAGE C 613 IMMUTABLE 614 STRICT 615 LEAKPROOF 616 PARALLEL SAFE 617 COST 300; 618 619CREATE OPERATOR &@ ( 620 PROCEDURE = pgroonga_match_varchar, 621 LEFTARG = varchar, 622 RIGHTARG = varchar, 623 RESTRICT = contsel, 624 JOIN = contjoinsel 625); 626 627CREATE FUNCTION pgroonga_match_varchar_condition 628 (target varchar, condition pgroonga_full_text_search_condition) 629 RETURNS bool 630 AS 'MODULE_PATHNAME', 'pgroonga_match_varchar_condition' 631 LANGUAGE C 632 IMMUTABLE 633 STRICT 634 LEAKPROOF 635 PARALLEL SAFE 636 COST 300; 637 638CREATE OPERATOR &@ ( 639 PROCEDURE = pgroonga_match_varchar_condition, 640 LEFTARG = varchar, 641 RIGHTARG = pgroonga_full_text_search_condition, 642 RESTRICT = contsel, 643 JOIN = contjoinsel 644); 645 646CREATE FUNCTION pgroonga_match_varchar_condition_with_scorers 647 (target varchar, 648 condition pgroonga_full_text_search_condition_with_scorers) 649 RETURNS bool 650 AS 'MODULE_PATHNAME', 'pgroonga_match_varchar_condition_with_scorers' 651 LANGUAGE C 652 IMMUTABLE 653 STRICT 654 LEAKPROOF 655 PARALLEL SAFE 656 COST 300; 657 658CREATE OPERATOR &@ ( 659 PROCEDURE = pgroonga_match_varchar_condition_with_scorers, 660 LEFTARG = varchar, 661 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 662 RESTRICT = contsel, 663 JOIN = contjoinsel 664); 665 666CREATE FUNCTION pgroonga_contain_varchar_array(varchar[], varchar) 667 RETURNS bool 668 AS 'MODULE_PATHNAME', 'pgroonga_contain_varchar_array' 669 LANGUAGE C 670 IMMUTABLE 671 STRICT 672 LEAKPROOF 673 PARALLEL SAFE 674 COST 300; 675 676CREATE OPERATOR &> ( 677 PROCEDURE = pgroonga_contain_varchar_array, 678 LEFTARG = varchar[], 679 RIGHTARG = varchar, 680 RESTRICT = contsel, 681 JOIN = contjoinsel 682); 683 684CREATE FUNCTION pgroonga_match_jsonb(jsonb, text) 685 RETURNS bool 686 AS 'MODULE_PATHNAME', 'pgroonga_match_jsonb' 687 LANGUAGE C 688 IMMUTABLE 689 STRICT 690 LEAKPROOF 691 PARALLEL SAFE 692 COST 300; 693 694CREATE OPERATOR &@ ( 695 PROCEDURE = pgroonga_match_jsonb, 696 LEFTARG = jsonb, 697 RIGHTARG = text, 698 RESTRICT = contsel, 699 JOIN = contjoinsel 700); 701 702CREATE FUNCTION pgroonga_query_text(text, text) 703 RETURNS bool 704 AS 'MODULE_PATHNAME', 'pgroonga_query_text' 705 LANGUAGE C 706 IMMUTABLE 707 STRICT 708 LEAKPROOF 709 PARALLEL SAFE 710 COST 300; 711 712-- Deprecated since 1.2.2. 713CREATE OPERATOR &? ( 714 PROCEDURE = pgroonga_query_text, 715 LEFTARG = text, 716 RIGHTARG = text, 717 RESTRICT = contsel, 718 JOIN = contjoinsel 719); 720 721CREATE OPERATOR &@~ ( 722 PROCEDURE = pgroonga_query_text, 723 LEFTARG = text, 724 RIGHTARG = text, 725 RESTRICT = contsel, 726 JOIN = contjoinsel 727); 728 729CREATE FUNCTION pgroonga_query_text_condition 730 (target text, condition pgroonga_full_text_search_condition) 731 RETURNS bool 732 AS 'MODULE_PATHNAME', 'pgroonga_query_text_condition' 733 LANGUAGE C 734 IMMUTABLE 735 STRICT 736 LEAKPROOF 737 PARALLEL SAFE 738 COST 300; 739 740CREATE OPERATOR &@~ ( 741 PROCEDURE = pgroonga_query_text_condition, 742 LEFTARG = text, 743 RIGHTARG = pgroonga_full_text_search_condition, 744 RESTRICT = contsel, 745 JOIN = contjoinsel 746); 747 748CREATE FUNCTION pgroonga_query_text_condition_with_scorers 749 (target text, 750 condition pgroonga_full_text_search_condition_with_scorers) 751 RETURNS bool 752 AS 'MODULE_PATHNAME', 'pgroonga_query_text_condition_with_scorers' 753 LANGUAGE C 754 IMMUTABLE 755 STRICT 756 LEAKPROOF 757 PARALLEL SAFE 758 COST 300; 759 760CREATE OPERATOR &@~ ( 761 PROCEDURE = pgroonga_query_text_condition_with_scorers, 762 LEFTARG = text, 763 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 764 RESTRICT = contsel, 765 JOIN = contjoinsel 766); 767 768CREATE FUNCTION pgroonga_query_text_array(text[], text) 769 RETURNS bool 770 AS 'MODULE_PATHNAME', 'pgroonga_query_text_array' 771 LANGUAGE C 772 IMMUTABLE 773 STRICT 774 LEAKPROOF 775 PARALLEL SAFE 776 COST 300; 777 778-- Deprecated since 1.2.2. 779CREATE OPERATOR &? ( 780 PROCEDURE = pgroonga_query_text_array, 781 LEFTARG = text[], 782 RIGHTARG = text, 783 RESTRICT = contsel, 784 JOIN = contjoinsel 785); 786 787CREATE OPERATOR &@~ ( 788 PROCEDURE = pgroonga_query_text_array, 789 LEFTARG = text[], 790 RIGHTARG = text, 791 RESTRICT = contsel, 792 JOIN = contjoinsel 793); 794 795CREATE FUNCTION pgroonga_query_text_array_condition 796 (targets text[], condition pgroonga_full_text_search_condition) 797 RETURNS bool 798 AS 'MODULE_PATHNAME', 'pgroonga_query_text_array_condition' 799 LANGUAGE C 800 IMMUTABLE 801 STRICT 802 LEAKPROOF 803 PARALLEL SAFE 804 COST 300; 805 806CREATE OPERATOR &@~ ( 807 PROCEDURE = pgroonga_query_text_array_condition, 808 LEFTARG = text[], 809 RIGHTARG = pgroonga_full_text_search_condition, 810 RESTRICT = contsel, 811 JOIN = contjoinsel 812); 813 814CREATE FUNCTION pgroonga_query_text_array_condition_with_scorers 815 (targets text[], 816 condition pgroonga_full_text_search_condition_with_scorers) 817 RETURNS bool 818 AS 'MODULE_PATHNAME', 'pgroonga_query_text_array_condition_with_scorers' 819 LANGUAGE C 820 IMMUTABLE 821 STRICT 822 LEAKPROOF 823 PARALLEL SAFE 824 COST 300; 825 826CREATE OPERATOR &@~ ( 827 PROCEDURE = pgroonga_query_text_array_condition_with_scorers, 828 LEFTARG = text[], 829 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 830 RESTRICT = contsel, 831 JOIN = contjoinsel 832); 833 834CREATE FUNCTION pgroonga_query_varchar(varchar, varchar) 835 RETURNS bool 836 AS 'MODULE_PATHNAME', 'pgroonga_query_varchar' 837 LANGUAGE C 838 IMMUTABLE 839 STRICT 840 LEAKPROOF 841 PARALLEL SAFE 842 COST 300; 843 844-- Deprecated since 1.2.2. 845CREATE OPERATOR &? ( 846 PROCEDURE = pgroonga_query_varchar, 847 LEFTARG = varchar, 848 RIGHTARG = varchar, 849 RESTRICT = contsel, 850 JOIN = contjoinsel 851); 852 853CREATE OPERATOR &@~ ( 854 PROCEDURE = pgroonga_query_varchar, 855 LEFTARG = varchar, 856 RIGHTARG = varchar, 857 RESTRICT = contsel, 858 JOIN = contjoinsel 859); 860 861CREATE FUNCTION pgroonga_query_varchar_condition 862 (target varchar, condition pgroonga_full_text_search_condition) 863 RETURNS bool 864 AS 'MODULE_PATHNAME', 'pgroonga_query_varchar_condition' 865 LANGUAGE C 866 IMMUTABLE 867 STRICT 868 LEAKPROOF 869 PARALLEL SAFE 870 COST 300; 871 872CREATE OPERATOR &@~ ( 873 PROCEDURE = pgroonga_query_varchar_condition, 874 LEFTARG = varchar, 875 RIGHTARG = pgroonga_full_text_search_condition, 876 RESTRICT = contsel, 877 JOIN = contjoinsel 878); 879 880CREATE FUNCTION pgroonga_query_varchar_condition_with_scorers 881 (target varchar, 882 condition pgroonga_full_text_search_condition_with_scorers) 883 RETURNS bool 884 AS 'MODULE_PATHNAME', 'pgroonga_query_varchar_condition_with_scorers' 885 LANGUAGE C 886 IMMUTABLE 887 STRICT 888 LEAKPROOF 889 PARALLEL SAFE 890 COST 300; 891 892CREATE OPERATOR &@~ ( 893 PROCEDURE = pgroonga_query_varchar_condition_with_scorers, 894 LEFTARG = varchar, 895 RIGHTARG = pgroonga_full_text_search_condition_with_scorers, 896 RESTRICT = contsel, 897 JOIN = contjoinsel 898); 899 900CREATE FUNCTION pgroonga_query_jsonb(jsonb, text) 901 RETURNS bool 902 AS 'MODULE_PATHNAME', 'pgroonga_query_jsonb' 903 LANGUAGE C 904 IMMUTABLE 905 STRICT 906 LEAKPROOF 907 PARALLEL SAFE 908 COST 300; 909 910-- Deprecated since 1.2.2. 911CREATE OPERATOR &? ( 912 PROCEDURE = pgroonga_query_jsonb, 913 LEFTARG = jsonb, 914 RIGHTARG = text, 915 RESTRICT = contsel, 916 JOIN = contjoinsel 917); 918 919CREATE OPERATOR &@~ ( 920 PROCEDURE = pgroonga_query_jsonb, 921 LEFTARG = jsonb, 922 RIGHTARG = text, 923 RESTRICT = contsel, 924 JOIN = contjoinsel 925); 926 927CREATE FUNCTION pgroonga_similar_text(text, text) 928 RETURNS bool 929 AS 'MODULE_PATHNAME', 'pgroonga_similar_text' 930 LANGUAGE C 931 IMMUTABLE 932 STRICT 933 LEAKPROOF 934 PARALLEL SAFE 935 COST 10000; 936 937-- Deprecated since 1.2.2. 938CREATE OPERATOR &~? ( 939 PROCEDURE = pgroonga_similar_text, 940 LEFTARG = text, 941 RIGHTARG = text, 942 RESTRICT = contsel, 943 JOIN = contjoinsel 944); 945 946CREATE OPERATOR &@* ( 947 PROCEDURE = pgroonga_similar_text, 948 LEFTARG = text, 949 RIGHTARG = text, 950 RESTRICT = contsel, 951 JOIN = contjoinsel 952); 953 954CREATE FUNCTION pgroonga_similar_text_array(text[], text) 955 RETURNS bool 956 AS 'MODULE_PATHNAME', 'pgroonga_similar_text_array' 957 LANGUAGE C 958 IMMUTABLE 959 STRICT 960 LEAKPROOF 961 PARALLEL SAFE 962 COST 10000; 963 964-- Deprecated since 1.2.2. 965CREATE OPERATOR &~? ( 966 PROCEDURE = pgroonga_similar_text_array, 967 LEFTARG = text[], 968 RIGHTARG = text, 969 RESTRICT = contsel, 970 JOIN = contjoinsel 971); 972 973CREATE OPERATOR &@* ( 974 PROCEDURE = pgroonga_similar_text_array, 975 LEFTARG = text[], 976 RIGHTARG = text, 977 RESTRICT = contsel, 978 JOIN = contjoinsel 979); 980 981CREATE FUNCTION pgroonga_similar_varchar(varchar, varchar) 982 RETURNS bool 983 AS 'MODULE_PATHNAME', 'pgroonga_similar_varchar' 984 LANGUAGE C 985 IMMUTABLE 986 STRICT 987 LEAKPROOF 988 PARALLEL SAFE 989 COST 10000; 990 991-- Deprecated since 1.2.2. 992CREATE OPERATOR &~? ( 993 PROCEDURE = pgroonga_similar_varchar, 994 LEFTARG = varchar, 995 RIGHTARG = varchar, 996 RESTRICT = contsel, 997 JOIN = contjoinsel 998); 999 1000CREATE OPERATOR &@* ( 1001 PROCEDURE = pgroonga_similar_varchar, 1002 LEFTARG = varchar, 1003 RIGHTARG = varchar, 1004 RESTRICT = contsel, 1005 JOIN = contjoinsel 1006); 1007 1008CREATE FUNCTION pgroonga_prefix_text(text, text) 1009 RETURNS bool 1010 AS 'MODULE_PATHNAME', 'pgroonga_prefix_text' 1011 LANGUAGE C 1012 IMMUTABLE 1013 STRICT 1014 LEAKPROOF 1015 PARALLEL SAFE 1016 COST 300; 1017 1018CREATE OPERATOR &^ ( 1019 PROCEDURE = pgroonga_prefix_text, 1020 LEFTARG = text, 1021 RIGHTARG = text, 1022 RESTRICT = contsel, 1023 JOIN = contjoinsel 1024); 1025 1026CREATE FUNCTION pgroonga_prefix_text_array(text[], text) 1027 RETURNS bool 1028 AS 'MODULE_PATHNAME', 'pgroonga_prefix_text_array' 1029 LANGUAGE C 1030 IMMUTABLE 1031 STRICT 1032 LEAKPROOF 1033 PARALLEL SAFE 1034 COST 300; 1035 1036CREATE OPERATOR &^ ( 1037 PROCEDURE = pgroonga_prefix_text_array, 1038 LEFTARG = text[], 1039 RIGHTARG = text, 1040 RESTRICT = contsel, 1041 JOIN = contjoinsel 1042); 1043 1044/* Deprecated since 1.2.1. */ 1045CREATE OPERATOR &^> ( 1046 PROCEDURE = pgroonga_prefix_text_array, 1047 LEFTARG = text[], 1048 RIGHTARG = text, 1049 RESTRICT = contsel, 1050 JOIN = contjoinsel 1051); 1052 1053CREATE FUNCTION pgroonga_prefix_varchar(varchar, varchar) 1054 RETURNS bool 1055 AS 'MODULE_PATHNAME', 'pgroonga_prefix_varchar' 1056 LANGUAGE C 1057 IMMUTABLE 1058 STRICT 1059 LEAKPROOF 1060 PARALLEL SAFE 1061 COST 300; 1062 1063CREATE OPERATOR &^ ( 1064 PROCEDURE = pgroonga_prefix_varchar, 1065 LEFTARG = varchar, 1066 RIGHTARG = varchar, 1067 RESTRICT = contsel, 1068 JOIN = contjoinsel 1069); 1070 1071CREATE FUNCTION pgroonga_prefix_varchar_array(varchar[], varchar) 1072 RETURNS bool 1073 AS 'MODULE_PATHNAME', 'pgroonga_prefix_varchar_array' 1074 LANGUAGE C 1075 IMMUTABLE 1076 STRICT 1077 LEAKPROOF 1078 PARALLEL SAFE 1079 COST 300; 1080 1081CREATE OPERATOR &^ ( 1082 PROCEDURE = pgroonga_prefix_varchar_array, 1083 LEFTARG = varchar[], 1084 RIGHTARG = varchar, 1085 RESTRICT = contsel, 1086 JOIN = contjoinsel 1087); 1088 1089/* Deprecated since 1.2.1. */ 1090CREATE OPERATOR &^> ( 1091 PROCEDURE = pgroonga_prefix_varchar_array, 1092 LEFTARG = varchar[], 1093 RIGHTARG = varchar, 1094 RESTRICT = contsel, 1095 JOIN = contjoinsel 1096); 1097 1098CREATE FUNCTION pgroonga_prefix_rk_text(text, text) 1099 RETURNS bool 1100 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_text' 1101 LANGUAGE C 1102 IMMUTABLE 1103 STRICT 1104 LEAKPROOF 1105 PARALLEL SAFE 1106 COST 300; 1107 1108CREATE OPERATOR &^~ ( 1109 PROCEDURE = pgroonga_prefix_rk_text, 1110 LEFTARG = text, 1111 RIGHTARG = text, 1112 RESTRICT = contsel, 1113 JOIN = contjoinsel 1114); 1115 1116CREATE FUNCTION pgroonga_prefix_rk_text_array(text[], text) 1117 RETURNS bool 1118 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_text_array' 1119 LANGUAGE C 1120 IMMUTABLE 1121 STRICT 1122 LEAKPROOF 1123 PARALLEL SAFE 1124 COST 300; 1125 1126CREATE OPERATOR &^~ ( 1127 PROCEDURE = pgroonga_prefix_rk_text_array, 1128 LEFTARG = text[], 1129 RIGHTARG = text, 1130 RESTRICT = contsel, 1131 JOIN = contjoinsel 1132); 1133 1134/* Deprecated since 1.2.1. */ 1135CREATE OPERATOR &^~> ( 1136 PROCEDURE = pgroonga_prefix_rk_text_array, 1137 LEFTARG = text[], 1138 RIGHTARG = text, 1139 RESTRICT = contsel, 1140 JOIN = contjoinsel 1141); 1142 1143CREATE FUNCTION pgroonga_prefix_rk_varchar(varchar, varchar) 1144 RETURNS bool 1145 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_varchar' 1146 LANGUAGE C 1147 IMMUTABLE 1148 STRICT 1149 LEAKPROOF 1150 PARALLEL SAFE 1151 COST 300; 1152 1153CREATE OPERATOR &^~ ( 1154 PROCEDURE = pgroonga_prefix_rk_varchar, 1155 LEFTARG = varchar, 1156 RIGHTARG = varchar, 1157 RESTRICT = contsel, 1158 JOIN = contjoinsel 1159); 1160 1161CREATE FUNCTION pgroonga_prefix_rk_varchar_array(varchar[], varchar) 1162 RETURNS bool 1163 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_varchar_array' 1164 LANGUAGE C 1165 IMMUTABLE 1166 STRICT 1167 LEAKPROOF 1168 PARALLEL SAFE 1169 COST 300; 1170 1171CREATE OPERATOR &^~ ( 1172 PROCEDURE = pgroonga_prefix_rk_varchar_array, 1173 LEFTARG = varchar[], 1174 RIGHTARG = varchar, 1175 RESTRICT = contsel, 1176 JOIN = contjoinsel 1177); 1178 1179/* Deprecated since 1.2.1. */ 1180CREATE OPERATOR &^~> ( 1181 PROCEDURE = pgroonga_prefix_rk_varchar_array, 1182 LEFTARG = varchar[], 1183 RIGHTARG = varchar, 1184 RESTRICT = contsel, 1185 JOIN = contjoinsel 1186); 1187 1188CREATE FUNCTION pgroonga_script_text(text, text) 1189 RETURNS bool 1190 AS 'MODULE_PATHNAME', 'pgroonga_script_text' 1191 LANGUAGE C 1192 IMMUTABLE 1193 STRICT 1194 LEAKPROOF 1195 PARALLEL SAFE 1196 COST 300; 1197 1198CREATE OPERATOR &` ( 1199 PROCEDURE = pgroonga_script_text, 1200 LEFTARG = text, 1201 RIGHTARG = text, 1202 RESTRICT = contsel, 1203 JOIN = contjoinsel 1204); 1205 1206CREATE FUNCTION pgroonga_script_text_array(text[], text) 1207 RETURNS bool 1208 AS 'MODULE_PATHNAME', 'pgroonga_script_text_array' 1209 LANGUAGE C 1210 IMMUTABLE 1211 STRICT 1212 LEAKPROOF 1213 PARALLEL SAFE 1214 COST 300; 1215 1216CREATE OPERATOR &` ( 1217 PROCEDURE = pgroonga_script_text_array, 1218 LEFTARG = text[], 1219 RIGHTARG = text, 1220 RESTRICT = contsel, 1221 JOIN = contjoinsel 1222); 1223 1224CREATE FUNCTION pgroonga_script_varchar(varchar, varchar) 1225 RETURNS bool 1226 AS 'MODULE_PATHNAME', 'pgroonga_script_varchar' 1227 LANGUAGE C 1228 IMMUTABLE 1229 STRICT 1230 LEAKPROOF 1231 PARALLEL SAFE 1232 COST 300; 1233 1234CREATE OPERATOR &` ( 1235 PROCEDURE = pgroonga_script_varchar, 1236 LEFTARG = varchar, 1237 RIGHTARG = varchar, 1238 RESTRICT = contsel, 1239 JOIN = contjoinsel 1240); 1241 1242CREATE FUNCTION pgroonga_script_jsonb(jsonb, text) 1243 RETURNS bool 1244 AS 'MODULE_PATHNAME', 'pgroonga_script_jsonb' 1245 LANGUAGE C 1246 IMMUTABLE 1247 STRICT 1248 LEAKPROOF 1249 PARALLEL SAFE 1250 COST 300; 1251 1252CREATE OPERATOR &` ( 1253 PROCEDURE = pgroonga_script_jsonb, 1254 LEFTARG = jsonb, 1255 RIGHTARG = text, 1256 RESTRICT = contsel, 1257 JOIN = contjoinsel 1258); 1259 1260CREATE FUNCTION pgroonga_match_in_text(text, text[]) 1261 RETURNS bool 1262 AS 'MODULE_PATHNAME', 'pgroonga_match_in_text' 1263 LANGUAGE C 1264 IMMUTABLE 1265 STRICT 1266 LEAKPROOF 1267 PARALLEL SAFE 1268 COST 300; 1269 1270/* Deprecated since 1.2.1. */ 1271CREATE OPERATOR &@> ( 1272 PROCEDURE = pgroonga_match_in_text, 1273 LEFTARG = text, 1274 RIGHTARG = text[], 1275 RESTRICT = contsel, 1276 JOIN = contjoinsel 1277); 1278 1279CREATE OPERATOR &@| ( 1280 PROCEDURE = pgroonga_match_in_text, 1281 LEFTARG = text, 1282 RIGHTARG = text[], 1283 RESTRICT = contsel, 1284 JOIN = contjoinsel 1285); 1286 1287CREATE FUNCTION pgroonga_match_in_text_array(text[], text[]) 1288 RETURNS bool 1289 AS 'MODULE_PATHNAME', 'pgroonga_match_in_text_array' 1290 LANGUAGE C 1291 IMMUTABLE 1292 STRICT 1293 LEAKPROOF 1294 PARALLEL SAFE 1295 COST 300; 1296 1297CREATE OPERATOR &@| ( 1298 PROCEDURE = pgroonga_match_in_text_array, 1299 LEFTARG = text[], 1300 RIGHTARG = text[], 1301 RESTRICT = contsel, 1302 JOIN = contjoinsel 1303); 1304 1305CREATE FUNCTION pgroonga_match_in_varchar(varchar, varchar[]) 1306 RETURNS bool 1307 AS 'MODULE_PATHNAME', 'pgroonga_match_in_varchar' 1308 LANGUAGE C 1309 IMMUTABLE 1310 STRICT 1311 LEAKPROOF 1312 PARALLEL SAFE 1313 COST 300; 1314 1315CREATE OPERATOR &@| ( 1316 PROCEDURE = pgroonga_match_in_varchar, 1317 LEFTARG = varchar, 1318 RIGHTARG = varchar[], 1319 RESTRICT = contsel, 1320 JOIN = contjoinsel 1321); 1322 1323CREATE FUNCTION pgroonga_query_in_text(text, text[]) 1324 RETURNS bool 1325 AS 'MODULE_PATHNAME', 'pgroonga_query_in_text' 1326 LANGUAGE C 1327 IMMUTABLE 1328 STRICT 1329 LEAKPROOF 1330 PARALLEL SAFE 1331 COST 300; 1332 1333/* Deprecated since 1.2.1. */ 1334CREATE OPERATOR &?> ( 1335 PROCEDURE = pgroonga_query_in_text, 1336 LEFTARG = text, 1337 RIGHTARG = text[], 1338 RESTRICT = contsel, 1339 JOIN = contjoinsel 1340); 1341 1342-- Deprecated since 1.2.2. 1343CREATE OPERATOR &?| ( 1344 PROCEDURE = pgroonga_query_in_text, 1345 LEFTARG = text, 1346 RIGHTARG = text[], 1347 RESTRICT = contsel, 1348 JOIN = contjoinsel 1349); 1350 1351CREATE OPERATOR &@~| ( 1352 PROCEDURE = pgroonga_query_in_text, 1353 LEFTARG = text, 1354 RIGHTARG = text[], 1355 RESTRICT = contsel, 1356 JOIN = contjoinsel 1357); 1358 1359CREATE FUNCTION pgroonga_query_in_text_array(text[], text[]) 1360 RETURNS bool 1361 AS 'MODULE_PATHNAME', 'pgroonga_query_in_text_array' 1362 LANGUAGE C 1363 IMMUTABLE 1364 STRICT 1365 LEAKPROOF 1366 PARALLEL SAFE 1367 COST 300; 1368 1369-- Deprecated since 1.2.2. 1370CREATE OPERATOR &?| ( 1371 PROCEDURE = pgroonga_query_in_text_array, 1372 LEFTARG = text[], 1373 RIGHTARG = text[], 1374 RESTRICT = contsel, 1375 JOIN = contjoinsel 1376); 1377 1378CREATE OPERATOR &@~| ( 1379 PROCEDURE = pgroonga_query_in_text_array, 1380 LEFTARG = text[], 1381 RIGHTARG = text[], 1382 RESTRICT = contsel, 1383 JOIN = contjoinsel 1384); 1385 1386CREATE FUNCTION pgroonga_query_in_varchar(varchar, varchar[]) 1387 RETURNS bool 1388 AS 'MODULE_PATHNAME', 'pgroonga_query_in_varchar' 1389 LANGUAGE C 1390 IMMUTABLE 1391 STRICT 1392 LEAKPROOF 1393 PARALLEL SAFE 1394 COST 300; 1395 1396-- Deprecated since 1.2.2. 1397CREATE OPERATOR &?| ( 1398 PROCEDURE = pgroonga_query_in_varchar, 1399 LEFTARG = varchar, 1400 RIGHTARG = varchar[], 1401 RESTRICT = contsel, 1402 JOIN = contjoinsel 1403); 1404 1405CREATE OPERATOR &@~| ( 1406 PROCEDURE = pgroonga_query_in_varchar, 1407 LEFTARG = varchar, 1408 RIGHTARG = varchar[], 1409 RESTRICT = contsel, 1410 JOIN = contjoinsel 1411); 1412 1413CREATE FUNCTION pgroonga_prefix_in_text(text, text[]) 1414 RETURNS bool 1415 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_text' 1416 LANGUAGE C 1417 IMMUTABLE 1418 STRICT 1419 LEAKPROOF 1420 PARALLEL SAFE 1421 COST 300; 1422 1423CREATE OPERATOR &^| ( 1424 PROCEDURE = pgroonga_prefix_in_text, 1425 LEFTARG = text, 1426 RIGHTARG = text[], 1427 RESTRICT = contsel, 1428 JOIN = contjoinsel 1429); 1430 1431CREATE FUNCTION pgroonga_not_prefix_in_text(text, text[]) 1432 RETURNS bool 1433 AS 'MODULE_PATHNAME', 'pgroonga_not_prefix_in_text' 1434 LANGUAGE C 1435 IMMUTABLE 1436 STRICT 1437 LEAKPROOF 1438 PARALLEL SAFE 1439 COST 300; 1440 1441CREATE OPERATOR !&^| ( 1442 PROCEDURE = pgroonga_not_prefix_in_text, 1443 LEFTARG = text, 1444 RIGHTARG = text[], 1445 NEGATOR = &^|, 1446 RESTRICT = contsel, 1447 JOIN = contjoinsel 1448); 1449 1450CREATE FUNCTION pgroonga_prefix_in_text_array(text[], text[]) 1451 RETURNS bool 1452 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_text_array' 1453 LANGUAGE C 1454 IMMUTABLE 1455 STRICT 1456 LEAKPROOF 1457 PARALLEL SAFE 1458 COST 300; 1459 1460CREATE OPERATOR &^| ( 1461 PROCEDURE = pgroonga_prefix_in_text_array, 1462 LEFTARG = text[], 1463 RIGHTARG = text[], 1464 RESTRICT = contsel, 1465 JOIN = contjoinsel 1466); 1467 1468CREATE FUNCTION pgroonga_prefix_in_varchar(varchar, varchar[]) 1469 RETURNS bool 1470 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_varchar' 1471 LANGUAGE C 1472 IMMUTABLE 1473 STRICT 1474 LEAKPROOF 1475 PARALLEL SAFE 1476 COST 300; 1477 1478CREATE OPERATOR &^| ( 1479 PROCEDURE = pgroonga_prefix_in_varchar, 1480 LEFTARG = varchar, 1481 RIGHTARG = varchar[], 1482 RESTRICT = contsel, 1483 JOIN = contjoinsel 1484); 1485 1486CREATE FUNCTION pgroonga_prefix_in_varchar_array(varchar[], varchar[]) 1487 RETURNS bool 1488 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_varchar_array' 1489 LANGUAGE C 1490 IMMUTABLE 1491 STRICT 1492 LEAKPROOF 1493 PARALLEL SAFE 1494 COST 300; 1495 1496CREATE OPERATOR &^| ( 1497 PROCEDURE = pgroonga_prefix_in_varchar_array, 1498 LEFTARG = varchar[], 1499 RIGHTARG = varchar[], 1500 RESTRICT = contsel, 1501 JOIN = contjoinsel 1502); 1503 1504CREATE FUNCTION pgroonga_prefix_rk_in_text(text, text[]) 1505 RETURNS bool 1506 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_text' 1507 LANGUAGE C 1508 IMMUTABLE 1509 STRICT 1510 LEAKPROOF 1511 PARALLEL SAFE 1512 COST 300; 1513 1514CREATE OPERATOR &^~| ( 1515 PROCEDURE = pgroonga_prefix_rk_in_text, 1516 LEFTARG = text, 1517 RIGHTARG = text[], 1518 RESTRICT = contsel, 1519 JOIN = contjoinsel 1520); 1521 1522CREATE FUNCTION pgroonga_prefix_rk_in_text_array(text[], text[]) 1523 RETURNS bool 1524 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_text_array' 1525 LANGUAGE C 1526 IMMUTABLE 1527 STRICT 1528 LEAKPROOF 1529 PARALLEL SAFE 1530 COST 300; 1531 1532CREATE OPERATOR &^~| ( 1533 PROCEDURE = pgroonga_prefix_rk_in_text_array, 1534 LEFTARG = text[], 1535 RIGHTARG = text[], 1536 RESTRICT = contsel, 1537 JOIN = contjoinsel 1538); 1539 1540CREATE FUNCTION pgroonga_prefix_rk_in_varchar(varchar, varchar[]) 1541 RETURNS bool 1542 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_varchar' 1543 LANGUAGE C 1544 IMMUTABLE 1545 STRICT 1546 LEAKPROOF 1547 PARALLEL SAFE 1548 COST 300; 1549 1550CREATE OPERATOR &^~| ( 1551 PROCEDURE = pgroonga_prefix_rk_in_varchar, 1552 LEFTARG = varchar, 1553 RIGHTARG = varchar[], 1554 RESTRICT = contsel, 1555 JOIN = contjoinsel 1556); 1557 1558CREATE FUNCTION pgroonga_prefix_rk_in_varchar_array(varchar[], varchar[]) 1559 RETURNS bool 1560 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_varchar_array' 1561 LANGUAGE C 1562 IMMUTABLE 1563 STRICT 1564 LEAKPROOF 1565 PARALLEL SAFE 1566 COST 300; 1567 1568CREATE OPERATOR &^~| ( 1569 PROCEDURE = pgroonga_prefix_rk_in_varchar_array, 1570 LEFTARG = varchar[], 1571 RIGHTARG = varchar[], 1572 RESTRICT = contsel, 1573 JOIN = contjoinsel 1574); 1575 1576CREATE FUNCTION pgroonga_regexp_text(text, text) 1577 RETURNS bool 1578 AS 'MODULE_PATHNAME', 'pgroonga_regexp_text' 1579 LANGUAGE C 1580 IMMUTABLE 1581 STRICT 1582 LEAKPROOF 1583 PARALLEL SAFE 1584 COST 300; 1585 1586CREATE OPERATOR &~ ( 1587 PROCEDURE = pgroonga_regexp_text, 1588 LEFTARG = text, 1589 RIGHTARG = text, 1590 RESTRICT = contsel, 1591 JOIN = contjoinsel 1592); 1593 1594CREATE FUNCTION pgroonga_regexp_varchar(varchar, varchar) 1595 RETURNS bool 1596 AS 'MODULE_PATHNAME', 'pgroonga_regexp_varchar' 1597 LANGUAGE C 1598 IMMUTABLE 1599 STRICT 1600 LEAKPROOF 1601 PARALLEL SAFE 1602 COST 300; 1603 1604CREATE OPERATOR &~ ( 1605 PROCEDURE = pgroonga_regexp_varchar, 1606 LEFTARG = varchar, 1607 RIGHTARG = varchar, 1608 RESTRICT = contsel, 1609 JOIN = contjoinsel 1610); 1611 1612CREATE FUNCTION pgroonga_regexp_in_text(text, text[]) 1613 RETURNS bool 1614 AS 'MODULE_PATHNAME', 'pgroonga_regexp_in_text' 1615 LANGUAGE C 1616 IMMUTABLE 1617 STRICT 1618 LEAKPROOF 1619 PARALLEL SAFE 1620 COST 300; 1621 1622CREATE OPERATOR &~| ( 1623 PROCEDURE = pgroonga_regexp_in_text, 1624 LEFTARG = text, 1625 RIGHTARG = text[], 1626 RESTRICT = contsel, 1627 JOIN = contjoinsel 1628); 1629 1630CREATE FUNCTION pgroonga_regexp_in_varchar(varchar, varchar[]) 1631 RETURNS bool 1632 AS 'MODULE_PATHNAME', 'pgroonga_regexp_in_varchar' 1633 LANGUAGE C 1634 IMMUTABLE 1635 STRICT 1636 LEAKPROOF 1637 PARALLEL SAFE 1638 COST 300; 1639 1640CREATE OPERATOR &~| ( 1641 PROCEDURE = pgroonga_regexp_in_varchar, 1642 LEFTARG = varchar, 1643 RIGHTARG = varchar[], 1644 RESTRICT = contsel, 1645 JOIN = contjoinsel 1646); 1647 1648DROP ACCESS METHOD IF EXISTS pgroonga CASCADE; 1649CREATE FUNCTION pgroonga_handler(internal) 1650 RETURNS index_am_handler 1651 AS 'MODULE_PATHNAME', 'pgroonga_handler' 1652 LANGUAGE C; 1653CREATE ACCESS METHOD pgroonga 1654 TYPE INDEX 1655 HANDLER pgroonga_handler; 1656 1657/* v1 */ 1658CREATE OPERATOR CLASS pgroonga_text_full_text_search_ops FOR TYPE text 1659 USING pgroonga AS 1660 OPERATOR 6 ~~, 1661 OPERATOR 7 ~~*, 1662 OPERATOR 8 %%, 1663 OPERATOR 9 @@, 1664 OPERATOR 12 &@, 1665 OPERATOR 13 &?, -- For backward compatibility 1666 OPERATOR 28 &@~; 1667 1668CREATE OPERATOR CLASS pgroonga_text_array_full_text_search_ops 1669 FOR TYPE text[] 1670 USING pgroonga AS 1671 OPERATOR 8 %% (text[], text), 1672 OPERATOR 9 @@ (text[], text), 1673 OPERATOR 12 &@ (text[], text), 1674 OPERATOR 13 &? (text[], text), -- For backward compatibility 1675 OPERATOR 28 &@~ (text[], text); 1676 1677CREATE OPERATOR CLASS pgroonga_varchar_full_text_search_ops FOR TYPE varchar 1678 USING pgroonga AS 1679 OPERATOR 8 %%, 1680 OPERATOR 9 @@, 1681 OPERATOR 12 &@, 1682 OPERATOR 13 &?, -- For backward compatibility 1683 OPERATOR 28 &@~; 1684 1685CREATE OPERATOR CLASS pgroonga_varchar_ops FOR TYPE varchar 1686 USING pgroonga AS 1687 OPERATOR 1 < (text, text), 1688 OPERATOR 2 <= (text, text), 1689 OPERATOR 3 = (text, text), 1690 OPERATOR 4 >= (text, text), 1691 OPERATOR 5 > (text, text); 1692 1693CREATE OPERATOR CLASS pgroonga_varchar_array_ops 1694 FOR TYPE varchar[] 1695 USING pgroonga AS 1696 OPERATOR 8 %% (varchar[], varchar), 1697 OPERATOR 23 &> (varchar[], varchar); 1698 1699CREATE OPERATOR CLASS pgroonga_bool_ops DEFAULT FOR TYPE bool 1700 USING pgroonga AS 1701 OPERATOR 1 <, 1702 OPERATOR 2 <=, 1703 OPERATOR 3 =, 1704 OPERATOR 4 >=, 1705 OPERATOR 5 >; 1706 1707CREATE OPERATOR CLASS pgroonga_int2_ops DEFAULT FOR TYPE int2 1708 USING pgroonga AS 1709 OPERATOR 1 <, 1710 OPERATOR 2 <=, 1711 OPERATOR 3 =, 1712 OPERATOR 4 >=, 1713 OPERATOR 5 >; 1714 1715CREATE OPERATOR CLASS pgroonga_int4_ops DEFAULT FOR TYPE int4 1716 USING pgroonga AS 1717 OPERATOR 1 <, 1718 OPERATOR 2 <=, 1719 OPERATOR 3 =, 1720 OPERATOR 4 >=, 1721 OPERATOR 5 >; 1722 1723CREATE OPERATOR CLASS pgroonga_int8_ops DEFAULT FOR TYPE int8 1724 USING pgroonga AS 1725 OPERATOR 1 <, 1726 OPERATOR 2 <=, 1727 OPERATOR 3 =, 1728 OPERATOR 4 >=, 1729 OPERATOR 5 >; 1730 1731CREATE OPERATOR CLASS pgroonga_float4_ops DEFAULT FOR TYPE float4 1732 USING pgroonga AS 1733 OPERATOR 1 <, 1734 OPERATOR 2 <=, 1735 OPERATOR 3 =, 1736 OPERATOR 4 >=, 1737 OPERATOR 5 >; 1738 1739CREATE OPERATOR CLASS pgroonga_float8_ops DEFAULT FOR TYPE float8 1740 USING pgroonga AS 1741 OPERATOR 1 <, 1742 OPERATOR 2 <=, 1743 OPERATOR 3 =, 1744 OPERATOR 4 >=, 1745 OPERATOR 5 >; 1746 1747CREATE OPERATOR CLASS pgroonga_timestamp_ops DEFAULT FOR TYPE timestamp 1748 USING pgroonga AS 1749 OPERATOR 1 <, 1750 OPERATOR 2 <=, 1751 OPERATOR 3 =, 1752 OPERATOR 4 >=, 1753 OPERATOR 5 >; 1754 1755CREATE OPERATOR CLASS pgroonga_timestamptz_ops DEFAULT FOR TYPE timestamptz 1756 USING pgroonga AS 1757 OPERATOR 1 <, 1758 OPERATOR 2 <=, 1759 OPERATOR 3 =, 1760 OPERATOR 4 >=, 1761 OPERATOR 5 >; 1762 1763CREATE FUNCTION pgroonga_match_script_jsonb(jsonb, text) 1764 RETURNS bool 1765 AS 'MODULE_PATHNAME', 'pgroonga_match_script_jsonb' 1766 LANGUAGE C 1767 IMMUTABLE 1768 STRICT 1769 PARALLEL SAFE; 1770 1771CREATE OPERATOR @@ ( 1772 PROCEDURE = pgroonga_match_script_jsonb, 1773 LEFTARG = jsonb, 1774 RIGHTARG = text, 1775 RESTRICT = contsel, 1776 JOIN = contjoinsel 1777); 1778 1779CREATE OPERATOR CLASS pgroonga_jsonb_ops FOR TYPE jsonb 1780 USING pgroonga AS 1781 OPERATOR 9 @@ (jsonb, text), 1782 OPERATOR 11 @>, 1783 OPERATOR 12 &@ (jsonb, text), 1784 OPERATOR 13 &? (jsonb, text), -- For backward compatibility 1785 OPERATOR 15 &` (jsonb, text), 1786 OPERATOR 28 &@~ (jsonb, text); 1787 1788CREATE OPERATOR CLASS pgroonga_text_regexp_ops FOR TYPE text 1789 USING pgroonga AS 1790 OPERATOR 6 ~~, 1791 OPERATOR 7 ~~*, 1792 OPERATOR 10 @~, 1793 OPERATOR 22 &~; 1794 1795CREATE OPERATOR CLASS pgroonga_varchar_regexp_ops FOR TYPE varchar 1796 USING pgroonga AS 1797 OPERATOR 10 @~, 1798 OPERATOR 22 &~; 1799 1800/* v2 */ 1801CREATE OPERATOR CLASS pgroonga_int4_array_ops DEFAULT FOR TYPE int4[] 1802 USING pgroonga AS 1803 OPERATOR 3 = (anyarray, anyarray); 1804 1805CREATE OPERATOR CLASS pgroonga_text_full_text_search_ops_v2 1806 DEFAULT FOR TYPE text 1807 USING pgroonga AS 1808 OPERATOR 6 ~~, 1809 OPERATOR 7 ~~*, 1810 OPERATOR 8 %%, -- For backward compatibility 1811 OPERATOR 9 @@, -- For backward compatibility 1812 OPERATOR 12 &@, 1813 OPERATOR 13 &?, -- For backward compatibility 1814 OPERATOR 14 &~?, -- For backward compatibility 1815 OPERATOR 15 &`, 1816 OPERATOR 18 &@| (text, text[]), 1817 OPERATOR 19 &?| (text, text[]), -- For backward compatibility 1818 OPERATOR 26 &@> (text, text[]), -- For backward compatibility 1819 OPERATOR 27 &?> (text, text[]), -- For backward compatibility 1820 OPERATOR 28 &@~, 1821 OPERATOR 29 &@*, 1822 OPERATOR 30 &@~| (text, text[]), 1823 OPERATOR 31 &@ (text, pgroonga_full_text_search_condition), 1824 OPERATOR 32 &@~ (text, pgroonga_full_text_search_condition), 1825 OPERATOR 33 &@ (text, pgroonga_full_text_search_condition_with_scorers), 1826 OPERATOR 34 &@~ (text, pgroonga_full_text_search_condition_with_scorers); 1827 1828CREATE OPERATOR CLASS pgroonga_text_array_full_text_search_ops_v2 1829 DEFAULT FOR TYPE text[] 1830 USING pgroonga AS 1831 OPERATOR 8 %% (text[], text), -- For backward compatibility 1832 OPERATOR 9 @@ (text[], text), -- For backward compatibility 1833 OPERATOR 12 &@ (text[], text), 1834 OPERATOR 13 &? (text[], text), -- For backward compatibility 1835 OPERATOR 14 &~? (text[], text), -- For backward compatibility 1836 OPERATOR 15 &` (text[], text), 1837 OPERATOR 18 &@| (text[], text[]), 1838 OPERATOR 19 &?| (text[], text[]), -- For backward compatibility 1839 OPERATOR 28 &@~ (text[], text), 1840 OPERATOR 29 &@* (text[], text), 1841 OPERATOR 30 &@~| (text[], text[]), 1842 OPERATOR 31 &@ (text[], pgroonga_full_text_search_condition), 1843 OPERATOR 32 &@~ (text[], pgroonga_full_text_search_condition), 1844 OPERATOR 33 &@ (text[], pgroonga_full_text_search_condition_with_scorers), 1845 OPERATOR 34 &@~ (text[], pgroonga_full_text_search_condition_with_scorers); 1846 1847CREATE OPERATOR CLASS pgroonga_text_term_search_ops_v2 FOR TYPE text 1848 USING pgroonga AS 1849 OPERATOR 1 <, 1850 OPERATOR 2 <=, 1851 OPERATOR 3 =, 1852 OPERATOR 4 >=, 1853 OPERATOR 5 >, 1854 OPERATOR 16 &^, 1855 OPERATOR 17 &^~, 1856 OPERATOR 20 &^| (text, text[]), 1857 OPERATOR 21 &^~| (text, text[]), 1858 OPERATOR 36 !&^| (text, text[]); 1859 1860CREATE OPERATOR CLASS pgroonga_text_array_term_search_ops_v2 FOR TYPE text[] 1861 USING pgroonga AS 1862 OPERATOR 11 @> (anyarray, anyarray), 1863 OPERATOR 16 &^ (text[], text), 1864 OPERATOR 17 &^~ (text[], text), 1865 OPERATOR 20 &^| (text[], text[]), 1866 OPERATOR 21 &^~| (text[], text[]), 1867 OPERATOR 24 &^> (text[], text), -- For backward compatibility 1868 OPERATOR 25 &^~> (text[], text); -- For backward compatibility 1869 1870CREATE OPERATOR CLASS pgroonga_text_regexp_ops_v2 FOR TYPE text 1871 USING pgroonga AS 1872 OPERATOR 6 ~~, 1873 OPERATOR 7 ~~*, 1874 OPERATOR 10 @~, -- For backward compatibility 1875 OPERATOR 22 &~, 1876 OPERATOR 35 &~| (text, text[]); 1877 1878CREATE OPERATOR CLASS pgroonga_varchar_term_search_ops_v2 1879 DEFAULT FOR TYPE varchar 1880 USING pgroonga AS 1881 OPERATOR 1 < (text, text), 1882 OPERATOR 2 <= (text, text), 1883 OPERATOR 3 = (text, text), 1884 OPERATOR 4 >= (text, text), 1885 OPERATOR 5 > (text, text), 1886 OPERATOR 16 &^, 1887 OPERATOR 17 &^~, 1888 OPERATOR 20 &^| (varchar, varchar[]), 1889 OPERATOR 21 &^~| (varchar, varchar[]); 1890 1891CREATE OPERATOR CLASS pgroonga_varchar_full_text_search_ops_v2 1892 FOR TYPE varchar 1893 USING pgroonga AS 1894 OPERATOR 8 %%, -- For backward compatibility 1895 OPERATOR 9 @@, -- For backward compatibility 1896 OPERATOR 12 &@, 1897 OPERATOR 13 &?, -- For backward compatibility 1898 OPERATOR 14 &~?, -- For backward compatibility 1899 OPERATOR 15 &`, 1900 OPERATOR 18 &@| (varchar, varchar[]), 1901 OPERATOR 19 &?| (varchar, varchar[]), -- For backward compatibility 1902 OPERATOR 28 &@~, 1903 OPERATOR 29 &@*, 1904 OPERATOR 30 &@~| (varchar, varchar[]), 1905 OPERATOR 31 &@ (varchar, pgroonga_full_text_search_condition), 1906 OPERATOR 32 &@~ (varchar, pgroonga_full_text_search_condition), 1907 OPERATOR 33 &@ (varchar, pgroonga_full_text_search_condition_with_scorers), 1908 OPERATOR 34 &@~ (varchar, pgroonga_full_text_search_condition_with_scorers); 1909 1910CREATE OPERATOR CLASS pgroonga_varchar_array_term_search_ops_v2 1911 DEFAULT FOR TYPE varchar[] 1912 USING pgroonga AS 1913 OPERATOR 8 %% (varchar[], varchar), -- For backward compatibility 1914 OPERATOR 11 @> (anyarray, anyarray), 1915 OPERATOR 16 &^ (varchar[], varchar), 1916 OPERATOR 17 &^~ (varchar[], varchar), 1917 OPERATOR 20 &^| (varchar[], varchar[]), 1918 OPERATOR 21 &^~| (varchar[], varchar[]), 1919 OPERATOR 23 &> (varchar[], varchar), 1920 OPERATOR 24 &^> (varchar[], varchar), -- For backward compatibility 1921 OPERATOR 25 &^~> (varchar[], varchar); -- For backward compatibility 1922 1923CREATE OPERATOR CLASS pgroonga_varchar_regexp_ops_v2 FOR TYPE varchar 1924 USING pgroonga AS 1925 OPERATOR 10 @~, -- For backward compatibility 1926 OPERATOR 22 &~, 1927 OPERATOR 35 &~| (varchar, varchar[]); 1928 1929CREATE OPERATOR CLASS pgroonga_jsonb_ops_v2 1930 DEFAULT FOR TYPE jsonb 1931 USING pgroonga AS 1932 OPERATOR 9 @@ (jsonb, text), -- For backward compatibility 1933 OPERATOR 11 @>, 1934 OPERATOR 12 &@ (jsonb, text), 1935 OPERATOR 13 &? (jsonb, text), -- For backward compatibility 1936 OPERATOR 15 &` (jsonb, text), 1937 OPERATOR 28 &@~ (jsonb, text); 1938 1939CREATE OPERATOR CLASS pgroonga_jsonb_full_text_search_ops_v2 1940 FOR TYPE jsonb 1941 USING pgroonga AS 1942 OPERATOR 12 &@ (jsonb, text), 1943 OPERATOR 28 &@~ (jsonb, text); 1944 1945-- For backward compatibility 1946 1947DO LANGUAGE plpgsql $$ 1948BEGIN 1949 PERFORM setting FROM pg_settings 1950 WHERE name = 'server_version' AND 1951 setting LIKE '%Postgres-XL%'; 1952 -- "CREATE SCHEMA pgroonga" and CREATE FUNCTION pgroonga.XXX" don't work 1953 -- on Postgres-XL. 1954 IF NOT FOUND THEN 1955 CREATE SCHEMA pgroonga; 1956 1957 CREATE FUNCTION pgroonga.score("row" record) 1958 RETURNS float8 1959 AS 'MODULE_PATHNAME', 'pgroonga_score' 1960 LANGUAGE C 1961 VOLATILE 1962 STRICT 1963 PARALLEL SAFE; 1964 1965 CREATE FUNCTION pgroonga.table_name(indexName cstring) 1966 RETURNS text 1967 AS 'MODULE_PATHNAME', 'pgroonga_table_name' 1968 LANGUAGE C 1969 STABLE 1970 STRICT 1971 PARALLEL SAFE; 1972 1973 CREATE FUNCTION pgroonga.command(groongaCommand text) 1974 RETURNS text 1975 AS 'MODULE_PATHNAME', 'pgroonga_command' 1976 LANGUAGE C 1977 VOLATILE 1978 STRICT 1979 PARALLEL SAFE; 1980 1981 CREATE FUNCTION pgroonga.command(groongaCommand text, arguments text[]) 1982 RETURNS text 1983 AS 'MODULE_PATHNAME', 'pgroonga_command' 1984 LANGUAGE C 1985 VOLATILE 1986 STRICT 1987 PARALLEL SAFE; 1988 1989 CREATE FUNCTION pgroonga.query_expand(tableName cstring, 1990 termColumnName text, 1991 synonymsColumnName text, 1992 query text) 1993 RETURNS text 1994 AS 'MODULE_PATHNAME', 'pgroonga_query_expand' 1995 LANGUAGE C 1996 STABLE 1997 STRICT 1998 PARALLEL SAFE; 1999 2000 CREATE FUNCTION pgroonga.snippet_html(target text, keywords text[]) 2001 RETURNS text[] 2002 AS 'MODULE_PATHNAME', 'pgroonga_snippet_html' 2003 LANGUAGE C 2004 IMMUTABLE 2005 STRICT 2006 PARALLEL SAFE; 2007 2008 CREATE FUNCTION pgroonga.highlight_html(target text, keywords text[]) 2009 RETURNS text 2010 AS 'MODULE_PATHNAME', 'pgroonga_highlight_html' 2011 LANGUAGE C 2012 IMMUTABLE 2013 STRICT 2014 PARALLEL SAFE; 2015 2016 CREATE FUNCTION pgroonga.match_positions_byte(target text, keywords text[]) 2017 RETURNS integer[2][] 2018 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_byte' 2019 LANGUAGE C 2020 IMMUTABLE 2021 STRICT 2022 PARALLEL SAFE; 2023 2024 CREATE FUNCTION pgroonga.match_positions_character(target text, keywords text[]) 2025 RETURNS integer[2][] 2026 AS 'MODULE_PATHNAME', 'pgroonga_match_positions_character' 2027 LANGUAGE C 2028 IMMUTABLE 2029 STRICT 2030 PARALLEL SAFE; 2031 2032 CREATE FUNCTION pgroonga.query_extract_keywords(query text) 2033 RETURNS text[] 2034 AS 'MODULE_PATHNAME', 'pgroonga_query_extract_keywords' 2035 LANGUAGE C 2036 IMMUTABLE 2037 STRICT 2038 PARALLEL SAFE; 2039 2040 CREATE FUNCTION pgroonga.flush(indexName cstring) 2041 RETURNS bool 2042 AS 'MODULE_PATHNAME', 'pgroonga_flush' 2043 LANGUAGE C 2044 VOLATILE 2045 STRICT 2046 PARALLEL SAFE; 2047 2048 CREATE FUNCTION pgroonga.command_escape_value(value text) 2049 RETURNS text 2050 AS 'MODULE_PATHNAME', 'pgroonga_command_escape_value' 2051 LANGUAGE C 2052 IMMUTABLE 2053 STRICT 2054 PARALLEL SAFE; 2055 2056 CREATE FUNCTION pgroonga.query_escape(query text) 2057 RETURNS text 2058 AS 'MODULE_PATHNAME', 'pgroonga_query_escape' 2059 LANGUAGE C 2060 IMMUTABLE 2061 STRICT 2062 PARALLEL SAFE; 2063 2064 CREATE FUNCTION pgroonga.escape(value text) 2065 RETURNS text 2066 AS 'MODULE_PATHNAME', 'pgroonga_escape_string' 2067 LANGUAGE C 2068 IMMUTABLE 2069 STRICT 2070 PARALLEL SAFE; 2071 2072 CREATE FUNCTION pgroonga.escape(value text, special_characters text) 2073 RETURNS text 2074 AS 'MODULE_PATHNAME', 'pgroonga_escape_string' 2075 LANGUAGE C 2076 IMMUTABLE 2077 STRICT 2078 PARALLEL SAFE; 2079 2080 CREATE FUNCTION pgroonga.escape(value boolean) 2081 RETURNS text 2082 AS 'MODULE_PATHNAME', 'pgroonga_escape_boolean' 2083 LANGUAGE C 2084 IMMUTABLE 2085 STRICT 2086 PARALLEL SAFE; 2087 2088 CREATE FUNCTION pgroonga.escape(value int2) 2089 RETURNS text 2090 AS 'MODULE_PATHNAME', 'pgroonga_escape_int2' 2091 LANGUAGE C 2092 IMMUTABLE 2093 STRICT 2094 PARALLEL SAFE; 2095 2096 CREATE FUNCTION pgroonga.escape(value int4) 2097 RETURNS text 2098 AS 'MODULE_PATHNAME', 'pgroonga_escape_int4' 2099 LANGUAGE C 2100 IMMUTABLE 2101 STRICT 2102 PARALLEL SAFE; 2103 2104 CREATE FUNCTION pgroonga.escape(value int8) 2105 RETURNS text 2106 AS 'MODULE_PATHNAME', 'pgroonga_escape_int8' 2107 LANGUAGE C 2108 IMMUTABLE 2109 STRICT 2110 PARALLEL SAFE; 2111 2112 CREATE FUNCTION pgroonga.escape(value float4) 2113 RETURNS text 2114 AS 'MODULE_PATHNAME', 'pgroonga_escape_float8' 2115 LANGUAGE C 2116 IMMUTABLE 2117 STRICT 2118 PARALLEL SAFE; 2119 2120 CREATE FUNCTION pgroonga.escape(value float8) 2121 RETURNS text 2122 AS 'MODULE_PATHNAME', 'pgroonga_escape_float8' 2123 LANGUAGE C 2124 IMMUTABLE 2125 STRICT 2126 PARALLEL SAFE; 2127 2128 CREATE FUNCTION pgroonga.escape(value timestamp) 2129 RETURNS text 2130 AS 'MODULE_PATHNAME', 'pgroonga_escape_timestamptz' 2131 LANGUAGE C 2132 IMMUTABLE 2133 STRICT 2134 PARALLEL SAFE; 2135 2136 CREATE FUNCTION pgroonga.escape(value timestamptz) 2137 RETURNS text 2138 AS 'MODULE_PATHNAME', 'pgroonga_escape_timestamptz' 2139 LANGUAGE C 2140 IMMUTABLE 2141 STRICT 2142 PARALLEL SAFE; 2143 2144 2145 /* v1 */ 2146 CREATE FUNCTION pgroonga.match_term(target text, term text) 2147 RETURNS bool 2148 AS 'MODULE_PATHNAME', 'pgroonga_match_term_text' 2149 LANGUAGE C 2150 IMMUTABLE 2151 STRICT 2152 PARALLEL SAFE; 2153 2154 CREATE FUNCTION pgroonga.match_term(target text[], term text) 2155 RETURNS bool 2156 AS 'MODULE_PATHNAME', 'pgroonga_match_term_text_array' 2157 LANGUAGE C 2158 IMMUTABLE 2159 STRICT 2160 PARALLEL SAFE; 2161 2162 CREATE FUNCTION pgroonga.match_term(target varchar, term varchar) 2163 RETURNS bool 2164 AS 'MODULE_PATHNAME', 'pgroonga_match_term_varchar' 2165 LANGUAGE C 2166 IMMUTABLE 2167 STRICT 2168 PARALLEL SAFE; 2169 2170 CREATE FUNCTION pgroonga.match_term(target varchar[], term varchar) 2171 RETURNS bool 2172 AS 'MODULE_PATHNAME', 'pgroonga_match_term_varchar_array' 2173 LANGUAGE C 2174 IMMUTABLE 2175 STRICT 2176 PARALLEL SAFE; 2177 2178 IF current_schema() <> 'public' THEN 2179 CREATE OPERATOR public.%% ( 2180 PROCEDURE = pgroonga.match_term, 2181 LEFTARG = text, 2182 RIGHTARG = text, 2183 RESTRICT = contsel, 2184 JOIN = contjoinsel 2185 ); 2186 2187 CREATE OPERATOR public.%% ( 2188 PROCEDURE = pgroonga.match_term, 2189 LEFTARG = text[], 2190 RIGHTARG = text, 2191 RESTRICT = contsel, 2192 JOIN = contjoinsel 2193 ); 2194 2195 CREATE OPERATOR public.%% ( 2196 PROCEDURE = pgroonga.match_term, 2197 LEFTARG = varchar, 2198 RIGHTARG = varchar, 2199 RESTRICT = contsel, 2200 JOIN = contjoinsel 2201 ); 2202 2203 CREATE OPERATOR public.%% ( 2204 PROCEDURE = pgroonga.match_term, 2205 LEFTARG = varchar[], 2206 RIGHTARG = varchar, 2207 RESTRICT = contsel, 2208 JOIN = contjoinsel 2209 ); 2210 END IF; 2211 2212 CREATE FUNCTION pgroonga.match_query(text, text) 2213 RETURNS bool 2214 AS 'MODULE_PATHNAME', 'pgroonga_match_query_text' 2215 LANGUAGE C 2216 IMMUTABLE 2217 STRICT 2218 PARALLEL SAFE; 2219 2220 CREATE FUNCTION pgroonga.match_query(text[], text) 2221 RETURNS bool 2222 AS 'MODULE_PATHNAME', 'pgroonga_match_query_text_array' 2223 LANGUAGE C 2224 IMMUTABLE 2225 STRICT 2226 PARALLEL SAFE; 2227 2228 CREATE FUNCTION pgroonga.match_query(varchar, varchar) 2229 RETURNS bool 2230 AS 'MODULE_PATHNAME', 'pgroonga_match_query_varchar' 2231 LANGUAGE C 2232 IMMUTABLE 2233 STRICT 2234 PARALLEL SAFE; 2235 2236 IF current_schema() <> 'public' THEN 2237 CREATE OPERATOR public.@@ ( 2238 PROCEDURE = pgroonga.match_query, 2239 LEFTARG = text, 2240 RIGHTARG = text, 2241 RESTRICT = contsel, 2242 JOIN = contjoinsel 2243 ); 2244 2245 CREATE OPERATOR public.@@ ( 2246 PROCEDURE = pgroonga.match_query, 2247 LEFTARG = text[], 2248 RIGHTARG = text, 2249 RESTRICT = contsel, 2250 JOIN = contjoinsel 2251 ); 2252 2253 CREATE OPERATOR public.@@ ( 2254 PROCEDURE = pgroonga.match_query, 2255 LEFTARG = varchar, 2256 RIGHTARG = varchar, 2257 RESTRICT = contsel, 2258 JOIN = contjoinsel 2259 ); 2260 END IF; 2261 2262 CREATE FUNCTION pgroonga.match_regexp(text, text) 2263 RETURNS bool 2264 AS 'MODULE_PATHNAME', 'pgroonga_match_regexp_text' 2265 LANGUAGE C 2266 IMMUTABLE 2267 STRICT 2268 PARALLEL SAFE; 2269 2270 CREATE FUNCTION pgroonga.match_regexp(varchar, varchar) 2271 RETURNS bool 2272 AS 'MODULE_PATHNAME', 'pgroonga_match_regexp_varchar' 2273 LANGUAGE C 2274 IMMUTABLE 2275 STRICT 2276 PARALLEL SAFE; 2277 2278 IF current_schema() <> 'public' THEN 2279 CREATE OPERATOR public.@~ ( 2280 PROCEDURE = pgroonga.match_regexp, 2281 LEFTARG = text, 2282 RIGHTARG = text, 2283 RESTRICT = contsel, 2284 JOIN = contjoinsel 2285 ); 2286 2287 CREATE OPERATOR public.@~ ( 2288 PROCEDURE = pgroonga.match_regexp, 2289 LEFTARG = varchar, 2290 RIGHTARG = varchar, 2291 RESTRICT = contsel, 2292 JOIN = contjoinsel 2293 ); 2294 END IF; 2295 2296 /* v2 */ 2297 CREATE FUNCTION pgroonga.match_text(text, text) 2298 RETURNS bool 2299 AS 'MODULE_PATHNAME', 'pgroonga_match_text' 2300 LANGUAGE C 2301 IMMUTABLE 2302 STRICT 2303 PARALLEL SAFE; 2304 2305 IF current_schema() <> 'public' THEN 2306 CREATE OPERATOR public.&@ ( 2307 PROCEDURE = pgroonga.match_text, 2308 LEFTARG = text, 2309 RIGHTARG = text, 2310 RESTRICT = contsel, 2311 JOIN = contjoinsel 2312 ); 2313 END IF; 2314 2315 CREATE FUNCTION pgroonga.match_text_array(text[], text) 2316 RETURNS bool 2317 AS 'MODULE_PATHNAME', 'pgroonga_match_text_array' 2318 LANGUAGE C 2319 IMMUTABLE 2320 STRICT 2321 PARALLEL SAFE; 2322 2323 IF current_schema() <> 'public' THEN 2324 CREATE OPERATOR public.&@ ( 2325 PROCEDURE = pgroonga.match_text_array, 2326 LEFTARG = text[], 2327 RIGHTARG = text, 2328 RESTRICT = contsel, 2329 JOIN = contjoinsel 2330 ); 2331 END IF; 2332 2333 CREATE FUNCTION pgroonga.match_varchar(varchar, varchar) 2334 RETURNS bool 2335 AS 'MODULE_PATHNAME', 'pgroonga_match_varchar' 2336 LANGUAGE C 2337 IMMUTABLE 2338 STRICT 2339 PARALLEL SAFE; 2340 2341 IF current_schema() <> 'public' THEN 2342 CREATE OPERATOR public.&@ ( 2343 PROCEDURE = pgroonga.match_varchar, 2344 LEFTARG = varchar, 2345 RIGHTARG = varchar, 2346 RESTRICT = contsel, 2347 JOIN = contjoinsel 2348 ); 2349 END IF; 2350 2351 CREATE FUNCTION pgroonga.contain_varchar_array(varchar[], varchar) 2352 RETURNS bool 2353 AS 'MODULE_PATHNAME', 'pgroonga_contain_varchar_array' 2354 LANGUAGE C 2355 IMMUTABLE 2356 STRICT 2357 PARALLEL SAFE; 2358 2359 IF current_schema() <> 'public' THEN 2360 CREATE OPERATOR public.&> ( 2361 PROCEDURE = pgroonga.contain_varchar_array, 2362 LEFTARG = varchar[], 2363 RIGHTARG = varchar, 2364 RESTRICT = contsel, 2365 JOIN = contjoinsel 2366 ); 2367 END IF; 2368 2369 CREATE FUNCTION pgroonga.match_jsonb(jsonb, text) 2370 RETURNS bool 2371 AS 'MODULE_PATHNAME', 'pgroonga_match_jsonb' 2372 LANGUAGE C 2373 IMMUTABLE 2374 STRICT 2375 PARALLEL SAFE; 2376 2377 IF current_schema() <> 'public' THEN 2378 CREATE OPERATOR public.&@ ( 2379 PROCEDURE = pgroonga.match_jsonb, 2380 LEFTARG = jsonb, 2381 RIGHTARG = text, 2382 RESTRICT = contsel, 2383 JOIN = contjoinsel 2384 ); 2385 END IF; 2386 2387 CREATE FUNCTION pgroonga.query_text(text, text) 2388 RETURNS bool 2389 AS 'MODULE_PATHNAME', 'pgroonga_query_text' 2390 LANGUAGE C 2391 IMMUTABLE 2392 STRICT 2393 PARALLEL SAFE; 2394 2395 IF current_schema() <> 'public' THEN 2396 -- Deprecated since 1.2.2. 2397 CREATE OPERATOR public.&? ( 2398 PROCEDURE = pgroonga.query_text, 2399 LEFTARG = text, 2400 RIGHTARG = text, 2401 RESTRICT = contsel, 2402 JOIN = contjoinsel 2403 ); 2404 2405 CREATE OPERATOR public.&@~ ( 2406 PROCEDURE = pgroonga.query_text, 2407 LEFTARG = text, 2408 RIGHTARG = text, 2409 RESTRICT = contsel, 2410 JOIN = contjoinsel 2411 ); 2412 END IF; 2413 2414 CREATE FUNCTION pgroonga.query_text_array(text[], text) 2415 RETURNS bool 2416 AS 'MODULE_PATHNAME', 'pgroonga_query_text_array' 2417 LANGUAGE C 2418 IMMUTABLE 2419 STRICT 2420 PARALLEL SAFE; 2421 2422 IF current_schema() <> 'public' THEN 2423 -- Deprecated since 1.2.2. 2424 CREATE OPERATOR public.&? ( 2425 PROCEDURE = pgroonga.query_text_array, 2426 LEFTARG = text[], 2427 RIGHTARG = text, 2428 RESTRICT = contsel, 2429 JOIN = contjoinsel 2430 ); 2431 2432 CREATE OPERATOR public.&@~ ( 2433 PROCEDURE = pgroonga.query_text_array, 2434 LEFTARG = text[], 2435 RIGHTARG = text, 2436 RESTRICT = contsel, 2437 JOIN = contjoinsel 2438 ); 2439 END IF; 2440 2441 CREATE FUNCTION pgroonga.query_varchar(varchar, varchar) 2442 RETURNS bool 2443 AS 'MODULE_PATHNAME', 'pgroonga_query_varchar' 2444 LANGUAGE C 2445 IMMUTABLE 2446 STRICT 2447 PARALLEL SAFE; 2448 2449 IF current_schema() <> 'public' THEN 2450 -- Deprecated since 1.2.2. 2451 CREATE OPERATOR public.&? ( 2452 PROCEDURE = pgroonga.query_varchar, 2453 LEFTARG = varchar, 2454 RIGHTARG = varchar, 2455 RESTRICT = contsel, 2456 JOIN = contjoinsel 2457 ); 2458 2459 CREATE OPERATOR public.&@~ ( 2460 PROCEDURE = pgroonga.query_varchar, 2461 LEFTARG = varchar, 2462 RIGHTARG = varchar, 2463 RESTRICT = contsel, 2464 JOIN = contjoinsel 2465 ); 2466 END IF; 2467 2468 CREATE FUNCTION pgroonga.query_jsonb(jsonb, text) 2469 RETURNS bool 2470 AS 'MODULE_PATHNAME', 'pgroonga_query_jsonb' 2471 LANGUAGE C 2472 IMMUTABLE 2473 STRICT 2474 PARALLEL SAFE; 2475 2476 IF current_schema() <> 'public' THEN 2477 -- Deprecated since 1.2.2. 2478 CREATE OPERATOR public.&? ( 2479 PROCEDURE = pgroonga.query_jsonb, 2480 LEFTARG = jsonb, 2481 RIGHTARG = text, 2482 RESTRICT = contsel, 2483 JOIN = contjoinsel 2484 ); 2485 2486 CREATE OPERATOR public.&@~ ( 2487 PROCEDURE = pgroonga.query_jsonb, 2488 LEFTARG = jsonb, 2489 RIGHTARG = text, 2490 RESTRICT = contsel, 2491 JOIN = contjoinsel 2492 ); 2493 END IF; 2494 2495 CREATE FUNCTION pgroonga.similar_text(text, text) 2496 RETURNS bool 2497 AS 'MODULE_PATHNAME', 'pgroonga_similar_text' 2498 LANGUAGE C 2499 IMMUTABLE 2500 STRICT 2501 PARALLEL SAFE; 2502 2503 IF current_schema() <> 'public' THEN 2504 -- Deprecated since 1.2.2. 2505 CREATE OPERATOR public.&~? ( 2506 PROCEDURE = pgroonga.similar_text, 2507 LEFTARG = text, 2508 RIGHTARG = text, 2509 RESTRICT = contsel, 2510 JOIN = contjoinsel 2511 ); 2512 2513 CREATE OPERATOR public.&@* ( 2514 PROCEDURE = pgroonga.similar_text, 2515 LEFTARG = text, 2516 RIGHTARG = text, 2517 RESTRICT = contsel, 2518 JOIN = contjoinsel 2519 ); 2520 END IF; 2521 2522 CREATE FUNCTION pgroonga.similar_text_array(text[], text) 2523 RETURNS bool 2524 AS 'MODULE_PATHNAME', 'pgroonga_similar_text_array' 2525 LANGUAGE C 2526 IMMUTABLE 2527 STRICT 2528 PARALLEL SAFE; 2529 2530 IF current_schema() <> 'public' THEN 2531 -- Deprecated since 1.2.2. 2532 CREATE OPERATOR public.&~? ( 2533 PROCEDURE = pgroonga.similar_text_array, 2534 LEFTARG = text[], 2535 RIGHTARG = text, 2536 RESTRICT = contsel, 2537 JOIN = contjoinsel 2538 ); 2539 2540 CREATE OPERATOR public.&@* ( 2541 PROCEDURE = pgroonga.similar_text_array, 2542 LEFTARG = text[], 2543 RIGHTARG = text, 2544 RESTRICT = contsel, 2545 JOIN = contjoinsel 2546 ); 2547 END IF; 2548 2549 CREATE FUNCTION pgroonga.similar_varchar(varchar, varchar) 2550 RETURNS bool 2551 AS 'MODULE_PATHNAME', 'pgroonga_similar_varchar' 2552 LANGUAGE C 2553 IMMUTABLE 2554 STRICT 2555 PARALLEL SAFE; 2556 2557 IF current_schema() <> 'public' THEN 2558 -- Deprecated since 1.2.2. 2559 CREATE OPERATOR public.&~? ( 2560 PROCEDURE = pgroonga.similar_varchar, 2561 LEFTARG = varchar, 2562 RIGHTARG = varchar, 2563 RESTRICT = contsel, 2564 JOIN = contjoinsel 2565 ); 2566 2567 CREATE OPERATOR public.&@* ( 2568 PROCEDURE = pgroonga.similar_varchar, 2569 LEFTARG = varchar, 2570 RIGHTARG = varchar, 2571 RESTRICT = contsel, 2572 JOIN = contjoinsel 2573 ); 2574 END IF; 2575 2576 CREATE FUNCTION pgroonga.prefix_text(text, text) 2577 RETURNS bool 2578 AS 'MODULE_PATHNAME', 'pgroonga_prefix_text' 2579 LANGUAGE C 2580 IMMUTABLE 2581 STRICT 2582 PARALLEL SAFE; 2583 2584 IF current_schema() <> 'public' THEN 2585 CREATE OPERATOR public.&^ ( 2586 PROCEDURE = pgroonga.prefix_text, 2587 LEFTARG = text, 2588 RIGHTARG = text, 2589 RESTRICT = contsel, 2590 JOIN = contjoinsel 2591 ); 2592 END IF; 2593 2594 CREATE FUNCTION pgroonga.prefix_text_array(text[], text) 2595 RETURNS bool 2596 AS 'MODULE_PATHNAME', 'pgroonga_prefix_text_array' 2597 LANGUAGE C 2598 IMMUTABLE 2599 STRICT 2600 PARALLEL SAFE; 2601 2602 IF current_schema() <> 'public' THEN 2603 CREATE OPERATOR public.&^ ( 2604 PROCEDURE = pgroonga.prefix_text_array, 2605 LEFTARG = text[], 2606 RIGHTARG = text, 2607 RESTRICT = contsel, 2608 JOIN = contjoinsel 2609 ); 2610 2611 /* Deprecated since 1.2.1. */ 2612 CREATE OPERATOR public.&^> ( 2613 PROCEDURE = pgroonga.prefix_text_array, 2614 LEFTARG = text[], 2615 RIGHTARG = text, 2616 RESTRICT = contsel, 2617 JOIN = contjoinsel 2618 ); 2619 END IF; 2620 2621 CREATE FUNCTION pgroonga.prefix_rk_text(text, text) 2622 RETURNS bool 2623 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_text' 2624 LANGUAGE C 2625 IMMUTABLE 2626 STRICT 2627 PARALLEL SAFE; 2628 2629 IF current_schema() <> 'public' THEN 2630 CREATE OPERATOR public.&^~ ( 2631 PROCEDURE = pgroonga.prefix_rk_text, 2632 LEFTARG = text, 2633 RIGHTARG = text, 2634 RESTRICT = contsel, 2635 JOIN = contjoinsel 2636 ); 2637 END IF; 2638 2639 CREATE FUNCTION pgroonga.prefix_rk_text_array(text[], text) 2640 RETURNS bool 2641 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_text_array' 2642 LANGUAGE C 2643 IMMUTABLE 2644 STRICT 2645 PARALLEL SAFE; 2646 2647 IF current_schema() <> 'public' THEN 2648 CREATE OPERATOR public.&^~ ( 2649 PROCEDURE = pgroonga.prefix_rk_text_array, 2650 LEFTARG = text[], 2651 RIGHTARG = text, 2652 RESTRICT = contsel, 2653 JOIN = contjoinsel 2654 ); 2655 2656 /* Deprecated since 1.2.1. */ 2657 CREATE OPERATOR public.&^~> ( 2658 PROCEDURE = pgroonga.prefix_rk_text_array, 2659 LEFTARG = text[], 2660 RIGHTARG = text, 2661 RESTRICT = contsel, 2662 JOIN = contjoinsel 2663 ); 2664 END IF; 2665 2666 CREATE FUNCTION pgroonga.script_text(text, text) 2667 RETURNS bool 2668 AS 'MODULE_PATHNAME', 'pgroonga_script_text' 2669 LANGUAGE C 2670 IMMUTABLE 2671 STRICT 2672 PARALLEL SAFE; 2673 2674 IF current_schema() <> 'public' THEN 2675 CREATE OPERATOR public.&` ( 2676 PROCEDURE = pgroonga.script_text, 2677 LEFTARG = text, 2678 RIGHTARG = text, 2679 RESTRICT = contsel, 2680 JOIN = contjoinsel 2681 ); 2682 END IF; 2683 2684 CREATE FUNCTION pgroonga.script_text_array(text[], text) 2685 RETURNS bool 2686 AS 'MODULE_PATHNAME', 'pgroonga_script_text_array' 2687 LANGUAGE C 2688 IMMUTABLE 2689 STRICT 2690 PARALLEL SAFE; 2691 2692 IF current_schema() <> 'public' THEN 2693 CREATE OPERATOR public.&` ( 2694 PROCEDURE = pgroonga.script_text_array, 2695 LEFTARG = text[], 2696 RIGHTARG = text, 2697 RESTRICT = contsel, 2698 JOIN = contjoinsel 2699 ); 2700 END IF; 2701 2702 CREATE FUNCTION pgroonga.script_varchar(varchar, varchar) 2703 RETURNS bool 2704 AS 'MODULE_PATHNAME', 'pgroonga_script_varchar' 2705 LANGUAGE C 2706 IMMUTABLE 2707 STRICT 2708 PARALLEL SAFE; 2709 2710 IF current_schema() <> 'public' THEN 2711 CREATE OPERATOR public.&` ( 2712 PROCEDURE = pgroonga.script_varchar, 2713 LEFTARG = varchar, 2714 RIGHTARG = varchar, 2715 RESTRICT = contsel, 2716 JOIN = contjoinsel 2717 ); 2718 END IF; 2719 2720 CREATE FUNCTION pgroonga.script_jsonb(jsonb, text) 2721 RETURNS bool 2722 AS 'MODULE_PATHNAME', 'pgroonga_script_jsonb' 2723 LANGUAGE C 2724 IMMUTABLE 2725 STRICT 2726 PARALLEL SAFE; 2727 2728 IF current_schema() <> 'public' THEN 2729 CREATE OPERATOR public.&` ( 2730 PROCEDURE = pgroonga.script_jsonb, 2731 LEFTARG = jsonb, 2732 RIGHTARG = text, 2733 RESTRICT = contsel, 2734 JOIN = contjoinsel 2735 ); 2736 END IF; 2737 2738 CREATE FUNCTION pgroonga.match_in_text(text, text[]) 2739 RETURNS bool 2740 AS 'MODULE_PATHNAME', 'pgroonga_match_in_text' 2741 LANGUAGE C 2742 IMMUTABLE 2743 STRICT 2744 PARALLEL SAFE; 2745 2746 IF current_schema() <> 'public' THEN 2747 /* Deprecated since 1.2.1. */ 2748 CREATE OPERATOR public.&@> ( 2749 PROCEDURE = pgroonga.match_in_text, 2750 LEFTARG = text, 2751 RIGHTARG = text[], 2752 RESTRICT = contsel, 2753 JOIN = contjoinsel 2754 ); 2755 2756 CREATE OPERATOR public.&@| ( 2757 PROCEDURE = pgroonga.match_in_text, 2758 LEFTARG = text, 2759 RIGHTARG = text[], 2760 RESTRICT = contsel, 2761 JOIN = contjoinsel 2762 ); 2763 END IF; 2764 2765 CREATE FUNCTION pgroonga.match_in_text_array(text[], text[]) 2766 RETURNS bool 2767 AS 'MODULE_PATHNAME', 'pgroonga_match_in_text_array' 2768 LANGUAGE C 2769 IMMUTABLE 2770 STRICT 2771 PARALLEL SAFE; 2772 2773 IF current_schema() <> 'public' THEN 2774 CREATE OPERATOR public.&@| ( 2775 PROCEDURE = pgroonga.match_in_text_array, 2776 LEFTARG = text[], 2777 RIGHTARG = text[], 2778 RESTRICT = contsel, 2779 JOIN = contjoinsel 2780 ); 2781 END IF; 2782 2783 CREATE FUNCTION pgroonga.match_in_varchar(varchar, varchar[]) 2784 RETURNS bool 2785 AS 'MODULE_PATHNAME', 'pgroonga_match_in_varchar' 2786 LANGUAGE C 2787 IMMUTABLE 2788 STRICT 2789 PARALLEL SAFE; 2790 2791 IF current_schema() <> 'public' THEN 2792 CREATE OPERATOR public.&@| ( 2793 PROCEDURE = pgroonga.match_in_varchar, 2794 LEFTARG = varchar, 2795 RIGHTARG = varchar[], 2796 RESTRICT = contsel, 2797 JOIN = contjoinsel 2798 ); 2799 END IF; 2800 2801 CREATE FUNCTION pgroonga.query_in_text(text, text[]) 2802 RETURNS bool 2803 AS 'MODULE_PATHNAME', 'pgroonga_query_in_text' 2804 LANGUAGE C 2805 IMMUTABLE 2806 STRICT 2807 PARALLEL SAFE; 2808 2809 IF current_schema() <> 'public' THEN 2810 /* Deprecated since 1.2.1. */ 2811 CREATE OPERATOR public.&?> ( 2812 PROCEDURE = pgroonga.query_in_text, 2813 LEFTARG = text, 2814 RIGHTARG = text[], 2815 RESTRICT = contsel, 2816 JOIN = contjoinsel 2817 ); 2818 2819 -- Deprecated since 1.2.2. 2820 CREATE OPERATOR public.&?| ( 2821 PROCEDURE = pgroonga.query_in_text, 2822 LEFTARG = text, 2823 RIGHTARG = text[], 2824 RESTRICT = contsel, 2825 JOIN = contjoinsel 2826 ); 2827 2828 CREATE OPERATOR public.&@~| ( 2829 PROCEDURE = pgroonga.query_in_text, 2830 LEFTARG = text, 2831 RIGHTARG = text[], 2832 RESTRICT = contsel, 2833 JOIN = contjoinsel 2834 ); 2835 END IF; 2836 2837 CREATE FUNCTION pgroonga.query_in_text_array(text[], text[]) 2838 RETURNS bool 2839 AS 'MODULE_PATHNAME', 'pgroonga_query_in_text_array' 2840 LANGUAGE C 2841 IMMUTABLE 2842 STRICT 2843 PARALLEL SAFE; 2844 2845 IF current_schema() <> 'public' THEN 2846 -- Deprecated since 1.2.2. 2847 CREATE OPERATOR public.&?| ( 2848 PROCEDURE = pgroonga.query_in_text_array, 2849 LEFTARG = text[], 2850 RIGHTARG = text[], 2851 RESTRICT = contsel, 2852 JOIN = contjoinsel 2853 ); 2854 2855 CREATE OPERATOR public.&@~| ( 2856 PROCEDURE = pgroonga.query_in_text_array, 2857 LEFTARG = text[], 2858 RIGHTARG = text[], 2859 RESTRICT = contsel, 2860 JOIN = contjoinsel 2861 ); 2862 END IF; 2863 2864 CREATE FUNCTION pgroonga.query_in_varchar(varchar, varchar[]) 2865 RETURNS bool 2866 AS 'MODULE_PATHNAME', 'pgroonga_query_in_varchar' 2867 LANGUAGE C 2868 IMMUTABLE 2869 STRICT 2870 PARALLEL SAFE; 2871 2872 IF current_schema() <> 'public' THEN 2873 -- Deprecated since 1.2.2. 2874 CREATE OPERATOR public.&?| ( 2875 PROCEDURE = pgroonga.query_in_varchar, 2876 LEFTARG = varchar, 2877 RIGHTARG = varchar[], 2878 RESTRICT = contsel, 2879 JOIN = contjoinsel 2880 ); 2881 2882 CREATE OPERATOR public.&@~| ( 2883 PROCEDURE = pgroonga.query_in_varchar, 2884 LEFTARG = varchar, 2885 RIGHTARG = varchar[], 2886 RESTRICT = contsel, 2887 JOIN = contjoinsel 2888 ); 2889 END IF; 2890 2891 CREATE FUNCTION pgroonga.prefix_in_text(text, text[]) 2892 RETURNS bool 2893 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_text' 2894 LANGUAGE C 2895 IMMUTABLE 2896 STRICT 2897 PARALLEL SAFE; 2898 2899 IF current_schema() <> 'public' THEN 2900 CREATE OPERATOR public.&^| ( 2901 PROCEDURE = pgroonga.prefix_in_text, 2902 LEFTARG = text, 2903 RIGHTARG = text[], 2904 RESTRICT = contsel, 2905 JOIN = contjoinsel 2906 ); 2907 END IF; 2908 2909 CREATE FUNCTION pgroonga.prefix_in_text_array(text[], text[]) 2910 RETURNS bool 2911 AS 'MODULE_PATHNAME', 'pgroonga_prefix_in_text_array' 2912 LANGUAGE C 2913 IMMUTABLE 2914 STRICT 2915 PARALLEL SAFE; 2916 2917 IF current_schema() <> 'public' THEN 2918 CREATE OPERATOR public.&^| ( 2919 PROCEDURE = pgroonga.prefix_in_text_array, 2920 LEFTARG = text[], 2921 RIGHTARG = text[], 2922 RESTRICT = contsel, 2923 JOIN = contjoinsel 2924 ); 2925 END IF; 2926 2927 CREATE FUNCTION pgroonga.prefix_rk_in_text(text, text[]) 2928 RETURNS bool 2929 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_text' 2930 LANGUAGE C 2931 IMMUTABLE 2932 STRICT 2933 PARALLEL SAFE; 2934 2935 IF current_schema() <> 'public' THEN 2936 CREATE OPERATOR public.&^~| ( 2937 PROCEDURE = pgroonga.prefix_rk_in_text, 2938 LEFTARG = text, 2939 RIGHTARG = text[], 2940 RESTRICT = contsel, 2941 JOIN = contjoinsel 2942 ); 2943 END IF; 2944 2945 CREATE FUNCTION pgroonga.prefix_rk_in_text_array(text[], text[]) 2946 RETURNS bool 2947 AS 'MODULE_PATHNAME', 'pgroonga_prefix_rk_in_text_array' 2948 LANGUAGE C 2949 IMMUTABLE 2950 STRICT 2951 PARALLEL SAFE; 2952 2953 IF current_schema() <> 'public' THEN 2954 CREATE OPERATOR public.&^~| ( 2955 PROCEDURE = pgroonga.prefix_rk_in_text_array, 2956 LEFTARG = text[], 2957 RIGHTARG = text[], 2958 RESTRICT = contsel, 2959 JOIN = contjoinsel 2960 ); 2961 END IF; 2962 2963 CREATE FUNCTION pgroonga.regexp_text(text, text) 2964 RETURNS bool 2965 AS 'MODULE_PATHNAME', 'pgroonga_regexp_text' 2966 LANGUAGE C 2967 IMMUTABLE 2968 STRICT 2969 PARALLEL SAFE; 2970 2971 IF current_schema() <> 'public' THEN 2972 CREATE OPERATOR public.&~ ( 2973 PROCEDURE = pgroonga.regexp_text, 2974 LEFTARG = text, 2975 RIGHTARG = text, 2976 RESTRICT = contsel, 2977 JOIN = contjoinsel 2978 ); 2979 END IF; 2980 2981 CREATE FUNCTION pgroonga.regexp_varchar(varchar, varchar) 2982 RETURNS bool 2983 AS 'MODULE_PATHNAME', 'pgroonga_regexp_varchar' 2984 LANGUAGE C 2985 IMMUTABLE 2986 STRICT 2987 PARALLEL SAFE; 2988 2989 IF current_schema() <> 'public' THEN 2990 CREATE OPERATOR public.&~ ( 2991 PROCEDURE = pgroonga.regexp_varchar, 2992 LEFTARG = varchar, 2993 RIGHTARG = varchar, 2994 RESTRICT = contsel, 2995 JOIN = contjoinsel 2996 ); 2997 END IF; 2998 2999 3000 /* v1 */ 3001 CREATE OPERATOR CLASS pgroonga.text_full_text_search_ops FOR TYPE text 3002 USING pgroonga AS 3003 OPERATOR 6 ~~, 3004 OPERATOR 7 ~~*, 3005 OPERATOR 8 %%, 3006 OPERATOR 9 @@, 3007 OPERATOR 12 &@, 3008 OPERATOR 13 &?, -- For backward compatibility 3009 OPERATOR 28 &@~; 3010 3011 CREATE OPERATOR CLASS pgroonga.text_array_full_text_search_ops 3012 FOR TYPE text[] 3013 USING pgroonga AS 3014 OPERATOR 8 %% (text[], text), 3015 OPERATOR 9 @@ (text[], text), 3016 OPERATOR 12 &@ (text[], text), 3017 OPERATOR 13 &? (text[], text), -- For backward compatibility 3018 OPERATOR 28 &@~ (text[], text); 3019 3020 CREATE OPERATOR CLASS pgroonga.varchar_full_text_search_ops FOR TYPE varchar 3021 USING pgroonga AS 3022 OPERATOR 8 %%, 3023 OPERATOR 9 @@, 3024 OPERATOR 12 &@, 3025 OPERATOR 13 &?, -- For backward compatibility 3026 OPERATOR 28 &@~; 3027 3028 CREATE OPERATOR CLASS pgroonga.varchar_ops FOR TYPE varchar 3029 USING pgroonga AS 3030 OPERATOR 1 < (text, text), 3031 OPERATOR 2 <= (text, text), 3032 OPERATOR 3 = (text, text), 3033 OPERATOR 4 >= (text, text), 3034 OPERATOR 5 > (text, text); 3035 3036 CREATE OPERATOR CLASS pgroonga.varchar_array_ops 3037 FOR TYPE varchar[] 3038 USING pgroonga AS 3039 OPERATOR 8 %% (varchar[], varchar), 3040 OPERATOR 23 &> (varchar[], varchar); 3041 3042 CREATE OPERATOR CLASS pgroonga.bool_ops FOR TYPE bool 3043 USING pgroonga AS 3044 OPERATOR 1 <, 3045 OPERATOR 2 <=, 3046 OPERATOR 3 =, 3047 OPERATOR 4 >=, 3048 OPERATOR 5 >; 3049 3050 CREATE OPERATOR CLASS pgroonga.int2_ops FOR TYPE int2 3051 USING pgroonga AS 3052 OPERATOR 1 <, 3053 OPERATOR 2 <=, 3054 OPERATOR 3 =, 3055 OPERATOR 4 >=, 3056 OPERATOR 5 >; 3057 3058 CREATE OPERATOR CLASS pgroonga.int4_ops FOR TYPE int4 3059 USING pgroonga AS 3060 OPERATOR 1 <, 3061 OPERATOR 2 <=, 3062 OPERATOR 3 =, 3063 OPERATOR 4 >=, 3064 OPERATOR 5 >; 3065 3066 CREATE OPERATOR CLASS pgroonga.int8_ops FOR TYPE int8 3067 USING pgroonga AS 3068 OPERATOR 1 <, 3069 OPERATOR 2 <=, 3070 OPERATOR 3 =, 3071 OPERATOR 4 >=, 3072 OPERATOR 5 >; 3073 3074 CREATE OPERATOR CLASS pgroonga.float4_ops FOR TYPE float4 3075 USING pgroonga AS 3076 OPERATOR 1 <, 3077 OPERATOR 2 <=, 3078 OPERATOR 3 =, 3079 OPERATOR 4 >=, 3080 OPERATOR 5 >; 3081 3082 CREATE OPERATOR CLASS pgroonga.float8_ops FOR TYPE float8 3083 USING pgroonga AS 3084 OPERATOR 1 <, 3085 OPERATOR 2 <=, 3086 OPERATOR 3 =, 3087 OPERATOR 4 >=, 3088 OPERATOR 5 >; 3089 3090 CREATE OPERATOR CLASS pgroonga.timestamp_ops FOR TYPE timestamp 3091 USING pgroonga AS 3092 OPERATOR 1 <, 3093 OPERATOR 2 <=, 3094 OPERATOR 3 =, 3095 OPERATOR 4 >=, 3096 OPERATOR 5 >; 3097 3098 CREATE OPERATOR CLASS pgroonga.timestamptz_ops FOR TYPE timestamptz 3099 USING pgroonga AS 3100 OPERATOR 1 <, 3101 OPERATOR 2 <=, 3102 OPERATOR 3 =, 3103 OPERATOR 4 >=, 3104 OPERATOR 5 >; 3105 3106 CREATE FUNCTION pgroonga.match_script_jsonb(jsonb, text) 3107 RETURNS bool 3108 AS 'MODULE_PATHNAME', 'pgroonga_match_script_jsonb' 3109 LANGUAGE C 3110 IMMUTABLE 3111 STRICT 3112 PARALLEL SAFE; 3113 3114 IF current_schema() <> 'public' THEN 3115 CREATE OPERATOR public.@@ ( 3116 PROCEDURE = pgroonga.match_script_jsonb, 3117 LEFTARG = jsonb, 3118 RIGHTARG = text, 3119 RESTRICT = contsel, 3120 JOIN = contjoinsel 3121 ); 3122 END IF; 3123 3124 CREATE OPERATOR CLASS pgroonga.jsonb_ops FOR TYPE jsonb 3125 USING pgroonga AS 3126 OPERATOR 9 @@ (jsonb, text), 3127 OPERATOR 11 @>, 3128 OPERATOR 12 &@ (jsonb, text), 3129 OPERATOR 13 &? (jsonb, text), -- For backward compatibility 3130 OPERATOR 15 &` (jsonb, text), 3131 OPERATOR 28 &@~ (jsonb, text); 3132 3133 CREATE OPERATOR CLASS pgroonga.text_regexp_ops FOR TYPE text 3134 USING pgroonga AS 3135 OPERATOR 6 ~~, 3136 OPERATOR 7 ~~*, 3137 OPERATOR 10 @~, 3138 OPERATOR 22 &~; 3139 3140 CREATE OPERATOR CLASS pgroonga.varchar_regexp_ops FOR TYPE varchar 3141 USING pgroonga AS 3142 OPERATOR 10 @~, 3143 OPERATOR 22 &~; 3144 3145 /* v2 */ 3146 CREATE OPERATOR CLASS pgroonga.text_full_text_search_ops_v2 FOR TYPE text 3147 USING pgroonga AS 3148 OPERATOR 6 ~~, 3149 OPERATOR 7 ~~*, 3150 OPERATOR 8 %%, -- For backward compatibility 3151 OPERATOR 9 @@, -- For backward compatibility 3152 OPERATOR 12 &@, 3153 OPERATOR 13 &?, -- For backward compatibility 3154 OPERATOR 14 &~?, -- For backward compatibility 3155 OPERATOR 15 &`, 3156 OPERATOR 18 &@| (text, text[]), 3157 OPERATOR 19 &?| (text, text[]), -- For backward compatibility 3158 OPERATOR 26 &@> (text, text[]), -- For backward compatibility 3159 OPERATOR 27 &?> (text, text[]), -- For backward compatibility 3160 OPERATOR 28 &@~, 3161 OPERATOR 29 &@*, 3162 OPERATOR 30 &@~| (text, text[]); 3163 3164 CREATE OPERATOR CLASS pgroonga.text_array_full_text_search_ops_v2 3165 FOR TYPE text[] 3166 USING pgroonga AS 3167 OPERATOR 8 %% (text[], text), -- For backward compatibility 3168 OPERATOR 9 @@ (text[], text), -- For backward compatibility 3169 OPERATOR 12 &@ (text[], text), 3170 OPERATOR 13 &? (text[], text), -- For backward compatibility 3171 OPERATOR 14 &~? (text[], text), -- For backward compatibility 3172 OPERATOR 15 &` (text[], text), 3173 OPERATOR 18 &@| (text[], text[]), 3174 OPERATOR 19 &?| (text[], text[]), -- For backward compatibility 3175 OPERATOR 28 &@~ (text[], text), 3176 OPERATOR 29 &@* (text[], text), 3177 OPERATOR 30 &@~| (text[], text[]); 3178 3179 CREATE OPERATOR CLASS pgroonga.text_term_search_ops_v2 FOR TYPE text 3180 USING pgroonga AS 3181 OPERATOR 1 <, 3182 OPERATOR 2 <=, 3183 OPERATOR 3 =, 3184 OPERATOR 4 >=, 3185 OPERATOR 5 >, 3186 OPERATOR 16 &^, 3187 OPERATOR 17 &^~, 3188 OPERATOR 20 &^| (text, text[]), 3189 OPERATOR 21 &^~| (text, text[]); 3190 3191 CREATE OPERATOR CLASS pgroonga.text_array_term_search_ops_v2 FOR TYPE text[] 3192 USING pgroonga AS 3193 OPERATOR 16 &^ (text[], text), 3194 OPERATOR 17 &^~ (text[], text), 3195 OPERATOR 20 &^| (text[], text[]), 3196 OPERATOR 21 &^~| (text[], text[]), 3197 OPERATOR 24 &^> (text[], text), -- For backward compatibility 3198 OPERATOR 25 &^~> (text[], text); -- For backward compatibility 3199 3200 CREATE OPERATOR CLASS pgroonga.text_regexp_ops_v2 FOR TYPE text 3201 USING pgroonga AS 3202 OPERATOR 6 ~~, 3203 OPERATOR 7 ~~*, 3204 OPERATOR 10 @~, -- For backward compatibility 3205 OPERATOR 22 &~; 3206 3207 CREATE OPERATOR CLASS pgroonga.varchar_full_text_search_ops_v2 3208 FOR TYPE varchar 3209 USING pgroonga AS 3210 OPERATOR 8 %%, -- For backward compatibility 3211 OPERATOR 9 @@, -- For backward compatibility 3212 OPERATOR 12 &@, 3213 OPERATOR 13 &?, -- For backward compatibility 3214 OPERATOR 14 &~?, -- For backward compatibility 3215 OPERATOR 15 &`, 3216 OPERATOR 18 &@| (varchar, varchar[]), 3217 OPERATOR 19 &?| (varchar, varchar[]), -- For backward compatibility 3218 OPERATOR 28 &@~, 3219 OPERATOR 29 &@*, 3220 OPERATOR 30 &@~| (varchar, varchar[]); 3221 3222 CREATE OPERATOR CLASS pgroonga.varchar_array_term_search_ops_v2 3223 FOR TYPE varchar[] 3224 USING pgroonga AS 3225 OPERATOR 8 %% (varchar[], varchar), -- For backward compatibility 3226 OPERATOR 23 &> (varchar[], varchar); 3227 3228 CREATE OPERATOR CLASS pgroonga.varchar_regexp_ops_v2 FOR TYPE varchar 3229 USING pgroonga AS 3230 OPERATOR 10 @~, -- For backward compatibility 3231 OPERATOR 22 &~; 3232 3233 CREATE OPERATOR CLASS pgroonga.jsonb_ops_v2 3234 FOR TYPE jsonb 3235 USING pgroonga AS 3236 OPERATOR 9 @@ (jsonb, text), -- For backward compatibility 3237 OPERATOR 11 @>, 3238 OPERATOR 12 &@ (jsonb, text), 3239 OPERATOR 13 &? (jsonb, text), -- For backward compatibility 3240 OPERATOR 15 &` (jsonb, text), 3241 OPERATOR 28 &@~ (jsonb, text); 3242 END IF; 3243END; 3244$$; 3245