1-- User-defined types 2--------------------- 3 4-- mol type 5 6CREATE TYPE mol; 7 8CREATE OR REPLACE FUNCTION mol_in(cstring) 9RETURNS mol 10@RDKIT_PARALLEL_SAFE@ 11AS 'MODULE_PATHNAME' 12LANGUAGE C STRICT IMMUTABLE; 13 14CREATE OR REPLACE FUNCTION mol_out(mol) 15RETURNS cstring 16@RDKIT_PARALLEL_SAFE@ 17AS 'MODULE_PATHNAME' 18LANGUAGE C STRICT IMMUTABLE; 19 20CREATE OR REPLACE FUNCTION mol_recv(internal) 21RETURNS mol 22@RDKIT_PARALLEL_SAFE@ 23AS 'MODULE_PATHNAME' 24LANGUAGE C STRICT IMMUTABLE; 25 26CREATE OR REPLACE FUNCTION mol_send(mol) 27RETURNS bytea 28@RDKIT_PARALLEL_SAFE@ 29AS 'MODULE_PATHNAME' 30LANGUAGE C STRICT IMMUTABLE; 31 32CREATE TYPE mol ( 33 INTERNALLENGTH = VARIABLE, 34 INPUT = mol_in, 35 OUTPUT = mol_out, 36 RECEIVE = mol_recv, 37 SEND = mol_send, 38 STORAGE = extended 39); 40 41 42-- qmol type 43 44CREATE TYPE qmol; 45 46CREATE OR REPLACE FUNCTION qmol_in(cstring) 47RETURNS qmol 48@RDKIT_PARALLEL_SAFE@ 49AS 'MODULE_PATHNAME' 50LANGUAGE C STRICT IMMUTABLE; 51 52CREATE OR REPLACE FUNCTION qmol_out(qmol) 53RETURNS cstring 54@RDKIT_PARALLEL_SAFE@ 55AS 'MODULE_PATHNAME' 56LANGUAGE C STRICT IMMUTABLE; 57 58CREATE OR REPLACE FUNCTION qmol_recv(internal) 59RETURNS qmol 60@RDKIT_PARALLEL_SAFE@ 61AS 'MODULE_PATHNAME', 'mol_recv' 62LANGUAGE C STRICT IMMUTABLE; 63 64CREATE OR REPLACE FUNCTION qmol_send(qmol) 65RETURNS bytea 66@RDKIT_PARALLEL_SAFE@ 67AS 'MODULE_PATHNAME', 'mol_send' 68LANGUAGE C STRICT IMMUTABLE; 69 70CREATE TYPE qmol ( 71 INTERNALLENGTH = VARIABLE, 72 INPUT = qmol_in, 73 OUTPUT = qmol_out, 74 RECEIVE = qmol_recv, 75 SEND = qmol_send, 76 STORAGE = extended 77); 78 79 80-- bfp type 81 82CREATE TYPE bfp; 83 84CREATE OR REPLACE FUNCTION bfp_in(cstring) 85RETURNS bfp 86@RDKIT_PARALLEL_SAFE@ 87AS 'MODULE_PATHNAME' 88LANGUAGE C STRICT IMMUTABLE; 89 90CREATE OR REPLACE FUNCTION bfp_out(bfp) 91RETURNS cstring 92@RDKIT_PARALLEL_SAFE@ 93AS 'MODULE_PATHNAME' 94LANGUAGE C STRICT IMMUTABLE; 95 96CREATE TYPE bfp ( 97 INTERNALLENGTH = VARIABLE, 98 INPUT = bfp_in, 99 OUTPUT = bfp_out, 100 STORAGE = extended 101); 102 103 104-- sfp type 105 106CREATE TYPE sfp; 107 108CREATE OR REPLACE FUNCTION sfp_in(cstring) 109RETURNS sfp 110@RDKIT_PARALLEL_SAFE@ 111AS 'MODULE_PATHNAME' 112LANGUAGE C STRICT IMMUTABLE; 113 114CREATE OR REPLACE FUNCTION sfp_out(sfp) 115RETURNS cstring 116@RDKIT_PARALLEL_SAFE@ 117AS 'MODULE_PATHNAME' 118LANGUAGE C STRICT IMMUTABLE; 119 120CREATE TYPE sfp ( 121 INTERNALLENGTH = VARIABLE, 122 INPUT = sfp_in, 123 OUTPUT = sfp_out, 124 STORAGE = extended 125); 126 127 128-- reaction type 129 130CREATE TYPE reaction; 131 132CREATE OR REPLACE FUNCTION reaction_in(cstring) 133RETURNS reaction 134@RDKIT_PARALLEL_SAFE@ 135AS 'MODULE_PATHNAME' 136LANGUAGE C STRICT IMMUTABLE; 137 138CREATE OR REPLACE FUNCTION reaction_out(reaction) 139RETURNS cstring 140@RDKIT_PARALLEL_SAFE@ 141AS 'MODULE_PATHNAME' 142LANGUAGE C STRICT IMMUTABLE; 143 144CREATE OR REPLACE FUNCTION reaction_recv(internal) 145RETURNS reaction 146@RDKIT_PARALLEL_SAFE@ 147AS 'MODULE_PATHNAME' 148LANGUAGE C STRICT IMMUTABLE; 149 150CREATE OR REPLACE FUNCTION reaction_send(reaction) 151RETURNS bytea 152@RDKIT_PARALLEL_SAFE@ 153AS 'MODULE_PATHNAME' 154LANGUAGE C STRICT IMMUTABLE; 155 156CREATE TYPE reaction ( 157 INTERNALLENGTH = VARIABLE, 158 INPUT = reaction_in, 159 OUTPUT = reaction_out, 160 RECEIVE = reaction_recv, 161 SEND = reaction_send, 162 STORAGE = extended 163); 164 165 166-- Construction/Conversion of User-defined types 167------------------------------------------------ 168 169-- mol constructors 170 171CREATE OR REPLACE FUNCTION mol_from_smiles(cstring) 172RETURNS mol 173@RDKIT_PARALLEL_SAFE@ 174AS 'MODULE_PATHNAME' 175LANGUAGE C STRICT IMMUTABLE; 176 177CREATE OR REPLACE FUNCTION mol_from_smarts(cstring) 178RETURNS mol 179@RDKIT_PARALLEL_SAFE@ 180AS 'MODULE_PATHNAME' 181LANGUAGE C STRICT IMMUTABLE; 182 183CREATE OR REPLACE FUNCTION mol_from_ctab(cstring,bool default false) 184RETURNS mol 185@RDKIT_PARALLEL_SAFE@ 186AS 'MODULE_PATHNAME' 187LANGUAGE C STRICT IMMUTABLE; 188 189CREATE OR REPLACE FUNCTION mol_from_pkl(bytea) 190RETURNS mol 191@RDKIT_PARALLEL_SAFE@ 192AS 'MODULE_PATHNAME' 193LANGUAGE C STRICT IMMUTABLE; 194 195CREATE OR REPLACE FUNCTION mol_adjust_query_properties(mol,cstring default '') 196RETURNS mol 197@RDKIT_PARALLEL_SAFE@ 198AS 'MODULE_PATHNAME' 199LANGUAGE C STRICT IMMUTABLE; 200 201CREATE OR REPLACE FUNCTION mol_to_svg(mol, cstring default '', integer default 250, integer default 200, cstring default '') 202RETURNS cstring 203@RDKIT_PARALLEL_SAFE@ 204AS 'MODULE_PATHNAME' 205LANGUAGE C STRICT IMMUTABLE; 206 207 208-- mol conversion functions 209 210CREATE OR REPLACE FUNCTION mol_to_smiles(mol) 211RETURNS cstring 212@RDKIT_PARALLEL_SAFE@ 213AS 'MODULE_PATHNAME' 214LANGUAGE C STRICT IMMUTABLE; 215 216CREATE OR REPLACE FUNCTION mol_to_cxsmiles(mol) 217RETURNS cstring 218@RDKIT_PARALLEL_SAFE@ 219AS 'MODULE_PATHNAME' 220LANGUAGE C STRICT IMMUTABLE; 221 222CREATE OR REPLACE FUNCTION mol_to_smarts(mol) 223RETURNS cstring 224@RDKIT_PARALLEL_SAFE@ 225AS 'MODULE_PATHNAME' 226LANGUAGE C STRICT IMMUTABLE; 227 228CREATE OR REPLACE FUNCTION mol_to_ctab(mol,bool default true) 229RETURNS cstring 230@RDKIT_PARALLEL_SAFE@ 231AS 'MODULE_PATHNAME' 232LANGUAGE C STRICT IMMUTABLE; 233 234CREATE OR REPLACE FUNCTION mol_to_pkl(mol) 235RETURNS bytea 236@RDKIT_PARALLEL_SAFE@ 237AS 'MODULE_PATHNAME' 238LANGUAGE C STRICT IMMUTABLE; 239 240 241-- qmol constructors 242 243CREATE OR REPLACE FUNCTION qmol_from_smiles(cstring) 244RETURNS qmol 245@RDKIT_PARALLEL_SAFE@ 246AS 'MODULE_PATHNAME' 247LANGUAGE C STRICT IMMUTABLE; 248 249CREATE OR REPLACE FUNCTION qmol_from_ctab(cstring,bool default false) 250RETURNS qmol 251@RDKIT_PARALLEL_SAFE@ 252AS 'MODULE_PATHNAME' 253LANGUAGE C STRICT IMMUTABLE; 254 255 256-- qmol conversion functions 257 258CREATE OR REPLACE FUNCTION mol_to_smiles(qmol) 259RETURNS cstring 260@RDKIT_PARALLEL_SAFE@ 261AS 'MODULE_PATHNAME' 262LANGUAGE C STRICT IMMUTABLE; 263 264CREATE OR REPLACE FUNCTION mol_to_smarts(qmol) 265RETURNS cstring 266@RDKIT_PARALLEL_SAFE@ 267AS 'MODULE_PATHNAME' 268LANGUAGE C STRICT IMMUTABLE; 269 270 271-- bfp constructors 272 273CREATE OR REPLACE FUNCTION bfp_from_binary_text(bytea) 274RETURNS bfp 275@RDKIT_PARALLEL_SAFE@ 276AS 'MODULE_PATHNAME' 277LANGUAGE C STRICT IMMUTABLE; 278 279CREATE OR REPLACE FUNCTION avalon_fp(mol,bool default false,int default 15761407) 280RETURNS bfp 281@RDKIT_PARALLEL_SAFE@ 282AS 'MODULE_PATHNAME' 283LANGUAGE C STRICT IMMUTABLE; 284 285CREATE OR REPLACE FUNCTION layered_fp(mol) 286RETURNS bfp 287@RDKIT_PARALLEL_SAFE@ 288AS 'MODULE_PATHNAME' 289LANGUAGE C STRICT IMMUTABLE; 290 291CREATE OR REPLACE FUNCTION maccs_fp(mol) 292RETURNS bfp 293@RDKIT_PARALLEL_SAFE@ 294AS 'MODULE_PATHNAME' 295LANGUAGE C STRICT IMMUTABLE; 296 297CREATE OR REPLACE FUNCTION rdkit_fp(mol) 298RETURNS bfp 299@RDKIT_PARALLEL_SAFE@ 300AS 'MODULE_PATHNAME' 301LANGUAGE C STRICT IMMUTABLE; 302 303CREATE OR REPLACE FUNCTION atompairbv_fp(mol) 304RETURNS bfp 305@RDKIT_PARALLEL_SAFE@ 306AS 'MODULE_PATHNAME' 307LANGUAGE C STRICT IMMUTABLE; 308 309CREATE OR REPLACE FUNCTION featmorganbv_fp(mol,int default 2) 310RETURNS bfp 311@RDKIT_PARALLEL_SAFE@ 312AS 'MODULE_PATHNAME' 313LANGUAGE C STRICT IMMUTABLE; 314 315CREATE OR REPLACE FUNCTION morganbv_fp(mol,int default 2) 316RETURNS bfp 317@RDKIT_PARALLEL_SAFE@ 318AS 'MODULE_PATHNAME' 319LANGUAGE C STRICT IMMUTABLE; 320 321CREATE OR REPLACE FUNCTION torsionbv_fp(mol) 322RETURNS bfp 323@RDKIT_PARALLEL_SAFE@ 324AS 'MODULE_PATHNAME' 325LANGUAGE C STRICT IMMUTABLE; 326 327CREATE OR REPLACE FUNCTION reaction_structural_bfp(reaction,int default 5) 328RETURNS bfp 329@RDKIT_PARALLEL_SAFE@ 330AS 'MODULE_PATHNAME' 331LANGUAGE C STRICT IMMUTABLE; 332 333 334-- bfp conversion functions 335 336CREATE OR REPLACE FUNCTION bfp_to_binary_text(bfp) 337RETURNS bytea 338@RDKIT_PARALLEL_SAFE@ 339AS 'MODULE_PATHNAME' 340LANGUAGE C STRICT IMMUTABLE; 341 342 343-- sfp constructors 344 345CREATE OR REPLACE FUNCTION atompair_fp(mol) 346RETURNS sfp 347@RDKIT_PARALLEL_SAFE@ 348AS 'MODULE_PATHNAME' 349LANGUAGE C STRICT IMMUTABLE; 350 351CREATE OR REPLACE FUNCTION featmorgan_fp(mol,int default 2) 352RETURNS sfp 353@RDKIT_PARALLEL_SAFE@ 354AS 'MODULE_PATHNAME' 355LANGUAGE C STRICT IMMUTABLE; 356 357CREATE OR REPLACE FUNCTION morgan_fp(mol,int default 2) 358RETURNS sfp 359@RDKIT_PARALLEL_SAFE@ 360AS 'MODULE_PATHNAME' 361LANGUAGE C STRICT IMMUTABLE; 362 363CREATE OR REPLACE FUNCTION torsion_fp(mol) 364RETURNS sfp 365@RDKIT_PARALLEL_SAFE@ 366AS 'MODULE_PATHNAME' 367LANGUAGE C STRICT IMMUTABLE; 368 369CREATE OR REPLACE FUNCTION reaction_difference_fp(reaction, int default 1) 370RETURNS sfp 371@RDKIT_PARALLEL_SAFE@ 372AS 'MODULE_PATHNAME' 373LANGUAGE C STRICT IMMUTABLE; 374 375 376-- reaction constructors 377 378CREATE OR REPLACE FUNCTION reaction_from_smiles(cstring) 379RETURNS reaction 380@RDKIT_PARALLEL_SAFE@ 381AS 'MODULE_PATHNAME' 382LANGUAGE C STRICT IMMUTABLE; 383 384CREATE OR REPLACE FUNCTION reaction_from_smarts(cstring) 385RETURNS reaction 386@RDKIT_PARALLEL_SAFE@ 387AS 'MODULE_PATHNAME' 388LANGUAGE C STRICT IMMUTABLE; 389 390CREATE OR REPLACE FUNCTION reaction_from_ctab(cstring) 391RETURNS reaction 392@RDKIT_PARALLEL_SAFE@ 393AS 'MODULE_PATHNAME' 394LANGUAGE C STRICT IMMUTABLE; 395 396 397-- reaction conversion functions 398 399CREATE OR REPLACE FUNCTION reaction_to_smiles(reaction) 400RETURNS cstring 401@RDKIT_PARALLEL_SAFE@ 402AS 'MODULE_PATHNAME' 403LANGUAGE C STRICT IMMUTABLE; 404 405CREATE OR REPLACE FUNCTION reaction_to_smarts(reaction) 406RETURNS cstring 407@RDKIT_PARALLEL_SAFE@ 408AS 'MODULE_PATHNAME' 409LANGUAGE C STRICT IMMUTABLE; 410 411CREATE OR REPLACE FUNCTION reaction_to_ctab(reaction) 412RETURNS cstring 413@RDKIT_PARALLEL_SAFE@ 414AS 'MODULE_PATHNAME' 415LANGUAGE C STRICT IMMUTABLE; 416 417CREATE OR REPLACE FUNCTION reaction_to_svg(reaction, bool default false, integer default 400, integer default 200, cstring default '') 418RETURNS cstring 419@RDKIT_PARALLEL_SAFE@ 420AS 'MODULE_PATHNAME' 421LANGUAGE C STRICT IMMUTABLE; 422 423 424-- Descriptor Functions 425----------------------- 426 427-- mol floating point descriptors 428 429CREATE OR REPLACE FUNCTION mol_amw(mol) 430RETURNS real 431@RDKIT_PARALLEL_SAFE@ 432AS 'MODULE_PATHNAME' 433LANGUAGE C STRICT IMMUTABLE; 434 435CREATE OR REPLACE FUNCTION mol_logp(mol) 436RETURNS real 437@RDKIT_PARALLEL_SAFE@ 438AS 'MODULE_PATHNAME' 439LANGUAGE C STRICT IMMUTABLE; 440 441CREATE OR REPLACE FUNCTION mol_fractioncsp3(mol) 442RETURNS real 443@RDKIT_PARALLEL_SAFE@ 444AS 'MODULE_PATHNAME' 445LANGUAGE C STRICT IMMUTABLE; 446 447CREATE OR REPLACE FUNCTION mol_tpsa(mol) 448RETURNS real 449@RDKIT_PARALLEL_SAFE@ 450AS 'MODULE_PATHNAME' 451LANGUAGE C STRICT IMMUTABLE; 452 453CREATE OR REPLACE FUNCTION mol_chi0n(mol) 454RETURNS real 455@RDKIT_PARALLEL_SAFE@ 456AS 'MODULE_PATHNAME' 457LANGUAGE C STRICT IMMUTABLE; 458 459CREATE OR REPLACE FUNCTION mol_chi1n(mol) 460RETURNS real 461@RDKIT_PARALLEL_SAFE@ 462AS 'MODULE_PATHNAME' 463LANGUAGE C STRICT IMMUTABLE; 464 465CREATE OR REPLACE FUNCTION mol_chi2n(mol) 466RETURNS real 467@RDKIT_PARALLEL_SAFE@ 468AS 'MODULE_PATHNAME' 469LANGUAGE C STRICT IMMUTABLE; 470 471CREATE OR REPLACE FUNCTION mol_chi3n(mol) 472RETURNS real 473@RDKIT_PARALLEL_SAFE@ 474AS 'MODULE_PATHNAME' 475LANGUAGE C STRICT IMMUTABLE; 476 477CREATE OR REPLACE FUNCTION mol_chi4n(mol) 478RETURNS real 479@RDKIT_PARALLEL_SAFE@ 480AS 'MODULE_PATHNAME' 481LANGUAGE C STRICT IMMUTABLE; 482 483CREATE OR REPLACE FUNCTION mol_chi0v(mol) 484RETURNS real 485@RDKIT_PARALLEL_SAFE@ 486AS 'MODULE_PATHNAME' 487LANGUAGE C STRICT IMMUTABLE; 488 489CREATE OR REPLACE FUNCTION mol_chi1v(mol) 490RETURNS real 491@RDKIT_PARALLEL_SAFE@ 492AS 'MODULE_PATHNAME' 493LANGUAGE C STRICT IMMUTABLE; 494 495CREATE OR REPLACE FUNCTION mol_chi2v(mol) 496RETURNS real 497@RDKIT_PARALLEL_SAFE@ 498AS 'MODULE_PATHNAME' 499LANGUAGE C STRICT IMMUTABLE; 500 501CREATE OR REPLACE FUNCTION mol_chi3v(mol) 502RETURNS real 503@RDKIT_PARALLEL_SAFE@ 504AS 'MODULE_PATHNAME' 505LANGUAGE C STRICT IMMUTABLE; 506 507CREATE OR REPLACE FUNCTION mol_chi4v(mol) 508RETURNS real 509@RDKIT_PARALLEL_SAFE@ 510AS 'MODULE_PATHNAME' 511LANGUAGE C STRICT IMMUTABLE; 512 513CREATE OR REPLACE FUNCTION mol_kappa1(mol) 514RETURNS real 515@RDKIT_PARALLEL_SAFE@ 516AS 'MODULE_PATHNAME' 517LANGUAGE C STRICT IMMUTABLE; 518 519CREATE OR REPLACE FUNCTION mol_kappa2(mol) 520RETURNS real 521@RDKIT_PARALLEL_SAFE@ 522AS 'MODULE_PATHNAME' 523LANGUAGE C STRICT IMMUTABLE; 524 525CREATE OR REPLACE FUNCTION mol_kappa3(mol) 526RETURNS real 527@RDKIT_PARALLEL_SAFE@ 528AS 'MODULE_PATHNAME' 529LANGUAGE C STRICT IMMUTABLE; 530 531 532-- mol integer descriptors 533 534CREATE OR REPLACE FUNCTION mol_hba(mol) 535RETURNS integer 536@RDKIT_PARALLEL_SAFE@ 537AS 'MODULE_PATHNAME' 538LANGUAGE C STRICT IMMUTABLE; 539 540CREATE OR REPLACE FUNCTION mol_hbd(mol) 541RETURNS integer 542@RDKIT_PARALLEL_SAFE@ 543AS 'MODULE_PATHNAME' 544LANGUAGE C STRICT IMMUTABLE; 545 546CREATE OR REPLACE FUNCTION mol_numrotatablebonds(mol) 547RETURNS integer 548@RDKIT_PARALLEL_SAFE@ 549AS 'MODULE_PATHNAME' 550LANGUAGE C STRICT IMMUTABLE; 551 552CREATE OR REPLACE FUNCTION mol_numatoms(mol) 553RETURNS integer 554@RDKIT_PARALLEL_SAFE@ 555AS 'MODULE_PATHNAME' 556LANGUAGE C STRICT IMMUTABLE; 557 558CREATE OR REPLACE FUNCTION mol_numheavyatoms(mol) 559RETURNS integer 560@RDKIT_PARALLEL_SAFE@ 561AS 'MODULE_PATHNAME' 562LANGUAGE C STRICT IMMUTABLE; 563 564CREATE OR REPLACE FUNCTION mol_numheteroatoms(mol) 565RETURNS integer 566@RDKIT_PARALLEL_SAFE@ 567AS 'MODULE_PATHNAME' 568LANGUAGE C STRICT IMMUTABLE; 569 570CREATE OR REPLACE FUNCTION mol_numrings(mol) 571RETURNS integer 572@RDKIT_PARALLEL_SAFE@ 573AS 'MODULE_PATHNAME' 574LANGUAGE C STRICT IMMUTABLE; 575 576CREATE OR REPLACE FUNCTION mol_numaromaticrings(mol) 577RETURNS integer 578@RDKIT_PARALLEL_SAFE@ 579AS 'MODULE_PATHNAME' 580LANGUAGE C STRICT IMMUTABLE; 581 582CREATE OR REPLACE FUNCTION mol_numaliphaticrings(mol) 583RETURNS integer 584@RDKIT_PARALLEL_SAFE@ 585AS 'MODULE_PATHNAME' 586LANGUAGE C STRICT IMMUTABLE; 587 588CREATE OR REPLACE FUNCTION mol_numsaturatedrings(mol) 589RETURNS integer 590@RDKIT_PARALLEL_SAFE@ 591AS 'MODULE_PATHNAME' 592LANGUAGE C STRICT IMMUTABLE; 593 594CREATE OR REPLACE FUNCTION mol_numaromaticheterocycles(mol) 595RETURNS integer 596@RDKIT_PARALLEL_SAFE@ 597AS 'MODULE_PATHNAME' 598LANGUAGE C STRICT IMMUTABLE; 599 600CREATE OR REPLACE FUNCTION mol_numaliphaticheterocycles(mol) 601RETURNS integer 602@RDKIT_PARALLEL_SAFE@ 603AS 'MODULE_PATHNAME' 604LANGUAGE C STRICT IMMUTABLE; 605 606CREATE OR REPLACE FUNCTION mol_numsaturatedheterocycles(mol) 607RETURNS integer 608@RDKIT_PARALLEL_SAFE@ 609AS 'MODULE_PATHNAME' 610LANGUAGE C STRICT IMMUTABLE; 611 612CREATE OR REPLACE FUNCTION mol_numaromaticcarbocycles(mol) 613RETURNS integer 614@RDKIT_PARALLEL_SAFE@ 615AS 'MODULE_PATHNAME' 616LANGUAGE C STRICT IMMUTABLE; 617 618CREATE OR REPLACE FUNCTION mol_numaliphaticcarbocycles(mol) 619RETURNS integer 620@RDKIT_PARALLEL_SAFE@ 621AS 'MODULE_PATHNAME' 622LANGUAGE C STRICT IMMUTABLE; 623 624CREATE OR REPLACE FUNCTION mol_numsaturatedcarbocycles(mol) 625RETURNS integer 626@RDKIT_PARALLEL_SAFE@ 627AS 'MODULE_PATHNAME' 628LANGUAGE C STRICT IMMUTABLE; 629 630CREATE OR REPLACE FUNCTION mol_numheterocycles(mol) 631RETURNS integer 632@RDKIT_PARALLEL_SAFE@ 633AS 'MODULE_PATHNAME' 634LANGUAGE C STRICT IMMUTABLE; 635 636CREATE OR REPLACE FUNCTION mol_numspiroatoms(mol) 637RETURNS int 638@RDKIT_PARALLEL_SAFE@ 639AS 'MODULE_PATHNAME' 640LANGUAGE C STRICT IMMUTABLE; 641 642CREATE OR REPLACE FUNCTION mol_numbridgeheadatoms(mol) 643RETURNS int 644@RDKIT_PARALLEL_SAFE@ 645AS 'MODULE_PATHNAME' 646LANGUAGE C STRICT IMMUTABLE; 647 648 649-- mol text descriptors 650 651CREATE OR REPLACE FUNCTION mol_formula(mol,bool default false, bool default true) 652RETURNS cstring 653@RDKIT_PARALLEL_SAFE@ 654AS 'MODULE_PATHNAME' 655LANGUAGE C STRICT IMMUTABLE; 656 657CREATE OR REPLACE FUNCTION mol_inchi(mol, cstring default '') 658RETURNS cstring 659AS 'MODULE_PATHNAME' 660LANGUAGE C STRICT IMMUTABLE; 661 662CREATE OR REPLACE FUNCTION mol_inchikey(mol, cstring default '') 663RETURNS cstring 664AS 'MODULE_PATHNAME' 665LANGUAGE C STRICT IMMUTABLE; 666 667CREATE OR REPLACE FUNCTION mol_murckoscaffold(mol) 668RETURNS mol 669@RDKIT_PARALLEL_SAFE@ 670AS 'MODULE_PATHNAME' 671LANGUAGE C STRICT IMMUTABLE; 672 673CREATE OR REPLACE FUNCTION mol_nm_hash(mol, cstring default 'AnonymousGraph') 674 RETURNS cstring 675 AS 'MODULE_PATHNAME', 'mol_nm_hash' 676 LANGUAGE C STRICT IMMUTABLE; 677 678 679-- bfp integer descriptors 680 681CREATE OR REPLACE FUNCTION size(bfp) 682RETURNS int4 683@RDKIT_PARALLEL_SAFE@ 684AS 'MODULE_PATHNAME', 'bfp_size' 685LANGUAGE C STRICT IMMUTABLE; 686 687 688-- Sfp manipulation 689 690CREATE OR REPLACE FUNCTION add(sfp, sfp) 691RETURNS sfp 692@RDKIT_PARALLEL_SAFE@ 693AS 'MODULE_PATHNAME', 'sfp_add' 694LANGUAGE C STRICT IMMUTABLE COST 10; 695 696CREATE OR REPLACE FUNCTION subtract(sfp, sfp) 697RETURNS sfp 698@RDKIT_PARALLEL_SAFE@ 699AS 'MODULE_PATHNAME', 'sfp_subtract' 700LANGUAGE C STRICT IMMUTABLE COST 10; 701 702CREATE OR REPLACE FUNCTION all_values_gt(sfp, int) 703RETURNS bool 704@RDKIT_PARALLEL_SAFE@ 705AS 'MODULE_PATHNAME', 'sfp_allvals_gt' 706LANGUAGE C STRICT IMMUTABLE COST 10; 707 708CREATE OR REPLACE FUNCTION all_values_lt(sfp, int) 709RETURNS bool 710@RDKIT_PARALLEL_SAFE@ 711AS 'MODULE_PATHNAME', 'sfp_allvals_lt' 712LANGUAGE C STRICT IMMUTABLE COST 10; 713 714 715-- reaction integer descriptors 716 717CREATE OR REPLACE FUNCTION reaction_numreactants(reaction) 718RETURNS integer 719@RDKIT_PARALLEL_SAFE@ 720AS 'MODULE_PATHNAME' 721LANGUAGE C STRICT IMMUTABLE; 722 723CREATE OR REPLACE FUNCTION reaction_numproducts(reaction) 724RETURNS integer 725@RDKIT_PARALLEL_SAFE@ 726AS 'MODULE_PATHNAME' 727LANGUAGE C STRICT IMMUTABLE; 728 729CREATE OR REPLACE FUNCTION reaction_numagents(reaction) 730RETURNS integer 731@RDKIT_PARALLEL_SAFE@ 732AS 'MODULE_PATHNAME' 733LANGUAGE C STRICT IMMUTABLE; 734 735 736-- Utility functions 737 738CREATE OR REPLACE FUNCTION rdkit_version() 739RETURNS text 740@RDKIT_PARALLEL_SAFE@ 741AS 'MODULE_PATHNAME' 742LANGUAGE C STRICT IMMUTABLE; 743 744CREATE OR REPLACE FUNCTION is_valid_smiles(cstring) 745RETURNS bool 746@RDKIT_PARALLEL_SAFE@ 747AS 'MODULE_PATHNAME' 748LANGUAGE C STRICT IMMUTABLE; 749 750CREATE OR REPLACE FUNCTION is_valid_smarts(cstring) 751RETURNS bool 752@RDKIT_PARALLEL_SAFE@ 753AS 'MODULE_PATHNAME' 754LANGUAGE C STRICT IMMUTABLE; 755 756CREATE OR REPLACE FUNCTION is_valid_ctab(cstring) 757RETURNS bool 758@RDKIT_PARALLEL_SAFE@ 759AS 'MODULE_PATHNAME' 760LANGUAGE C STRICT IMMUTABLE; 761 762CREATE OR REPLACE FUNCTION is_valid_mol_pkl(bytea) 763RETURNS bool 764@RDKIT_PARALLEL_SAFE@ 765AS 'MODULE_PATHNAME' 766LANGUAGE C STRICT IMMUTABLE; 767 768 769-- Similarity functions 770----------------------- 771 772-- Bfp similarity functions 773 774CREATE OR REPLACE FUNCTION tanimoto_sml(bfp, bfp) 775RETURNS float8 776@RDKIT_PARALLEL_SAFE@ 777AS 'MODULE_PATHNAME', 'bfp_tanimoto_sml' 778LANGUAGE C STRICT IMMUTABLE COST 10; 779 780CREATE OR REPLACE FUNCTION dice_sml(bfp, bfp) 781RETURNS float8 782@RDKIT_PARALLEL_SAFE@ 783AS 'MODULE_PATHNAME', 'bfp_dice_sml' 784LANGUAGE C STRICT IMMUTABLE COST 10; 785 786CREATE OR REPLACE FUNCTION tversky_sml(bfp, bfp, float4, float4) 787RETURNS float8 788@RDKIT_PARALLEL_SAFE@ 789AS 'MODULE_PATHNAME', 'bfp_tversky_sml' 790LANGUAGE C STRICT IMMUTABLE COST 10; 791 792-- Sfp similarity functions 793 794CREATE OR REPLACE FUNCTION tanimoto_sml(sfp, sfp) 795RETURNS float8 796@RDKIT_PARALLEL_SAFE@ 797AS 'MODULE_PATHNAME', 'sfp_tanimoto_sml' 798LANGUAGE C STRICT IMMUTABLE COST 10; 799 800CREATE OR REPLACE FUNCTION dice_sml(sfp, sfp) 801RETURNS float8 802@RDKIT_PARALLEL_SAFE@ 803AS 'MODULE_PATHNAME', 'sfp_dice_sml' 804LANGUAGE C STRICT IMMUTABLE COST 10; 805 806 807-- Similarity operators 808----------------------- 809 810-- Bfp similarity and distance operators 811 812CREATE OR REPLACE FUNCTION tanimoto_sml_op(bfp, bfp) 813RETURNS bool 814@RDKIT_PARALLEL_SAFE@ 815AS 'MODULE_PATHNAME', 'bfp_tanimoto_sml_op' 816LANGUAGE C STRICT IMMUTABLE COST 10; 817 818CREATE OPERATOR % ( 819 LEFTARG = bfp, 820 RIGHTARG = bfp, 821 PROCEDURE = tanimoto_sml_op(bfp, bfp), 822 COMMUTATOR = '%', 823 RESTRICT = contsel, 824 JOIN = contjoinsel 825); 826 827CREATE OR REPLACE FUNCTION tanimoto_dist(bfp, bfp) 828RETURNS float8 829@RDKIT_PARALLEL_SAFE@ 830AS 'MODULE_PATHNAME', 'bfp_tanimoto_dist' 831LANGUAGE C STRICT IMMUTABLE COST 10; 832 833CREATE OPERATOR <%> ( 834 LEFTARG = bfp, 835 RIGHTARG = bfp, 836 PROCEDURE = tanimoto_dist(bfp, bfp), 837 COMMUTATOR = '<%>' 838); 839 840CREATE OR REPLACE FUNCTION dice_sml_op(bfp, bfp) 841RETURNS bool 842@RDKIT_PARALLEL_SAFE@ 843AS 'MODULE_PATHNAME', 'bfp_dice_sml_op' 844LANGUAGE C STRICT IMMUTABLE COST 10; 845 846CREATE OPERATOR # ( 847 LEFTARG = bfp, 848 RIGHTARG = bfp, 849 PROCEDURE = dice_sml_op(bfp, bfp), 850 COMMUTATOR = '#', 851 RESTRICT = contsel, 852 JOIN = contjoinsel 853); 854 855CREATE OR REPLACE FUNCTION dice_dist(bfp, bfp) 856RETURNS float8 857@RDKIT_PARALLEL_SAFE@ 858AS 'MODULE_PATHNAME', 'bfp_dice_dist' 859LANGUAGE C STRICT IMMUTABLE COST 10; 860 861CREATE OPERATOR <#> ( 862 LEFTARG = bfp, 863 RIGHTARG = bfp, 864 PROCEDURE = dice_dist(bfp, bfp), 865 COMMUTATOR = '<#>' 866); 867 868-- Sfp similarity operators 869 870CREATE OR REPLACE FUNCTION tanimoto_sml_op(sfp, sfp) 871RETURNS bool 872@RDKIT_PARALLEL_SAFE@ 873AS 'MODULE_PATHNAME', 'sfp_tanimoto_sml_op' 874LANGUAGE C STRICT IMMUTABLE COST 10; 875 876CREATE OPERATOR % ( 877 LEFTARG = sfp, 878 RIGHTARG = sfp, 879 PROCEDURE = tanimoto_sml_op(sfp, sfp), 880 COMMUTATOR = '%', 881 RESTRICT = contsel, 882 JOIN = contjoinsel 883); 884 885CREATE OR REPLACE FUNCTION dice_sml_op(sfp, sfp) 886RETURNS bool 887@RDKIT_PARALLEL_SAFE@ 888AS 'MODULE_PATHNAME', 'sfp_dice_sml_op' 889LANGUAGE C STRICT IMMUTABLE COST 10; 890 891CREATE OPERATOR # ( 892 LEFTARG = sfp, 893 RIGHTARG = sfp, 894 PROCEDURE = dice_sml_op(sfp, sfp), 895 COMMUTATOR = '#', 896 RESTRICT = contsel, 897 JOIN = contjoinsel 898); 899 900 901-- mol substructure search 902 903CREATE OR REPLACE FUNCTION substruct(mol, mol) 904RETURNS bool 905@RDKIT_PARALLEL_SAFE@ 906AS 'MODULE_PATHNAME', 'mol_substruct' 907LANGUAGE C STRICT IMMUTABLE; 908 909CREATE OR REPLACE FUNCTION substruct_count(mol, mol,bool default true) 910RETURNS int 911@RDKIT_PARALLEL_SAFE@ 912AS 'MODULE_PATHNAME', 'mol_substruct_count' 913LANGUAGE C STRICT IMMUTABLE; 914 915CREATE OPERATOR @> ( 916 LEFTARG = mol, 917 RIGHTARG = mol, 918 PROCEDURE = substruct(mol, mol), 919 COMMUTATOR = '<@', 920 RESTRICT = contsel, 921 JOIN = contjoinsel 922); 923 924CREATE OR REPLACE FUNCTION substruct(mol, qmol) 925RETURNS bool 926@RDKIT_PARALLEL_SAFE@ 927AS 'MODULE_PATHNAME', 'mol_substruct' 928LANGUAGE C STRICT IMMUTABLE; 929CREATE OPERATOR @> ( 930 LEFTARG = mol, 931 RIGHTARG = qmol, 932 PROCEDURE = substruct(mol, qmol), 933 COMMUTATOR = '<@', 934 RESTRICT = contsel, 935 JOIN = contjoinsel 936); 937 938CREATE OR REPLACE FUNCTION rsubstruct(mol, mol) 939RETURNS bool 940@RDKIT_PARALLEL_SAFE@ 941AS 'MODULE_PATHNAME', 'mol_rsubstruct' 942LANGUAGE C STRICT IMMUTABLE; 943 944CREATE OR REPLACE FUNCTION rsubstruct(qmol, mol) 945RETURNS bool 946@RDKIT_PARALLEL_SAFE@ 947AS 'MODULE_PATHNAME', 'mol_rsubstruct' 948LANGUAGE C STRICT IMMUTABLE; 949 950CREATE OPERATOR <@ ( 951 LEFTARG = mol, 952 RIGHTARG = mol, 953 PROCEDURE = rsubstruct(mol, mol), 954 COMMUTATOR = '@>', 955 RESTRICT = contsel, 956 JOIN = contjoinsel 957); 958CREATE OPERATOR <@ ( 959 LEFTARG = qmol, 960 RIGHTARG = mol, 961 PROCEDURE = rsubstruct(qmol, mol), 962 COMMUTATOR = '@>', 963 RESTRICT = contsel, 964 JOIN = contjoinsel 965); 966 967-- mol comparison 968 969CREATE OR REPLACE FUNCTION mol_cmp(mol,mol) 970RETURNS int4 971@RDKIT_PARALLEL_SAFE@ 972AS 'MODULE_PATHNAME' 973LANGUAGE C STRICT IMMUTABLE; 974 975CREATE OR REPLACE FUNCTION mol_lt(mol,mol) 976RETURNS bool 977@RDKIT_PARALLEL_SAFE@ 978AS 'MODULE_PATHNAME' 979LANGUAGE C STRICT IMMUTABLE; 980 981CREATE OR REPLACE FUNCTION mol_le(mol,mol) 982RETURNS bool 983@RDKIT_PARALLEL_SAFE@ 984AS 'MODULE_PATHNAME' 985LANGUAGE C STRICT IMMUTABLE; 986 987CREATE OR REPLACE FUNCTION mol_eq(mol,mol) 988RETURNS bool 989@RDKIT_PARALLEL_SAFE@ 990AS 'MODULE_PATHNAME' 991LANGUAGE C STRICT IMMUTABLE; 992 993CREATE OR REPLACE FUNCTION mol_ge(mol,mol) 994RETURNS bool 995@RDKIT_PARALLEL_SAFE@ 996AS 'MODULE_PATHNAME' 997LANGUAGE C STRICT IMMUTABLE; 998 999CREATE OR REPLACE FUNCTION mol_gt(mol,mol) 1000RETURNS bool 1001@RDKIT_PARALLEL_SAFE@ 1002AS 'MODULE_PATHNAME' 1003LANGUAGE C STRICT IMMUTABLE; 1004 1005CREATE OR REPLACE FUNCTION mol_ne(mol,mol) 1006RETURNS bool 1007@RDKIT_PARALLEL_SAFE@ 1008AS 'MODULE_PATHNAME' 1009LANGUAGE C STRICT IMMUTABLE; 1010 1011CREATE OPERATOR < ( 1012 LEFTARG = mol, 1013 RIGHTARG = mol, 1014 PROCEDURE = mol_lt, 1015 COMMUTATOR = '>', 1016 NEGATOR = '>=', 1017 RESTRICT = contsel, 1018 JOIN = contjoinsel 1019); 1020 1021CREATE OPERATOR <= ( 1022 LEFTARG = mol, 1023 RIGHTARG = mol, 1024 PROCEDURE = mol_le, 1025 COMMUTATOR = '>=', 1026 NEGATOR = '>', 1027 RESTRICT = contsel, 1028 JOIN = contjoinsel 1029); 1030 1031CREATE OPERATOR >= ( 1032 LEFTARG = mol, 1033 RIGHTARG = mol, 1034 PROCEDURE = mol_ge, 1035 COMMUTATOR = '<=', 1036 NEGATOR = '<', 1037 RESTRICT = contsel, 1038 JOIN = contjoinsel 1039); 1040 1041CREATE OPERATOR > ( 1042 LEFTARG = mol, 1043 RIGHTARG = mol, 1044 PROCEDURE = mol_gt, 1045 COMMUTATOR = '<', 1046 NEGATOR = '<=', 1047 RESTRICT = contsel, 1048 JOIN = contjoinsel 1049); 1050 1051CREATE OPERATOR = ( 1052 LEFTARG = mol, 1053 RIGHTARG = mol, 1054 PROCEDURE = mol_eq, 1055 COMMUTATOR = '=', 1056 NEGATOR = '<>', 1057 RESTRICT = eqsel, 1058 JOIN = eqjoinsel, 1059 SORT1 = '<', 1060 SORT2 = '<' 1061); 1062 1063CREATE OPERATOR <> ( 1064 LEFTARG = mol, 1065 RIGHTARG = mol, 1066 PROCEDURE = mol_ne, 1067 COMMUTATOR = '<>', 1068 NEGATOR = '=', 1069 RESTRICT = neqsel, 1070 JOIN = neqjoinsel 1071); 1072 1073CREATE OPERATOR @= ( 1074 LEFTARG = mol, 1075 RIGHTARG = mol, 1076 PROCEDURE = mol_eq, 1077 COMMUTATOR = '=', 1078 NEGATOR = '<>', 1079 RESTRICT = eqsel, 1080 JOIN = eqjoinsel 1081); 1082 1083-- bfp comparison 1084 1085CREATE OR REPLACE FUNCTION bfp_cmp(bfp,bfp) 1086RETURNS int4 1087@RDKIT_PARALLEL_SAFE@ 1088AS 'MODULE_PATHNAME' 1089LANGUAGE C STRICT IMMUTABLE; 1090 1091CREATE OR REPLACE FUNCTION bfp_lt(bfp,bfp) 1092RETURNS bool 1093@RDKIT_PARALLEL_SAFE@ 1094AS 'MODULE_PATHNAME' 1095LANGUAGE C STRICT IMMUTABLE; 1096 1097CREATE OR REPLACE FUNCTION bfp_le(bfp,bfp) 1098RETURNS bool 1099@RDKIT_PARALLEL_SAFE@ 1100AS 'MODULE_PATHNAME' 1101LANGUAGE C STRICT IMMUTABLE; 1102 1103CREATE OR REPLACE FUNCTION bfp_eq(bfp,bfp) 1104RETURNS bool 1105@RDKIT_PARALLEL_SAFE@ 1106AS 'MODULE_PATHNAME' 1107LANGUAGE C STRICT IMMUTABLE; 1108 1109CREATE OR REPLACE FUNCTION bfp_ge(bfp,bfp) 1110RETURNS bool 1111@RDKIT_PARALLEL_SAFE@ 1112AS 'MODULE_PATHNAME' 1113LANGUAGE C STRICT IMMUTABLE; 1114 1115CREATE OR REPLACE FUNCTION bfp_gt(bfp,bfp) 1116RETURNS bool 1117@RDKIT_PARALLEL_SAFE@ 1118AS 'MODULE_PATHNAME' 1119LANGUAGE C STRICT IMMUTABLE; 1120 1121CREATE OR REPLACE FUNCTION bfp_ne(bfp,bfp) 1122RETURNS bool 1123@RDKIT_PARALLEL_SAFE@ 1124AS 'MODULE_PATHNAME' 1125LANGUAGE C STRICT IMMUTABLE; 1126 1127CREATE OPERATOR < ( 1128 LEFTARG = bfp, 1129 RIGHTARG = bfp, 1130 PROCEDURE = bfp_lt, 1131 COMMUTATOR = '>', 1132 NEGATOR = '>=', 1133 RESTRICT = contsel, 1134 JOIN = contjoinsel 1135); 1136 1137CREATE OPERATOR <= ( 1138 LEFTARG = bfp, 1139 RIGHTARG = bfp, 1140 PROCEDURE = bfp_le, 1141 COMMUTATOR = '>=', 1142 NEGATOR = '>', 1143 RESTRICT = contsel, 1144 JOIN = contjoinsel 1145); 1146 1147CREATE OPERATOR >= ( 1148 LEFTARG = bfp, 1149 RIGHTARG = bfp, 1150 PROCEDURE = bfp_ge, 1151 COMMUTATOR = '<=', 1152 NEGATOR = '<', 1153 RESTRICT = contsel, 1154 JOIN = contjoinsel 1155); 1156 1157CREATE OPERATOR > ( 1158 LEFTARG = bfp, 1159 RIGHTARG = bfp, 1160 PROCEDURE = bfp_gt, 1161 COMMUTATOR = '<', 1162 NEGATOR = '<=', 1163 RESTRICT = contsel, 1164 JOIN = contjoinsel 1165); 1166 1167CREATE OPERATOR = ( 1168 LEFTARG = bfp, 1169 RIGHTARG = bfp, 1170 PROCEDURE = bfp_eq, 1171 COMMUTATOR = '=', 1172 NEGATOR = '<>', 1173 RESTRICT = eqsel, 1174 JOIN = eqjoinsel, 1175 SORT1 = '<', 1176 SORT2 = '<' 1177); 1178 1179CREATE OPERATOR <> ( 1180 LEFTARG = bfp, 1181 RIGHTARG = bfp, 1182 PROCEDURE = bfp_ne, 1183 COMMUTATOR = '<>', 1184 NEGATOR = '=', 1185 RESTRICT = neqsel, 1186 JOIN = neqjoinsel 1187); 1188 1189-- sfp comparison 1190 1191CREATE OR REPLACE FUNCTION sfp_cmp(sfp,sfp) 1192RETURNS int4 1193@RDKIT_PARALLEL_SAFE@ 1194AS 'MODULE_PATHNAME' 1195LANGUAGE C STRICT IMMUTABLE; 1196 1197CREATE OR REPLACE FUNCTION sfp_lt(sfp,sfp) 1198RETURNS bool 1199@RDKIT_PARALLEL_SAFE@ 1200AS 'MODULE_PATHNAME' 1201LANGUAGE C STRICT IMMUTABLE; 1202 1203CREATE OR REPLACE FUNCTION sfp_le(sfp,sfp) 1204RETURNS bool 1205@RDKIT_PARALLEL_SAFE@ 1206AS 'MODULE_PATHNAME' 1207LANGUAGE C STRICT IMMUTABLE; 1208 1209CREATE OR REPLACE FUNCTION sfp_eq(sfp,sfp) 1210RETURNS bool 1211@RDKIT_PARALLEL_SAFE@ 1212AS 'MODULE_PATHNAME' 1213LANGUAGE C STRICT IMMUTABLE; 1214 1215CREATE OR REPLACE FUNCTION sfp_ge(sfp,sfp) 1216RETURNS bool 1217@RDKIT_PARALLEL_SAFE@ 1218AS 'MODULE_PATHNAME' 1219LANGUAGE C STRICT IMMUTABLE; 1220 1221CREATE OR REPLACE FUNCTION sfp_gt(sfp,sfp) 1222RETURNS bool 1223@RDKIT_PARALLEL_SAFE@ 1224AS 'MODULE_PATHNAME' 1225LANGUAGE C STRICT IMMUTABLE; 1226 1227CREATE OR REPLACE FUNCTION sfp_ne(sfp,sfp) 1228RETURNS bool 1229@RDKIT_PARALLEL_SAFE@ 1230AS 'MODULE_PATHNAME' 1231LANGUAGE C STRICT IMMUTABLE; 1232 1233CREATE OPERATOR < ( 1234 LEFTARG = sfp, 1235 RIGHTARG = sfp, 1236 PROCEDURE = sfp_lt, 1237 COMMUTATOR = '>', 1238 NEGATOR = '>=', 1239 RESTRICT = contsel, 1240 JOIN = contjoinsel 1241); 1242 1243CREATE OPERATOR <= ( 1244 LEFTARG = sfp, 1245 RIGHTARG = sfp, 1246 PROCEDURE = sfp_le, 1247 COMMUTATOR = '>=', 1248 NEGATOR = '>', 1249 RESTRICT = contsel, 1250 JOIN = contjoinsel 1251); 1252 1253CREATE OPERATOR >= ( 1254 LEFTARG = sfp, 1255 RIGHTARG = sfp, 1256 PROCEDURE = sfp_ge, 1257 COMMUTATOR = '<=', 1258 NEGATOR = '<', 1259 RESTRICT = contsel, 1260 JOIN = contjoinsel 1261); 1262 1263CREATE OPERATOR > ( 1264 LEFTARG = sfp, 1265 RIGHTARG = sfp, 1266 PROCEDURE = sfp_gt, 1267 COMMUTATOR = '<', 1268 NEGATOR = '<=', 1269 RESTRICT = contsel, 1270 JOIN = contjoinsel 1271); 1272 1273CREATE OPERATOR = ( 1274 LEFTARG = sfp, 1275 RIGHTARG = sfp, 1276 PROCEDURE = sfp_eq, 1277 COMMUTATOR = '=', 1278 NEGATOR = '<>', 1279 RESTRICT = eqsel, 1280 JOIN = eqjoinsel, 1281 SORT1 = '<', 1282 SORT2 = '<' 1283); 1284 1285CREATE OPERATOR <> ( 1286 LEFTARG = sfp, 1287 RIGHTARG = sfp, 1288 PROCEDURE = sfp_ne, 1289 COMMUTATOR = '<>', 1290 NEGATOR = '=', 1291 RESTRICT = neqsel, 1292 JOIN = neqjoinsel 1293); 1294 1295 1296-- Reaction substructure search 1297 1298CREATE OR REPLACE FUNCTION substruct(reaction, reaction) 1299RETURNS bool 1300@RDKIT_PARALLEL_SAFE@ 1301AS 'MODULE_PATHNAME', 'reaction_substruct' 1302LANGUAGE C STRICT IMMUTABLE; 1303 1304CREATE OPERATOR @> ( 1305 LEFTARG = reaction, 1306 RIGHTARG = reaction, 1307 PROCEDURE = substruct(reaction, reaction), 1308 COMMUTATOR = '<@', 1309 RESTRICT = contsel, 1310 JOIN = contjoinsel 1311); 1312 1313CREATE OR REPLACE FUNCTION substructFP(reaction, reaction) 1314RETURNS bool 1315@RDKIT_PARALLEL_SAFE@ 1316AS 'MODULE_PATHNAME', 'reaction_substructFP' 1317LANGUAGE C STRICT IMMUTABLE; 1318 1319CREATE OPERATOR ?> ( 1320 LEFTARG = reaction, 1321 RIGHTARG = reaction, 1322 PROCEDURE = substructFP(reaction, reaction), 1323 COMMUTATOR = '?<', 1324 RESTRICT = contsel, 1325 JOIN = contjoinsel 1326); 1327 1328CREATE OR REPLACE FUNCTION rsubstruct(reaction, reaction) 1329RETURNS bool 1330@RDKIT_PARALLEL_SAFE@ 1331AS 'MODULE_PATHNAME', 'reaction_rsubstruct' 1332LANGUAGE C STRICT IMMUTABLE; 1333 1334CREATE OPERATOR <@ ( 1335 LEFTARG = reaction, 1336 RIGHTARG = reaction, 1337 PROCEDURE = rsubstruct(reaction, reaction), 1338 COMMUTATOR = '@>', 1339 RESTRICT = contsel, 1340 JOIN = contjoinsel 1341); 1342 1343CREATE OR REPLACE FUNCTION rsubstructFP(reaction, reaction) 1344RETURNS bool 1345@RDKIT_PARALLEL_SAFE@ 1346AS 'MODULE_PATHNAME', 'reaction_rsubstructFP' 1347LANGUAGE C STRICT IMMUTABLE; 1348 1349CREATE OPERATOR ?< ( 1350 LEFTARG = reaction, 1351 RIGHTARG = reaction, 1352 PROCEDURE = rsubstructFP(reaction, reaction), 1353 COMMUTATOR = '?>', 1354 RESTRICT = contsel, 1355 JOIN = contjoinsel 1356); 1357 1358 1359-- Reaction comparison 1360 1361CREATE OR REPLACE FUNCTION reaction_ne(reaction,reaction) 1362RETURNS bool 1363@RDKIT_PARALLEL_SAFE@ 1364AS 'MODULE_PATHNAME' 1365LANGUAGE C STRICT IMMUTABLE; 1366 1367CREATE OPERATOR <> ( 1368 LEFTARG = reaction, 1369 RIGHTARG = reaction, 1370 PROCEDURE = reaction_ne, 1371 COMMUTATOR = '<>', 1372 NEGATOR = '=', 1373 RESTRICT = neqsel, 1374 JOIN = neqjoinsel 1375); 1376 1377CREATE OR REPLACE FUNCTION reaction_eq(reaction,reaction) 1378RETURNS bool 1379@RDKIT_PARALLEL_SAFE@ 1380AS 'MODULE_PATHNAME' 1381LANGUAGE C STRICT IMMUTABLE; 1382 1383CREATE OPERATOR @= ( 1384 LEFTARG = reaction, 1385 RIGHTARG = reaction, 1386 PROCEDURE = reaction_eq, 1387 COMMUTATOR = '=', 1388 NEGATOR = '<>', 1389 RESTRICT = eqsel, 1390 JOIN = eqjoinsel 1391); 1392 1393 1394-- Operator classes for btree 1395 1396CREATE OPERATOR CLASS btree_mol_ops 1397 DEFAULT FOR TYPE mol USING btree AS 1398 OPERATOR 1 < , 1399 OPERATOR 2 <= , 1400 OPERATOR 3 = , 1401 OPERATOR 4 >= , 1402 OPERATOR 5 > , 1403 FUNCTION 1 mol_cmp(mol, mol); 1404 1405CREATE OPERATOR CLASS btree_bfp_ops 1406 DEFAULT FOR TYPE bfp USING btree AS 1407 OPERATOR 1 < , 1408 OPERATOR 2 <= , 1409 OPERATOR 3 = , 1410 OPERATOR 4 >= , 1411 OPERATOR 5 > , 1412 FUNCTION 1 bfp_cmp(bfp, bfp); 1413 1414CREATE OPERATOR CLASS btree_sfp_ops 1415 DEFAULT FOR TYPE sfp USING btree AS 1416 OPERATOR 1 < , 1417 OPERATOR 2 <= , 1418 OPERATOR 3 = , 1419 OPERATOR 4 >= , 1420 OPERATOR 5 > , 1421 FUNCTION 1 sfp_cmp(sfp, sfp); 1422 1423 1424-- Operator classes for hash 1425 1426CREATE OPERATOR CLASS hash_mol_ops 1427 DEFAULT FOR TYPE mol USING hash AS 1428 OPERATOR 1 =, 1429 FUNCTION 1 hashvarlena(internal); 1430 1431CREATE OPERATOR CLASS hash_bfp_ops 1432 DEFAULT FOR TYPE bfp USING hash AS 1433 OPERATOR 1 =, 1434 FUNCTION 1 hashvarlena(internal); 1435 1436CREATE OPERATOR CLASS hash_sfp_ops 1437 DEFAULT FOR TYPE sfp USING hash AS 1438 OPERATOR 1 =, 1439 FUNCTION 1 hashvarlena(internal); 1440 1441 1442-- Support functions for mol gist 1443 1444CREATE OR REPLACE FUNCTION gmol_consistent(bytea,internal,int4) 1445 RETURNS bool 1446 AS 'MODULE_PATHNAME' 1447 LANGUAGE C IMMUTABLE; 1448 1449CREATE OR REPLACE FUNCTION gmol_compress(internal) 1450 RETURNS internal 1451 AS 'MODULE_PATHNAME' 1452 LANGUAGE C IMMUTABLE; 1453 1454CREATE OR REPLACE FUNCTION gmol_decompress(internal) 1455 RETURNS internal 1456 AS 'MODULE_PATHNAME' 1457 LANGUAGE C IMMUTABLE; 1458 1459CREATE OR REPLACE FUNCTION gmol_penalty(internal,internal,internal) 1460 RETURNS internal 1461 AS 'MODULE_PATHNAME' 1462 LANGUAGE C STRICT IMMUTABLE; 1463 1464CREATE OR REPLACE FUNCTION gmol_picksplit(internal, internal) 1465 RETURNS internal 1466 AS 'MODULE_PATHNAME' 1467 LANGUAGE C IMMUTABLE; 1468 1469CREATE OR REPLACE FUNCTION gmol_union(bytea, internal) 1470 RETURNS _int4 1471 AS 'MODULE_PATHNAME' 1472 LANGUAGE C IMMUTABLE; 1473 1474CREATE OR REPLACE FUNCTION gmol_same(bytea, bytea, internal) 1475 RETURNS internal 1476 AS 'MODULE_PATHNAME' 1477 LANGUAGE C IMMUTABLE; 1478 1479 1480-- Support functions for bfp gist 1481 1482CREATE OR REPLACE FUNCTION gbfp_consistent(internal, bytea, smallint, oid, internal) 1483 RETURNS bool 1484 AS 'MODULE_PATHNAME' 1485 LANGUAGE C STABLE STRICT; 1486 1487CREATE OR REPLACE FUNCTION gbfp_union(internal, internal) 1488 RETURNS _internal 1489 AS 'MODULE_PATHNAME' 1490 LANGUAGE C IMMUTABLE STRICT; 1491 1492CREATE OR REPLACE FUNCTION gbfp_compress(internal) 1493 RETURNS internal 1494 AS 'MODULE_PATHNAME' 1495 LANGUAGE C IMMUTABLE STRICT; 1496 1497CREATE OR REPLACE FUNCTION gbfp_decompress(internal) 1498 RETURNS internal 1499 AS 'MODULE_PATHNAME' 1500 LANGUAGE C IMMUTABLE STRICT; 1501 1502CREATE OR REPLACE FUNCTION gbfp_penalty(internal,internal,internal) 1503 RETURNS internal 1504 AS 'MODULE_PATHNAME' 1505 LANGUAGE C IMMUTABLE STRICT; 1506 1507CREATE OR REPLACE FUNCTION gbfp_picksplit(internal, internal) 1508 RETURNS internal 1509 AS 'MODULE_PATHNAME' 1510 LANGUAGE C IMMUTABLE STRICT; 1511 1512CREATE OR REPLACE FUNCTION gbfp_same(internal, internal, internal) 1513 RETURNS internal 1514 AS 'MODULE_PATHNAME' 1515 LANGUAGE C IMMUTABLE STRICT; 1516 1517CREATE OR REPLACE FUNCTION gbfp_distance(internal, bytea, smallint, oid) 1518 RETURNS float8 1519 AS 'MODULE_PATHNAME' 1520 LANGUAGE C STABLE STRICT; 1521 1522CREATE OR REPLACE FUNCTION gbfp_fetch(internal) 1523 RETURNS internal 1524 AS 'MODULE_PATHNAME' 1525 LANGUAGE C IMMUTABLE STRICT; 1526 1527-- Support functions for sfp gist 1528 1529CREATE OR REPLACE FUNCTION gsfp_consistent(bytea,internal,int4) 1530 RETURNS bool 1531 AS 'MODULE_PATHNAME' 1532 LANGUAGE C IMMUTABLE; 1533 1534CREATE OR REPLACE FUNCTION gsfp_compress(internal) 1535 RETURNS internal 1536 AS 'MODULE_PATHNAME' 1537 LANGUAGE C IMMUTABLE; 1538 1539 1540-- Support functions for low sfp gist 1541 1542CREATE OR REPLACE FUNCTION gslfp_consistent(bytea,internal,int4) 1543 RETURNS bool 1544 AS 'MODULE_PATHNAME' 1545 LANGUAGE C IMMUTABLE; 1546 1547CREATE OR REPLACE FUNCTION gslfp_compress(internal) 1548 RETURNS internal 1549 AS 'MODULE_PATHNAME' 1550 LANGUAGE C IMMUTABLE; 1551 1552CREATE OR REPLACE FUNCTION gslfp_decompress(internal) 1553 RETURNS internal 1554 AS 'MODULE_PATHNAME' 1555 LANGUAGE C IMMUTABLE; 1556 1557CREATE OR REPLACE FUNCTION gslfp_penalty(internal,internal,internal) 1558 RETURNS internal 1559 AS 'MODULE_PATHNAME' 1560 LANGUAGE C STRICT IMMUTABLE; 1561 1562CREATE OR REPLACE FUNCTION gslfp_picksplit(internal, internal) 1563 RETURNS internal 1564 AS 'MODULE_PATHNAME' 1565 LANGUAGE C IMMUTABLE; 1566 1567CREATE OR REPLACE FUNCTION gslfp_union(bytea, internal) 1568 RETURNS _int4 1569 AS 'MODULE_PATHNAME' 1570 LANGUAGE C IMMUTABLE; 1571 1572CREATE OR REPLACE FUNCTION gslfp_same(bytea, bytea, internal) 1573 RETURNS internal 1574 AS 'MODULE_PATHNAME' 1575 LANGUAGE C IMMUTABLE; 1576 1577 1578-- Support functions for reaction gist 1579 1580CREATE OR REPLACE FUNCTION greaction_consistent(bytea,internal,int4) 1581 RETURNS bool 1582 AS 'MODULE_PATHNAME' 1583 LANGUAGE C IMMUTABLE; 1584 1585CREATE OR REPLACE FUNCTION greaction_compress(internal) 1586 RETURNS internal 1587 AS 'MODULE_PATHNAME' 1588 LANGUAGE C IMMUTABLE; 1589 1590 1591-- Operator classes for gist 1592 1593CREATE OPERATOR CLASS gist_mol_ops 1594DEFAULT FOR TYPE mol USING gist 1595AS 1596 OPERATOR 3 @> (mol, mol), 1597 OPERATOR 4 <@ (mol, mol), 1598 OPERATOR 3 @> (mol, qmol), 1599 OPERATOR 4 <@ (qmol, mol), 1600 OPERATOR 6 @= (mol, mol), 1601 FUNCTION 1 gmol_consistent (bytea, internal, int4), 1602 FUNCTION 2 gmol_union (bytea, internal), 1603 FUNCTION 3 gmol_compress (internal), 1604 FUNCTION 4 gmol_decompress (internal), 1605 FUNCTION 5 gmol_penalty (internal, internal, internal), 1606 FUNCTION 6 gmol_picksplit (internal, internal), 1607 FUNCTION 7 gmol_same (bytea, bytea, internal), 1608STORAGE bytea; 1609 1610CREATE OPERATOR CLASS gist_bfp_ops 1611DEFAULT FOR TYPE bfp USING gist 1612AS 1613 OPERATOR 1 % (bfp, bfp), 1614 OPERATOR 2 # (bfp, bfp), 1615 OPERATOR 3 <%> FOR ORDER BY pg_catalog.float_ops, 1616 OPERATOR 4 <#> FOR ORDER BY pg_catalog.float_ops, 1617 FUNCTION 1 gbfp_consistent (internal, bytea, smallint, oid, internal), 1618 FUNCTION 2 gbfp_union (internal, internal), 1619 FUNCTION 3 gbfp_compress (internal), 1620 FUNCTION 4 gbfp_decompress (internal), 1621 FUNCTION 5 gbfp_penalty (internal, internal, internal), 1622 FUNCTION 6 gbfp_picksplit (internal, internal), 1623 FUNCTION 7 gbfp_same (internal, internal, internal), 1624 FUNCTION 8 (bfp, bfp) gbfp_distance(internal, bytea, smallint, oid), 1625 @RDKIT_PG_BFP_GIST_FETCH@ 1626STORAGE bytea; 1627 1628CREATE OPERATOR CLASS gist_sfp_ops 1629DEFAULT FOR TYPE sfp USING gist 1630AS 1631 OPERATOR 1 % (sfp, sfp), 1632 OPERATOR 2 # (sfp, sfp), 1633 FUNCTION 1 gsfp_consistent (bytea, internal, int4), 1634 FUNCTION 2 gmol_union (bytea, internal), 1635 FUNCTION 3 gsfp_compress (internal), 1636 FUNCTION 4 gmol_decompress (internal), 1637 FUNCTION 5 gmol_penalty (internal, internal, internal), 1638 FUNCTION 6 gmol_picksplit (internal, internal), 1639 FUNCTION 7 gmol_same (bytea, bytea, internal), 1640STORAGE bytea; 1641 1642CREATE OPERATOR CLASS gist_sfp_low_ops 1643FOR TYPE sfp USING gist 1644AS 1645 OPERATOR 1 % (sfp, sfp), 1646 OPERATOR 2 # (sfp, sfp), 1647 FUNCTION 1 gslfp_consistent (bytea, internal, int4), 1648 FUNCTION 2 gslfp_union (bytea, internal), 1649 FUNCTION 3 gslfp_compress (internal), 1650 FUNCTION 4 gslfp_decompress (internal), 1651 FUNCTION 5 gslfp_penalty (internal, internal, internal), 1652 FUNCTION 6 gslfp_picksplit (internal, internal), 1653 FUNCTION 7 gslfp_same (bytea, bytea, internal), 1654STORAGE bytea; 1655 1656CREATE OPERATOR CLASS gist_reaction_ops 1657DEFAULT FOR TYPE reaction USING gist 1658AS 1659 OPERATOR 3 @> (reaction, reaction), 1660 OPERATOR 4 <@ (reaction, reaction), 1661 OPERATOR 6 @= (reaction, reaction), 1662 OPERATOR 7 ?> (reaction, reaction), 1663 OPERATOR 8 ?< (reaction, reaction), 1664 FUNCTION 1 greaction_consistent (bytea, internal, int4), 1665 FUNCTION 2 gmol_union (bytea, internal), 1666 FUNCTION 3 greaction_compress (internal), 1667 FUNCTION 4 gmol_decompress (internal), 1668 FUNCTION 5 gmol_penalty (internal, internal, internal), 1669 FUNCTION 6 gmol_picksplit (internal, internal), 1670 FUNCTION 7 gmol_same (bytea, bytea, internal), 1671STORAGE bytea; 1672 1673 1674-- Support functions for bfp gin 1675 1676CREATE FUNCTION gin_bfp_extract_value(bfp, internal) 1677RETURNS internal 1678AS 'MODULE_PATHNAME' 1679LANGUAGE C IMMUTABLE STRICT; 1680 1681CREATE FUNCTION gin_bfp_extract_query(bfp, internal, int2, internal, internal, internal, internal) 1682RETURNS internal 1683AS 'MODULE_PATHNAME' 1684LANGUAGE C IMMUTABLE STRICT; 1685 1686CREATE FUNCTION gin_bfp_consistent(internal, int2, bfp, int4, internal, internal, internal, internal) 1687RETURNS bool 1688AS 'MODULE_PATHNAME' 1689LANGUAGE C STABLE STRICT; 1690 1691CREATE FUNCTION gin_bfp_triconsistent(internal, int2, bfp, int4, internal, internal, internal) 1692RETURNS bool 1693AS 'MODULE_PATHNAME' 1694LANGUAGE C STABLE STRICT; 1695 1696-- Operator classes for gin 1697 1698CREATE OPERATOR CLASS gin_bfp_ops 1699DEFAULT FOR TYPE bfp USING gin 1700AS 1701 OPERATOR 1 % (bfp, bfp), 1702 OPERATOR 2 # (bfp, bfp), 1703 FUNCTION 1 btint4cmp (int4, int4), 1704 FUNCTION 2 gin_bfp_extract_value(bfp, internal), 1705 FUNCTION 3 gin_bfp_extract_query(bfp, internal, int2, internal, internal, internal, internal), 1706 FUNCTION 4 gin_bfp_consistent(internal, int2, bfp, int4, internal, internal, internal, internal), 1707 @RDKIT_GIN_BFP_TRICONSISTENT@ 1708 STORAGE int4; 1709 1710-- 1711 1712CREATE OR REPLACE FUNCTION has_reaction_substructmatch(queryreaction char, tablename regclass, columnname text) 1713 RETURNS SETOF reaction AS 1714$BODY$ 1715DECLARE 1716 nof_all_entries real; 1717 nof_index_matches real; 1718 match_ratio real; 1719BEGIN 1720 SET enable_seqscan=off; 1721 SET enable_bitmapscan=on; 1722 SET enable_indexscan=on; 1723 RAISE NOTICE 'Your query: %', queryreaction; 1724 EXECUTE 'SELECT COUNT(*) FROM ' || tablename INTO nof_all_entries; 1725 RAISE NOTICE 'Number of reactions in table: %', nof_all_entries; 1726 EXECUTE 'SELECT COUNT(*) FROM ' || tablename || ' WHERE ' || quote_ident(columnname) || '?>' || quote_literal(queryreaction) INTO nof_index_matches; 1727 RAISE NOTICE 'Number of matched reactions in the index: %', nof_index_matches; 1728 match_ratio := nof_index_matches/nof_all_entries; 1729 RAISE NOTICE 'Match ratio: %', match_ratio; 1730 IF match_ratio > 0.7 THEN 1731 SET enable_seqscan=on; 1732 SET enable_bitmapscan=off; 1733 SET enable_indexscan=off; 1734 IF match_ratio >= 1.0 THEN 1735 RAISE NOTICE 'Your query matches % percent of the index. You are sure you already have build an index?', match_ratio*100.0; 1736 END IF; 1737 RAISE NOTICE 'Your query matches % percent of the index. Executing strategy: SequentialScan. Starting substructure matching..', match_ratio*100.0; 1738 ELSE 1739 SET enable_seqscan=off; 1740 SET enable_bitmapscan=on; 1741 SET enable_indexscan=on; 1742 RAISE NOTICE 'Executing strategy: IndexScan and BitMapHeapScan. % matches have to be rechecked. Starting substructure matching...', nof_index_matches; 1743 END IF; 1744 RETURN QUERY EXECUTE 'SELECT * FROM ' || tablename || ' WHERE ' || quote_ident(columnname) || '@>' || quote_literal(queryreaction); 1745END 1746$BODY$ 1747LANGUAGE plpgsql; 1748 1749 1750/*** FMCS ***/ 1751 1752CREATE OR REPLACE FUNCTION fmcs_smiles(cstring, cstring) -- find MCS in 'space' separated SMILES string 1753 RETURNS cstring 1754@RDKIT_PARALLEL_SAFE@ 1755 AS 'MODULE_PATHNAME' 1756 LANGUAGE C STRICT IMMUTABLE; 1757 1758CREATE OR REPLACE FUNCTION fmcs_smiles(text, text) -- find MCS in 'space' separated SMILES string 1759 RETURNS text 1760@RDKIT_PARALLEL_SAFE@ 1761 AS 'SELECT CAST( fmcs_smiles(CAST($1 AS CSTRING), CAST($2 AS CSTRING)) AS text);' 1762 LANGUAGE SQL IMMUTABLE; 1763 1764CREATE OR REPLACE FUNCTION fmcs_smiles(text) -- find MCS in 'space' separated SMILES string WITH default params 1765 RETURNS text 1766@RDKIT_PARALLEL_SAFE@ 1767 AS 'SELECT CAST( fmcs_smiles(CAST($1 AS CSTRING), CAST('''' AS CSTRING)) AS text);' 1768 LANGUAGE SQL IMMUTABLE; 1769 1770--// fmcs_smiles aggregate function 1771CREATE OR REPLACE FUNCTION fmcs_smiles_transition(text, text) 1772 RETURNS text -- state_data_type 1773 AS 'MODULE_PATHNAME' 1774@RDKIT_PARALLEL_SAFE@ 1775 LANGUAGE C STRICT IMMUTABLE; 1776CREATE AGGREGATE fmcs ( 1777 BASETYPE = text, -- item type 1778 SFUNC = fmcs_smiles_transition, -- transition function 1779 STYPE = text, -- state type 1780 FINALFUNC = fmcs_smiles -- final calculation function 1781); 1782 1783--// ========================================== 1784--// fmcs_mols aggregate function 1785CREATE OR REPLACE FUNCTION fmcs_mols(internal) 1786 RETURNS text -- state_data_type 1787@RDKIT_PARALLEL_SAFE@ 1788 AS 'MODULE_PATHNAME' 1789 LANGUAGE C STRICT IMMUTABLE; 1790CREATE OR REPLACE FUNCTION fmcs_mol_transition(internal, mol) 1791 RETURNS internal -- state_data_type 1792@RDKIT_PARALLEL_SAFE@ 1793 AS 'MODULE_PATHNAME' 1794 LANGUAGE C IMMUTABLE; 1795CREATE AGGREGATE fmcs ( 1796 BASETYPE = mol, -- item type 1797 SFUNC = fmcs_mol_transition, -- transition function 1798 STYPE = internal, -- state type 1799 FINALFUNC = fmcs_mols -- final calculation function 1800); 1801--// ========================================== 1802 1803/* 1804use: 1805SELECT fmcs_smiles(CAST(str AS CSTRING), CAST('{"Timeout": 7}' AS CSTRING)) FROM (SELECT string_agg(str,' ') AS str FROM testsmiles) AS str; 1806SELECT fmcs_smiles(str, '{"Timeout": 7}') FROM (SELECT string_agg(str,' ') AS str FROM testsmiles) AS str; 1807SELECT fmcs_smiles(str) FROM (SELECT string_agg(str,' ') AS str FROM testsmiles) AS str; 1808SELECT fmcs_smiles(str) FROM (SELECT string_agg(str,' ') AS str FROM testsmiles GROUP BY gid) AS str; 1809------ aggregate function ------- 1810select fmcs(str) from testsmiles group by gid; 1811select fmcs(mol_from_smiles(CAST(str AS CSTRING))) from testsmiles group by gid; 1812 1813where testsmiles is a table like: 1814DROP TABLE testsmiles; 1815CREATE TABLE testsmiles ( 1816 gid int NOT NULL, -- Group ID 1817 str VARCHAR(16) NOT NULL -- mol SMILES 1818); 1819INSERT INTO testsmiles (gid,str) VALUES (1,'CCC'); 1820INSERT INTO testsmiles (gid,str) VALUES (1,'CCCC'); 1821INSERT INTO testsmiles (gid,str) VALUES (2,'CCCNC'); 1822INSERT INTO testsmiles (gid,str) VALUES (2,'CNCCC'); 1823SELECT * FROM testsmiles; 1824 1825result is: 1826 fmcs_smiles 1827---------------- 1828 [#6]-[#6]-[#6] 1829(1 row) 1830*/ 1831