Open-ILS/src/sql/Pg/008.schema.query.sql

   1 -- Script to create the query schema and the tables therein
   2
   3 BEGIN;
   4
   5 DROP SCHEMA IF EXISTS query CASCADE;
   6 CREATE SCHEMA query;
   7 COMMENT ON SCHEMA actor IS $$
   8 /*
   9  * Copyright (C) 2009  Equinox Software, Inc. / Georgia Public Library Service
  10  * Scott McKellar <scott@esilibrary.com>
  11  *
  12  * Schema: query
  13  *
  14  * Contains tables designed to represent user-defined queries for
  15  * reports and the like.
  16  *
  17  * ****
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License
  21  * as published by the Free Software Foundation; either version 2
  22  * of the License, or (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  */
  29 $$;
  30
  31 CREATE TABLE  query.stored_query (
  32         id            SERIAL         PRIMARY KEY,
  33         type          TEXT           NOT NULL CONSTRAINT query_type CHECK
  34                                      ( type IN ( 'SELECT', 'UNION', 'INTERSECT', 'EXCEPT' ) ),
  35         use_all       BOOLEAN        NOT NULL DEFAULT FALSE,
  36         use_distinct  BOOLEAN        NOT NULL DEFAULT FALSE,
  37         from_clause   INT            NOT NULL , --REFERENCES query.from_clause
  38         where_clause  INT            , --REFERENCES query.expression
  39                                      --DEFERRABLE INITIALLY DEFERRED,
  40         having_clause INT            --REFERENCES query.expression
  41                                      --DEFERRABLE INITIALLY DEFERRED
  42 );
  43
  44 -- (Foreign keys to be defined later after other tables are created)
  45
  46 CREATE TABLE query.query_sequence (
  47         id              SERIAL            PRIMARY KEY,
  48         parent_query    INT               NOT NULL
  49                                           REFERENCES query.stored_query
  50                                                                           ON DELETE CASCADE
  51                                                                           DEFERRABLE INITIALLY DEFERRED,
  52         seq_no          INT               NOT NULL,
  53         child_query     INT               NOT NULL
  54                                           REFERENCES query.stored_query
  55                                                                           ON DELETE CASCADE
  56                                                                           DEFERRABLE INITIALLY DEFERRED,
  57         CONSTRAINT query_query_seq UNIQUE( parent_query, seq_no )
  58 );
  59
  60 CREATE TABLE query.datatype (
  61         id              SERIAL            PRIMARY KEY,
  62         datatype_name   TEXT              NOT NULL UNIQUE,
  63         is_numeric      BOOL              NOT NULL DEFAULT FALSE,
  64         is_composite    BOOL              NOT NULL DEFAULT FALSE,
  65         CONSTRAINT qdt_comp_not_num CHECK
  66         ( is_numeric IS FALSE OR is_composite IS FALSE )
  67 );
  68
  69 CREATE TABLE query.subfield (
  70         id              SERIAL            PRIMARY KEY,
  71         composite_type  INT               NOT NULL
  72                                           REFERENCES query.datatype(id)
  73                                           ON DELETE CASCADE
  74                                           DEFERRABLE INITIALLY DEFERRED,
  75         seq_no          INT               NOT NULL
  76                                           CONSTRAINT qsf_pos_seq_no
  77                                           CHECK( seq_no > 0 ),
  78         subfield_type   INT               NOT NULL
  79                                           REFERENCES query.datatype(id)
  80                                           DEFERRABLE INITIALLY DEFERRED,
  81         CONSTRAINT qsf_datatype_seq_no UNIQUE (composite_type, seq_no)
  82 );
  83
  84 CREATE TABLE query.function_sig (
  85         id              SERIAL            PRIMARY KEY,
  86         function_name   TEXT              NOT NULL,
  87         return_type     INT               REFERENCES query.datatype(id)
  88                                           DEFERRABLE INITIALLY DEFERRED,
  89         is_aggregate    BOOL              NOT NULL DEFAULT FALSE,
  90         CONSTRAINT qfd_rtn_or_aggr CHECK
  91         ( return_type IS NULL OR is_aggregate = FALSE )
  92 );
  93
  94 CREATE INDEX query_function_sig_name_idx
  95         ON query.function_sig (function_name);
  96
  97 CREATE TABLE query.function_param_def (
  98         id              SERIAL            PRIMARY KEY,
  99         function_id     INT               NOT NULL
 100                                           REFERENCES query.function_sig( id )
 101                                           ON DELETE CASCADE
 102                                           DEFERRABLE INITIALLY DEFERRED,
 103         seq_no          INT               NOT NULL
 104                                           CONSTRAINT qfpd_pos_seq_no CHECK
 105                                           ( seq_no > 0 ),
 106         datatype        INT               NOT NULL
 107                                           REFERENCES query.datatype( id )
 108                                           DEFERRABLE INITIALLY DEFERRED,
 109         CONSTRAINT qfpd_function_param_seq UNIQUE (function_id, seq_no)
 110 );
 111
 112 CREATE TABLE query.expression (
 113         id            SERIAL        PRIMARY KEY,
 114         type          TEXT          NOT NULL CONSTRAINT predicate_type CHECK
 115                                     ( type IN (
 116                                         'xbet',    -- between
 117                                                                         'xbool',   -- boolean
 118                                         'xcase',   -- case
 119                                                                         'xcast',   -- cast
 120                                                                         'xcol',    -- column
 121                                                                         'xex',     -- exists
 122                                                                         'xfld',    -- field
 123                                                                         'xfunc',   -- function
 124                                                                         'xin',     -- in
 125                                                                         'xnbet',   -- not between
 126                                         'xnex',    -- not exists
 127                                                                         'xnin',    -- not in
 128                                         'xnull',   -- null
 129                                                                         'xnum',    -- number
 130                                                                         'xop',     -- operator
 131                                                                         'xstr',    -- string
 132                                                 'xsubq'    -- subquery
 133                                                                 ) ),
 134         parenthesize  BOOL          NOT NULL DEFAULT FALSE,
 135         parent_expr   INT           REFERENCES query.expression
 136                                     ON DELETE CASCADE
 137                                     DEFERRABLE INITIALLY DEFERRED,
 138         seq_no        INT           NOT NULL DEFAULT 1,
 139         literal       TEXT,
 140         table_alias   TEXT,
 141         column_name   TEXT,
 142         left_operand  INT           REFERENCES query.expression
 143                                     DEFERRABLE INITIALLY DEFERRED,
 144         operator      TEXT,
 145         right_operand INT           REFERENCES query.expression
 146                                     DEFERRABLE INITIALLY DEFERRED,
 147         function_id   INT           REFERENCES query.function_sig
 148                                     DEFERRABLE INITIALLY DEFERRED,
 149         subquery      INT           REFERENCES query.stored_query
 150                                     DEFERRABLE INITIALLY DEFERRED,
 151         cast_type     INT           REFERENCES query.datatype
 152                                     DEFERRABLE INITIALLY DEFERRED
 153 );
 154
 155 CREATE UNIQUE INDEX query_expr_parent_seq
 156         ON query.expression( parent_expr, seq_no )
 157         WHERE parent_expr IS NOT NULL;
 158
 159 -- Due to some circular references, the following foreign key definitions
 160 -- had to be deferred until query.expression existed:
 161
 162 ALTER TABLE query.stored_query
 163         ADD FOREIGN KEY ( where_clause )
 164         REFERENCES query.expression( id )
 165         DEFERRABLE INITIALLY DEFERRED;
 166
 167 ALTER TABLE query.stored_query
 168         ADD FOREIGN KEY ( having_clause )
 169         REFERENCES query.expression( id )
 170         DEFERRABLE INITIALLY DEFERRED;
 171
 172 CREATE TABLE query.case_branch (
 173         id            SERIAL        PRIMARY KEY,
 174         parent_expr   INT           NOT NULL REFERENCES query.expression
 175                                     ON DELETE CASCADE
 176                                     DEFERRABLE INITIALLY DEFERRED,
 177         seq_no        INT           NOT NULL,
 178         condition     INT           REFERENCES query.expression
 179                                     DEFERRABLE INITIALLY DEFERRED,
 180         result        INT           NOT NULL REFERENCES query.expression
 181                                     DEFERRABLE INITIALLY DEFERRED,
 182         CONSTRAINT case_branch_parent_seq UNIQUE (parent_expr, seq_no)
 183 );
 184
 185 CREATE TABLE query.from_relation (
 186         id               SERIAL        PRIMARY KEY,
 187         type             TEXT          NOT NULL CONSTRAINT relation_type CHECK (
 188                                            type IN ( 'RELATION', 'SUBQUERY', 'FUNCTION' ) ),
 189         table_name       TEXT,
 190         class_name       TEXT,
 191         subquery         INT           REFERENCES query.stored_query,
 192         function_call    INT           REFERENCES query.expression,
 193         table_alias      TEXT          NOT NULL,
 194         parent_relation  INT           REFERENCES query.from_relation
 195                                        ON DELETE CASCADE
 196                                        DEFERRABLE INITIALLY DEFERRED,
 197         seq_no           INT           NOT NULL DEFAULT 1,
 198         join_type        TEXT          CONSTRAINT good_join_type CHECK (
 199                                            join_type IS NULL OR join_type IN
 200                                            ( 'INNER', 'LEFT', 'RIGHT', 'FULL' )
 201                                        ),
 202         on_clause        INT           REFERENCES query.expression
 203                                        DEFERRABLE INITIALLY DEFERRED,
 204         CONSTRAINT join_or_core CHECK (
 205             ( parent_relation IS NULL AND join_type IS NULL
 206               AND on_clause IS NULL and table_alias IS NULL )
 207             OR
 208             ( parent_relation IS NOT NULL AND join_type IS NOT NULL
 209               AND on_clause IS NOT NULL )
 210         )
 211 );
 212
 213 CREATE UNIQUE INDEX from_parent_seq
 214         ON query.from_relation( parent_relation, seq_no )
 215         WHERE parent_relation IS NOT NULL;
 216
 217 -- The following foreign key had to be deferred until
 218 -- query.from_relation existed
 219
 220 ALTER TABLE query.stored_query
 221         ADD FOREIGN KEY (from_clause)
 222         REFERENCES query.from_relation
 223         DEFERRABLE INITIALLY DEFERRED;
 224
 225 CREATE TABLE query.record_column (
 226         id            SERIAL            PRIMARY KEY,
 227         from_relation INT               NOT NULL REFERENCES query.from_relation
 228                                         ON DELETE CASCADE
 229                                         DEFERRABLE INITIALLY DEFERRED,
 230         seq_no        INT               NOT NULL,
 231         column_name   TEXT              NOT NULL,
 232     column_type   INT               NOT NULL REFERENCES query.datatype
 233                                     ON DELETE CASCADE
 234                                     DEFERRABLE INITIALLY DEFERRED,
 235         CONSTRAINT column_sequence UNIQUE (from_relation, seq_no)
 236 );
 237
 238 CREATE TABLE query.select_item (
 239         id               SERIAL         PRIMARY KEY,
 240         stored_query     INT            NOT NULL REFERENCES query.stored_query
 241                                         ON DELETE CASCADE
 242                                         DEFERRABLE INITIALLY DEFERRED,
 243         seq_no           INT            NOT NULL,
 244         expression       INT            NOT NULL REFERENCES query.expression
 245                                         DEFERRABLE INITIALLY DEFERRED,
 246         column_alias     TEXT,
 247         grouped_by       BOOL           NOT NULL DEFAULT FALSE,
 248         CONSTRAINT select_sequence UNIQUE( stored_query, seq_no )
 249 );
 250
 251 CREATE TABLE query.order_by_item (
 252         id               SERIAL         PRIMARY KEY,
 253         stored_query     INT            NOT NULL REFERENCES query.stored_query
 254                                         ON DELETE CASCADE
 255                                         DEFERRABLE INITIALLY DEFERRED,
 256         seq_no           INT            NOT NULL,
 257         expression       INT            NOT NULL REFERENCES query.expression
 258                                         ON DELETE CASCADE
 259                                         DEFERRABLE INITIALLY DEFERRED,
 260         CONSTRAINT order_by_sequence UNIQUE( stored_query, seq_no )
 261 );
 262
 263 -- Create updatable views -------------------------------------------
 264
 265 -- Create updatable view for BETWEEN expressions
 266
 267 CREATE OR REPLACE VIEW query.expr_xbet AS
 268     SELECT
 269                 id,
 270                 parenthesize,
 271                 parent_expr,
 272                 seq_no
 273     FROM
 274         query.expression
 275     WHERE
 276         type = 'xbet';
 277
 278 CREATE OR REPLACE RULE query_expr_xbet_insert_rule AS
 279     ON INSERT TO query.expr_xbet
 280     DO INSTEAD
 281     INSERT INTO query.expression (
 282                 id,
 283                 type,
 284                 parenthesize,
 285                 parent_expr,
 286                 seq_no
 287     ) VALUES (
 288         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 289         'xbet',
 290         COALESCE(NEW.parenthesize, FALSE),
 291         NEW.parent_expr,
 292         COALESCE(NEW.seq_no, 1)
 293     );
 294
 295 CREATE OR REPLACE RULE query_expr_xbet_update_rule AS
 296     ON UPDATE TO query.expr_xbet
 297     DO INSTEAD
 298     UPDATE query.expression SET
 299         id = NEW.id,
 300         parenthesize = NEW.parenthesize,
 301         parent_expr = NEW.parent_expr,
 302         seq_no = NEW.seq_no
 303     WHERE
 304         id = OLD.id;
 305
 306 CREATE OR REPLACE RULE query_expr_xbet_delete_rule AS
 307     ON DELETE TO query.expr_xbet
 308     DO INSTEAD
 309     DELETE FROM query.expression WHERE id = OLD.id;
 310
 311 -- Create updatable view for boolean expressions
 312
 313 CREATE OR REPLACE VIEW query.expr_xbool AS
 314     SELECT
 315                 id,
 316                 parenthesize,
 317                 parent_expr,
 318                 seq_no,
 319                 literal
 320     FROM
 321         query.expression
 322     WHERE
 323         type = 'xbool';
 324
 325 CREATE OR REPLACE RULE query_expr_xbool_insert_rule AS
 326     ON INSERT TO query.expr_xbool
 327     DO INSTEAD
 328     INSERT INTO query.expression (
 329                 id,
 330                 type,
 331                 parenthesize,
 332                 parent_expr,
 333                 seq_no,
 334                 literal
 335     ) VALUES (
 336         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 337         'xbool',
 338         COALESCE(NEW.parenthesize, FALSE),
 339         NEW.parent_expr,
 340         COALESCE(NEW.seq_no, 1),
 341         NEW.literal
 342     );
 343
 344 CREATE OR REPLACE RULE query_expr_xbool_update_rule AS
 345     ON UPDATE TO query.expr_xbool
 346     DO INSTEAD
 347     UPDATE query.expression SET
 348         id = NEW.id,
 349         parenthesize = NEW.parenthesize,
 350         parent_expr = NEW.parent_expr,
 351         seq_no = NEW.seq_no,
 352         literal = NEW.literal
 353     WHERE
 354         id = OLD.id;
 355
 356 CREATE OR REPLACE RULE query_expr_xbool_delete_rule AS
 357     ON DELETE TO query.expr_xbool
 358     DO INSTEAD
 359     DELETE FROM query.expression WHERE id = OLD.id;
 360
 361 -- Create updatable view for CASE expressions
 362
 363 CREATE OR REPLACE VIEW query.expr_xcase AS
 364     SELECT
 365                 id,
 366                 parenthesize,
 367                 parent_expr,
 368                 seq_no
 369     FROM
 370         query.expression
 371     WHERE
 372         type = 'xcase';
 373
 374 CREATE OR REPLACE RULE query_expr_xcase_insert_rule AS
 375     ON INSERT TO query.expr_xcase
 376     DO INSTEAD
 377     INSERT INTO query.expression (
 378                 id,
 379                 type,
 380                 parenthesize,
 381                 parent_expr,
 382                 seq_no
 383     ) VALUES (
 384         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 385         'xcase',
 386         COALESCE(NEW.parenthesize, FALSE),
 387         NEW.parent_expr,
 388         COALESCE(NEW.seq_no, 1)
 389     );
 390
 391 CREATE OR REPLACE RULE query_expr_xcase_update_rule AS
 392     ON UPDATE TO query.expr_xcase
 393     DO INSTEAD
 394     UPDATE query.expression SET
 395         id = NEW.id,
 396         parenthesize = NEW.parenthesize,
 397         parent_expr = NEW.parent_expr,
 398         seq_no = NEW.seq_no
 399     WHERE
 400         id = OLD.id;
 401
 402 CREATE OR REPLACE RULE query_expr_xcase_delete_rule AS
 403     ON DELETE TO query.expr_xcase
 404     DO INSTEAD
 405     DELETE FROM query.expression WHERE id = OLD.id;
 406
 407 -- Create updatable view for cast expressions
 408
 409 CREATE OR REPLACE VIEW query.expr_xcast AS
 410     SELECT
 411                 id,
 412                 parenthesize,
 413                 parent_expr,
 414                 seq_no,
 415                 left_operand,
 416                 cast_type
 417     FROM
 418         query.expression
 419     WHERE
 420         type = 'xcast';
 421
 422 CREATE OR REPLACE RULE query_expr_xcast_insert_rule AS
 423     ON INSERT TO query.expr_xcast
 424     DO INSTEAD
 425     INSERT INTO query.expression (
 426                 id,
 427                 type,
 428                 parenthesize,
 429                 parent_expr,
 430                 seq_no,
 431                 left_operand,
 432                 cast_type
 433     ) VALUES (
 434         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 435         'xcast',
 436         COALESCE(NEW.parenthesize, FALSE),
 437         NEW.parent_expr,
 438         COALESCE(NEW.seq_no, 1),
 439                 NEW.left_operand,
 440                 NEW.cast_type
 441     );
 442
 443 CREATE OR REPLACE RULE query_expr_xcast_update_rule AS
 444     ON UPDATE TO query.expr_xcast
 445     DO INSTEAD
 446     UPDATE query.expression SET
 447         id = NEW.id,
 448         parenthesize = NEW.parenthesize,
 449         parent_expr = NEW.parent_expr,
 450         seq_no = NEW.seq_no,
 451                 left_operand = NEW.left_operand,
 452                 cast_type = NEW.cast_type
 453     WHERE
 454         id = OLD.id;
 455
 456 CREATE OR REPLACE RULE query_expr_xcast_delete_rule AS
 457     ON DELETE TO query.expr_xcast
 458     DO INSTEAD
 459     DELETE FROM query.expression WHERE id = OLD.id;
 460
 461 -- Create updatable view for column expressions
 462
 463 CREATE OR REPLACE VIEW query.expr_xcol AS
 464     SELECT
 465                 id,
 466                 parenthesize,
 467                 parent_expr,
 468                 seq_no,
 469                 table_alias,
 470                 column_name
 471     FROM
 472         query.expression
 473     WHERE
 474         type = 'xcol';
 475
 476 CREATE OR REPLACE RULE query_expr_xcol_insert_rule AS
 477     ON INSERT TO query.expr_xcol
 478     DO INSTEAD
 479     INSERT INTO query.expression (
 480                 id,
 481                 type,
 482                 parenthesize,
 483                 parent_expr,
 484                 seq_no,
 485                 table_alias,
 486                 column_name
 487     ) VALUES (
 488         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 489         'xcol',
 490         COALESCE(NEW.parenthesize, FALSE),
 491         NEW.parent_expr,
 492         COALESCE(NEW.seq_no, 1),
 493                 NEW.table_alias,
 494                 NEW.column_name
 495     );
 496
 497 CREATE OR REPLACE RULE query_expr_xcol_update_rule AS
 498     ON UPDATE TO query.expr_xcol
 499     DO INSTEAD
 500     UPDATE query.expression SET
 501         id = NEW.id,
 502         parenthesize = NEW.parenthesize,
 503         parent_expr = NEW.parent_expr,
 504         seq_no = NEW.seq_no,
 505                 table_alias = NEW.table_alias,
 506                 column_name = NEW.column_name
 507     WHERE
 508         id = OLD.id;
 509
 510 CREATE OR REPLACE RULE query_expr_xcol_delete_rule AS
 511     ON DELETE TO query.expr_xcol
 512     DO INSTEAD
 513     DELETE FROM query.expression WHERE id = OLD.id;
 514
 515 -- Create updatable view for EXISTS expressions
 516
 517 CREATE OR REPLACE VIEW query.expr_xex AS
 518     SELECT
 519                 id,
 520                 parenthesize,
 521                 parent_expr,
 522                 seq_no,
 523                 subquery
 524     FROM
 525         query.expression
 526     WHERE
 527         type = 'xex';
 528
 529 CREATE OR REPLACE RULE query_expr_xex_insert_rule AS
 530     ON INSERT TO query.expr_xex
 531     DO INSTEAD
 532     INSERT INTO query.expression (
 533                 id,
 534                 type,
 535                 parenthesize,
 536                 parent_expr,
 537                 seq_no,
 538                 subquery
 539     ) VALUES (
 540         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 541         'xex',
 542         COALESCE(NEW.parenthesize, FALSE),
 543         NEW.parent_expr,
 544         COALESCE(NEW.seq_no, 1),
 545                 NEW.subquery
 546     );
 547
 548 CREATE OR REPLACE RULE query_expr_xex_update_rule AS
 549     ON UPDATE TO query.expr_xex
 550     DO INSTEAD
 551     UPDATE query.expression SET
 552         id = NEW.id,
 553         parenthesize = NEW.parenthesize,
 554         parent_expr = NEW.parent_expr,
 555         seq_no = NEW.seq_no,
 556                 subquery = NEW.subquery
 557     WHERE
 558         id = OLD.id;
 559
 560 CREATE OR REPLACE RULE query_expr_xex_delete_rule AS
 561     ON DELETE TO query.expr_xex
 562     DO INSTEAD
 563     DELETE FROM query.expression WHERE id = OLD.id;
 564
 565 -- Create updatable view for field expressions
 566
 567 CREATE OR REPLACE VIEW query.expr_xfld AS
 568     SELECT
 569                 id,
 570                 parenthesize,
 571                 parent_expr,
 572                 seq_no,
 573                 column_name,
 574                 left_operand
 575     FROM
 576         query.expression
 577     WHERE
 578         type = 'xfld';
 579
 580 CREATE OR REPLACE RULE query_expr_xfld_insert_rule AS
 581     ON INSERT TO query.expr_xfld
 582     DO INSTEAD
 583     INSERT INTO query.expression (
 584                 id,
 585                 type,
 586                 parenthesize,
 587                 parent_expr,
 588                 seq_no,
 589                 column_name,
 590                 left_operand
 591     ) VALUES (
 592         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 593         'xfld',
 594         COALESCE(NEW.parenthesize, FALSE),
 595         NEW.parent_expr,
 596         COALESCE(NEW.seq_no, 1),
 597                 NEW.column_name,
 598                 NEW.left_operand
 599     );
 600
 601 CREATE OR REPLACE RULE query_expr_xfld_update_rule AS
 602     ON UPDATE TO query.expr_xfld
 603     DO INSTEAD
 604     UPDATE query.expression SET
 605         id = NEW.id,
 606         parenthesize = NEW.parenthesize,
 607         parent_expr = NEW.parent_expr,
 608         seq_no = NEW.seq_no,
 609                 column_name = NEW.column_name,
 610                 left_operand = NEW.left_operand
 611     WHERE
 612         id = OLD.id;
 613
 614 CREATE OR REPLACE RULE query_expr_xfld_delete_rule AS
 615     ON DELETE TO query.expr_xfld
 616     DO INSTEAD
 617     DELETE FROM query.expression WHERE id = OLD.id;
 618
 619 -- Create updatable view for function call expressions
 620
 621 CREATE OR REPLACE VIEW query.expr_xfunc AS
 622     SELECT
 623                 id,
 624                 parenthesize,
 625                 parent_expr,
 626                 seq_no,
 627                 function_id
 628     FROM
 629         query.expression
 630     WHERE
 631         type = 'xfunc';
 632
 633 CREATE OR REPLACE RULE query_expr_xfunc_insert_rule AS
 634     ON INSERT TO query.expr_xfunc
 635     DO INSTEAD
 636     INSERT INTO query.expression (
 637                 id,
 638                 type,
 639                 parenthesize,
 640                 parent_expr,
 641                 seq_no,
 642                 function_id
 643     ) VALUES (
 644         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 645         'xfunc',
 646         COALESCE(NEW.parenthesize, FALSE),
 647         NEW.parent_expr,
 648         COALESCE(NEW.seq_no, 1),
 649                 NEW.function_id
 650     );
 651
 652 CREATE OR REPLACE RULE query_expr_xfunc_update_rule AS
 653     ON UPDATE TO query.expr_xfunc
 654     DO INSTEAD
 655     UPDATE query.expression SET
 656         id = NEW.id,
 657         parenthesize = NEW.parenthesize,
 658         parent_expr = NEW.parent_expr,
 659         seq_no = NEW.seq_no,
 660                 function_id = NEW.function_id
 661     WHERE
 662         id = OLD.id;
 663
 664 CREATE OR REPLACE RULE query_expr_xfunc_delete_rule AS
 665     ON DELETE TO query.expr_xfunc
 666     DO INSTEAD
 667     DELETE FROM query.expression WHERE id = OLD.id;
 668
 669 -- Create updatable view for IN expressions
 670
 671 CREATE OR REPLACE VIEW query.expr_xin AS
 672     SELECT
 673                 id,
 674                 parenthesize,
 675                 parent_expr,
 676                 seq_no,
 677                 subquery
 678     FROM
 679         query.expression
 680     WHERE
 681         type = 'xin';
 682
 683 CREATE OR REPLACE RULE query_expr_xin_insert_rule AS
 684     ON INSERT TO query.expr_xin
 685     DO INSTEAD
 686     INSERT INTO query.expression (
 687                 id,
 688                 type,
 689                 parenthesize,
 690                 parent_expr,
 691                 seq_no,
 692                 subquery
 693     ) VALUES (
 694         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 695         'xin',
 696         COALESCE(NEW.parenthesize, FALSE),
 697         NEW.parent_expr,
 698         COALESCE(NEW.seq_no, 1),
 699                 NEW.subquery
 700     );
 701
 702 CREATE OR REPLACE RULE query_expr_xin_update_rule AS
 703     ON UPDATE TO query.expr_xin
 704     DO INSTEAD
 705     UPDATE query.expression SET
 706         id = NEW.id,
 707         parenthesize = NEW.parenthesize,
 708         parent_expr = NEW.parent_expr,
 709         seq_no = NEW.seq_no,
 710                 subquery = NEW.subquery
 711     WHERE
 712         id = OLD.id;
 713
 714 CREATE OR REPLACE RULE query_expr_xin_delete_rule AS
 715     ON DELETE TO query.expr_xin
 716     DO INSTEAD
 717     DELETE FROM query.expression WHERE id = OLD.id;
 718
 719 -- Create updatable view for NOT BETWEEN expressions
 720
 721 CREATE OR REPLACE VIEW query.expr_xnbet AS
 722     SELECT
 723                 id,
 724                 parenthesize,
 725                 parent_expr,
 726                 seq_no
 727     FROM
 728         query.expression
 729     WHERE
 730         type = 'xnbet';
 731
 732 CREATE OR REPLACE RULE query_expr_xnbet_insert_rule AS
 733     ON INSERT TO query.expr_xnbet
 734     DO INSTEAD
 735     INSERT INTO query.expression (
 736                 id,
 737                 type,
 738                 parenthesize,
 739                 parent_expr,
 740                 seq_no
 741     ) VALUES (
 742         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 743         'xnbet',
 744         COALESCE(NEW.parenthesize, FALSE),
 745         NEW.parent_expr,
 746         COALESCE(NEW.seq_no, 1)
 747     );
 748
 749 CREATE OR REPLACE RULE query_expr_xnbet_update_rule AS
 750     ON UPDATE TO query.expr_xnbet
 751     DO INSTEAD
 752     UPDATE query.expression SET
 753         id = NEW.id,
 754         parenthesize = NEW.parenthesize,
 755         parent_expr = NEW.parent_expr,
 756         seq_no = NEW.seq_no
 757     WHERE
 758         id = OLD.id;
 759
 760 CREATE OR REPLACE RULE query_expr_xnbet_delete_rule AS
 761     ON DELETE TO query.expr_xnbet
 762     DO INSTEAD
 763     DELETE FROM query.expression WHERE id = OLD.id;
 764
 765 -- Create updatable view for NOT EXISTS expressions
 766
 767 CREATE OR REPLACE VIEW query.expr_xnex AS
 768     SELECT
 769                 id,
 770                 parenthesize,
 771                 parent_expr,
 772                 seq_no,
 773                 subquery
 774     FROM
 775         query.expression
 776     WHERE
 777         type = 'xnex';
 778
 779 CREATE OR REPLACE RULE query_expr_xnex_insert_rule AS
 780     ON INSERT TO query.expr_xnex
 781     DO INSTEAD
 782     INSERT INTO query.expression (
 783                 id,
 784                 type,
 785                 parenthesize,
 786                 parent_expr,
 787                 seq_no,
 788                 subquery
 789     ) VALUES (
 790         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 791         'xnex',
 792         COALESCE(NEW.parenthesize, FALSE),
 793         NEW.parent_expr,
 794         COALESCE(NEW.seq_no, 1),
 795                 NEW.subquery
 796     );
 797
 798 CREATE OR REPLACE RULE query_expr_xnex_update_rule AS
 799     ON UPDATE TO query.expr_xnex
 800     DO INSTEAD
 801     UPDATE query.expression SET
 802         id = NEW.id,
 803         parenthesize = NEW.parenthesize,
 804         parent_expr = NEW.parent_expr,
 805         seq_no = NEW.seq_no,
 806                 subquery = NEW.subquery
 807     WHERE
 808         id = OLD.id;
 809
 810 CREATE OR REPLACE RULE query_expr_xnex_delete_rule AS
 811     ON DELETE TO query.expr_xnex
 812     DO INSTEAD
 813     DELETE FROM query.expression WHERE id = OLD.id;
 814
 815 -- Create updatable view for NOT IN expressions
 816
 817 CREATE OR REPLACE VIEW query.expr_xnin AS
 818     SELECT
 819                 id,
 820                 parenthesize,
 821                 parent_expr,
 822                 seq_no,
 823                 subquery
 824     FROM
 825         query.expression
 826     WHERE
 827         type = 'xnin';
 828
 829 CREATE OR REPLACE RULE query_expr_xnin_insert_rule AS
 830     ON INSERT TO query.expr_xnin
 831     DO INSTEAD
 832     INSERT INTO query.expression (
 833                 id,
 834                 type,
 835                 parenthesize,
 836                 parent_expr,
 837                 seq_no,
 838                 subquery
 839     ) VALUES (
 840         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 841         'xnin',
 842         COALESCE(NEW.parenthesize, FALSE),
 843         NEW.parent_expr,
 844         COALESCE(NEW.seq_no, 1),
 845                 NEW.subquery
 846     );
 847
 848 CREATE OR REPLACE RULE query_expr_xnin_update_rule AS
 849     ON UPDATE TO query.expr_xnin
 850     DO INSTEAD
 851     UPDATE query.expression SET
 852         id = NEW.id,
 853         parenthesize = NEW.parenthesize,
 854         parent_expr = NEW.parent_expr,
 855         seq_no = NEW.seq_no,
 856                 subquery = NEW.subquery
 857     WHERE
 858         id = OLD.id;
 859
 860 CREATE OR REPLACE RULE query_expr_xnin_delete_rule AS
 861     ON DELETE TO query.expr_xnin
 862     DO INSTEAD
 863     DELETE FROM query.expression WHERE id = OLD.id;
 864
 865 -- Create updatable view for NULL expressions
 866
 867 CREATE OR REPLACE VIEW query.expr_xnull AS
 868     SELECT
 869                 id,
 870                 parenthesize,
 871                 parent_expr,
 872                 seq_no
 873     FROM
 874         query.expression
 875     WHERE
 876         type = 'xnull';
 877
 878 CREATE OR REPLACE RULE query_expr_xnull_insert_rule AS
 879     ON INSERT TO query.expr_xnull
 880     DO INSTEAD
 881     INSERT INTO query.expression (
 882                 id,
 883                 type,
 884                 parenthesize,
 885                 parent_expr,
 886                 seq_no
 887     ) VALUES (
 888         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 889         'xnull',
 890         COALESCE(NEW.parenthesize, FALSE),
 891         NEW.parent_expr,
 892         COALESCE(NEW.seq_no, 1)
 893     );
 894
 895 CREATE OR REPLACE RULE query_expr_xnull_update_rule AS
 896     ON UPDATE TO query.expr_xnull
 897     DO INSTEAD
 898     UPDATE query.expression SET
 899         id = NEW.id,
 900         parenthesize = NEW.parenthesize,
 901         parent_expr = NEW.parent_expr,
 902         seq_no = NEW.seq_no
 903     WHERE
 904         id = OLD.id;
 905
 906 CREATE OR REPLACE RULE query_expr_xnull_delete_rule AS
 907     ON DELETE TO query.expr_xnull
 908     DO INSTEAD
 909     DELETE FROM query.expression WHERE id = OLD.id;
 910
 911 -- Create updatable view for numeric literal expressions
 912
 913 CREATE OR REPLACE VIEW query.expr_xnum AS
 914     SELECT
 915                 id,
 916                 parenthesize,
 917                 parent_expr,
 918                 seq_no,
 919                 literal
 920     FROM
 921         query.expression
 922     WHERE
 923         type = 'xnum';
 924
 925 CREATE OR REPLACE RULE query_expr_xnum_insert_rule AS
 926     ON INSERT TO query.expr_xnum
 927     DO INSTEAD
 928     INSERT INTO query.expression (
 929                 id,
 930                 type,
 931                 parenthesize,
 932                 parent_expr,
 933                 seq_no,
 934                 literal
 935     ) VALUES (
 936         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 937         'xnum',
 938         COALESCE(NEW.parenthesize, FALSE),
 939         NEW.parent_expr,
 940         COALESCE(NEW.seq_no, 1),
 941         NEW.literal
 942     );
 943
 944 CREATE OR REPLACE RULE query_expr_xnum_update_rule AS
 945     ON UPDATE TO query.expr_xnum
 946     DO INSTEAD
 947     UPDATE query.expression SET
 948         id = NEW.id,
 949         parenthesize = NEW.parenthesize,
 950         parent_expr = NEW.parent_expr,
 951         seq_no = NEW.seq_no,
 952         literal = NEW.literal
 953     WHERE
 954         id = OLD.id;
 955
 956 CREATE OR REPLACE RULE query_expr_xnum_delete_rule AS
 957     ON DELETE TO query.expr_xnum
 958     DO INSTEAD
 959     DELETE FROM query.expression WHERE id = OLD.id;
 960
 961 -- Create updatable view for operator expressions
 962
 963 CREATE OR REPLACE VIEW query.expr_xop AS
 964     SELECT
 965                 id,
 966                 parenthesize,
 967                 parent_expr,
 968                 seq_no,
 969                 left_operand,
 970                 operator,
 971                 right_operand
 972     FROM
 973         query.expression
 974     WHERE
 975         type = 'xop';
 976
 977 CREATE OR REPLACE RULE query_expr_xop_insert_rule AS
 978     ON INSERT TO query.expr_xop
 979     DO INSTEAD
 980     INSERT INTO query.expression (
 981                 id,
 982                 type,
 983                 parenthesize,
 984                 parent_expr,
 985                 seq_no,
 986                 left_operand,
 987                 operator,
 988                 right_operand
 989     ) VALUES (
 990         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 991         'xop',
 992         COALESCE(NEW.parenthesize, FALSE),
 993         NEW.parent_expr,
 994         COALESCE(NEW.seq_no, 1),
 995                 NEW.left_operand,
 996                 NEW.operator,
 997                 NEW.right_operand
 998     );
 999
1000 CREATE OR REPLACE RULE query_expr_xop_update_rule AS
1001     ON UPDATE TO query.expr_xop
1002     DO INSTEAD
1003     UPDATE query.expression SET
1004         id = NEW.id,
1005         parenthesize = NEW.parenthesize,
1006         parent_expr = NEW.parent_expr,
1007         seq_no = NEW.seq_no,
1008                 left_operand = NEW.left_operand,
1009                 operator = NEW.operator,
1010                 right_operand = NEW.right_operand
1011     WHERE
1012         id = OLD.id;
1013
1014 CREATE OR REPLACE RULE query_expr_xop_delete_rule AS
1015     ON DELETE TO query.expr_xop
1016     DO INSTEAD
1017     DELETE FROM query.expression WHERE id = OLD.id;
1018
1019 -- Create updatable view for string literal expressions
1020
1021 CREATE OR REPLACE VIEW query.expr_string AS
1022     SELECT
1023         id,
1024         parenthesize,
1025         parent_expr,
1026         seq_no,
1027         literal
1028     FROM
1029         query.expression
1030     WHERE
1031         type = 'xstr';
1032
1033 CREATE OR REPLACE RULE query_expr_string_insert_rule AS
1034     ON INSERT TO query.expr_string
1035     DO INSTEAD
1036     INSERT INTO query.expression (
1037         id,
1038         type,
1039         parenthesize,
1040         parent_expr,
1041         seq_no,
1042         literal
1043     ) VALUES (
1044         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
1045         'xstr',
1046         COALESCE(NEW.parenthesize, FALSE),
1047         NEW.parent_expr,
1048         COALESCE(NEW.seq_no, 1),
1049         NEW.literal
1050     );
1051
1052 CREATE OR REPLACE RULE query_expr_string_update_rule AS
1053     ON UPDATE TO query.expr_string
1054     DO INSTEAD
1055     UPDATE query.expression SET
1056         id = NEW.id,
1057         parenthesize = NEW.parenthesize,
1058         parent_expr = NEW.parent_expr,
1059         seq_no = NEW.seq_no,
1060         literal = NEW.literal
1061     WHERE
1062         id = OLD.id;
1063
1064 CREATE OR REPLACE RULE query_expr_string_delete_rule AS
1065     ON DELETE TO query.expr_string
1066     DO INSTEAD
1067     DELETE FROM query.expression WHERE id = OLD.id;
1068
1069 -- Create updatable view for subquery expressions
1070
1071 CREATE OR REPLACE VIEW query.expr_xsubq AS
1072     SELECT
1073                 id,
1074                 parenthesize,
1075                 parent_expr,
1076                 seq_no,
1077                 subquery
1078     FROM
1079         query.expression
1080     WHERE
1081         type = 'xsubq';
1082
1083 CREATE OR REPLACE RULE query_expr_xsubq_insert_rule AS
1084     ON INSERT TO query.expr_xsubq
1085     DO INSTEAD
1086     INSERT INTO query.expression (
1087                 id,
1088                 type,
1089                 parenthesize,
1090                 parent_expr,
1091                 seq_no,
1092                 subquery
1093     ) VALUES (
1094         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
1095         'xsubq',
1096         COALESCE(NEW.parenthesize, FALSE),
1097         NEW.parent_expr,
1098         COALESCE(NEW.seq_no, 1),
1099                 NEW.subquery
1100     );
1101
1102 CREATE OR REPLACE RULE query_expr_xsubq_update_rule AS
1103     ON UPDATE TO query.expr_xsubq
1104     DO INSTEAD
1105     UPDATE query.expression SET
1106         id = NEW.id,
1107         parenthesize = NEW.parenthesize,
1108         parent_expr = NEW.parent_expr,
1109         seq_no = NEW.seq_no,
1110                 subquery = NEW.subquery
1111     WHERE
1112         id = OLD.id;
1113
1114 CREATE OR REPLACE RULE query_expr_xsubq_delete_rule AS
1115     ON DELETE TO query.expr_xsubq
1116     DO INSTEAD
1117     DELETE FROM query.expression WHERE id = OLD.id;
1118
1119 COMMIT;