1. Add a boolean "negate" column to query.expression.
[working/Evergreen.git] / 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,           --REFERENCES query.from_clause
38                                      --DEFERRABLE INITIALLY DEFERRED,
39         where_clause  INT,           --REFERENCES query.expression
40                                      --DEFERRABLE INITIALLY DEFERRED,
41         having_clause INT            --REFERENCES query.expression
42                                      --DEFERRABLE INITIALLY DEFERRED
43 );
44
45 -- (Foreign keys to be defined later after other tables are created)
46
47 CREATE TABLE query.query_sequence (
48         id              SERIAL            PRIMARY KEY,
49         parent_query    INT               NOT NULL
50                                           REFERENCES query.stored_query
51                                                                           ON DELETE CASCADE
52                                                                           DEFERRABLE INITIALLY DEFERRED,
53         seq_no          INT               NOT NULL,
54         child_query     INT               NOT NULL
55                                           REFERENCES query.stored_query
56                                                                           ON DELETE CASCADE
57                                                                           DEFERRABLE INITIALLY DEFERRED,
58         CONSTRAINT query_query_seq UNIQUE( parent_query, seq_no )
59 );
60
61 CREATE TABLE query.datatype (
62         id              SERIAL            PRIMARY KEY,
63         datatype_name   TEXT              NOT NULL UNIQUE,
64         is_numeric      BOOL              NOT NULL DEFAULT FALSE,
65         is_composite    BOOL              NOT NULL DEFAULT FALSE,
66         CONSTRAINT qdt_comp_not_num CHECK
67         ( is_numeric IS FALSE OR is_composite IS FALSE )
68 );
69
70 CREATE TABLE query.subfield (
71         id              SERIAL            PRIMARY KEY,
72         composite_type  INT               NOT NULL
73                                           REFERENCES query.datatype(id)
74                                           ON DELETE CASCADE
75                                           DEFERRABLE INITIALLY DEFERRED,
76         seq_no          INT               NOT NULL
77                                           CONSTRAINT qsf_pos_seq_no
78                                           CHECK( seq_no > 0 ),
79         subfield_type   INT               NOT NULL
80                                           REFERENCES query.datatype(id)
81                                           DEFERRABLE INITIALLY DEFERRED,
82         CONSTRAINT qsf_datatype_seq_no UNIQUE (composite_type, seq_no)
83 );
84
85 CREATE TABLE query.function_sig (
86         id              SERIAL            PRIMARY KEY,
87         function_name   TEXT              NOT NULL,
88         return_type     INT               REFERENCES query.datatype(id)
89                                           DEFERRABLE INITIALLY DEFERRED,
90         is_aggregate    BOOL              NOT NULL DEFAULT FALSE,
91         CONSTRAINT qfd_rtn_or_aggr CHECK
92         ( return_type IS NULL OR is_aggregate = FALSE )
93 );
94
95 CREATE INDEX query_function_sig_name_idx 
96         ON query.function_sig (function_name);
97
98 CREATE TABLE query.function_param_def (
99         id              SERIAL            PRIMARY KEY,
100         function_id     INT               NOT NULL
101                                           REFERENCES query.function_sig( id )
102                                           ON DELETE CASCADE
103                                           DEFERRABLE INITIALLY DEFERRED,
104         seq_no          INT               NOT NULL
105                                           CONSTRAINT qfpd_pos_seq_no CHECK
106                                           ( seq_no > 0 ),
107         datatype        INT               NOT NULL
108                                           REFERENCES query.datatype( id )
109                                           DEFERRABLE INITIALLY DEFERRED,
110         CONSTRAINT qfpd_function_param_seq UNIQUE (function_id, seq_no)
111 );
112
113 CREATE TABLE query.expression (
114         id            SERIAL        PRIMARY KEY,
115         type          TEXT          NOT NULL CONSTRAINT predicate_type CHECK
116                                     ( type IN (
117                                         'xbet',    -- between
118                                                                         'xbool',   -- boolean
119                                         'xcase',   -- case
120                                                                         'xcast',   -- cast
121                                                                         'xcol',    -- column
122                                                                         'xex',     -- exists
123                                                                         'xfld',    -- field
124                                                                         'xfunc',   -- function
125                                                                         'xin',     -- in
126                                         'xnull',   -- null
127                                                                         'xnum',    -- number
128                                                                         'xop',     -- operator
129                                                                         'xstr',    -- string
130                                                 'xsubq'    -- subquery
131                                                                 ) ),
132         parenthesize  BOOL          NOT NULL DEFAULT FALSE,
133         parent_expr   INT           REFERENCES query.expression
134                                     ON DELETE CASCADE
135                                     DEFERRABLE INITIALLY DEFERRED,
136         seq_no        INT           NOT NULL DEFAULT 1,
137         literal       TEXT,
138         table_alias   TEXT,
139         column_name   TEXT,
140         left_operand  INT           REFERENCES query.expression
141                                     DEFERRABLE INITIALLY DEFERRED,
142         operator      TEXT,
143         right_operand INT           REFERENCES query.expression
144                                     DEFERRABLE INITIALLY DEFERRED,
145         function_id   INT           REFERENCES query.function_sig
146                                     DEFERRABLE INITIALLY DEFERRED,
147         subquery      INT           REFERENCES query.stored_query
148                                     DEFERRABLE INITIALLY DEFERRED,
149         cast_type     INT           REFERENCES query.datatype
150                                     DEFERRABLE INITIALLY DEFERRED,
151         negate        BOOL          NOT NULL DEFAULT FALSE
152 );
153
154 CREATE UNIQUE INDEX query_expr_parent_seq
155         ON query.expression( parent_expr, seq_no )
156         WHERE parent_expr IS NOT NULL;
157
158 -- Due to some circular references, the following foreign key definitions
159 -- had to be deferred until query.expression existed:
160
161 ALTER TABLE query.stored_query
162         ADD FOREIGN KEY ( where_clause )
163         REFERENCES query.expression( id )
164         DEFERRABLE INITIALLY DEFERRED;
165
166 ALTER TABLE query.stored_query
167         ADD FOREIGN KEY ( having_clause )
168         REFERENCES query.expression( id )
169         DEFERRABLE INITIALLY DEFERRED;
170
171 CREATE TABLE query.case_branch (
172         id            SERIAL        PRIMARY KEY,
173         parent_expr   INT           NOT NULL REFERENCES query.expression
174                                     ON DELETE CASCADE
175                                     DEFERRABLE INITIALLY DEFERRED,
176         seq_no        INT           NOT NULL,
177         condition     INT           REFERENCES query.expression
178                                     DEFERRABLE INITIALLY DEFERRED,
179         result        INT           NOT NULL REFERENCES query.expression
180                                     DEFERRABLE INITIALLY DEFERRED,
181         CONSTRAINT case_branch_parent_seq UNIQUE (parent_expr, seq_no)
182 );
183
184 CREATE TABLE query.from_relation (
185         id               SERIAL        PRIMARY KEY,
186         type             TEXT          NOT NULL CONSTRAINT relation_type CHECK (
187                                            type IN ( 'RELATION', 'SUBQUERY', 'FUNCTION' ) ),
188         table_name       TEXT,
189         class_name       TEXT,
190         subquery         INT           REFERENCES query.stored_query,
191         function_call    INT           REFERENCES query.expression,
192         table_alias      TEXT,
193         parent_relation  INT           REFERENCES query.from_relation
194                                        ON DELETE CASCADE
195                                        DEFERRABLE INITIALLY DEFERRED,
196         seq_no           INT           NOT NULL DEFAULT 1,
197         join_type        TEXT          CONSTRAINT good_join_type CHECK (
198                                            join_type IS NULL OR join_type IN
199                                            ( 'INNER', 'LEFT', 'RIGHT', 'FULL' )
200                                        ),
201         on_clause        INT           REFERENCES query.expression
202                                        DEFERRABLE INITIALLY DEFERRED,
203         CONSTRAINT join_or_core CHECK (
204             ( parent_relation IS NULL AND join_type IS NULL 
205               AND on_clause IS NULL )
206             OR
207             ( parent_relation IS NOT NULL AND join_type IS NOT NULL
208               AND on_clause IS NOT NULL )
209         )
210 );
211
212 CREATE UNIQUE INDEX from_parent_seq
213         ON query.from_relation( parent_relation, seq_no )
214         WHERE parent_relation IS NOT NULL;
215
216 -- The following foreign key had to be deferred until
217 -- query.from_relation existed
218
219 ALTER TABLE query.stored_query
220         ADD FOREIGN KEY (from_clause)
221         REFERENCES query.from_relation
222         DEFERRABLE INITIALLY DEFERRED;
223
224 CREATE TABLE query.record_column (
225         id            SERIAL            PRIMARY KEY,
226         from_relation INT               NOT NULL REFERENCES query.from_relation
227                                         ON DELETE CASCADE
228                                         DEFERRABLE INITIALLY DEFERRED,
229         seq_no        INT               NOT NULL,
230         column_name   TEXT              NOT NULL,
231     column_type   INT               NOT NULL REFERENCES query.datatype
232                                     ON DELETE CASCADE
233                                     DEFERRABLE INITIALLY DEFERRED,
234         CONSTRAINT column_sequence UNIQUE (from_relation, seq_no)
235 );
236
237 CREATE TABLE query.select_item (
238         id               SERIAL         PRIMARY KEY,
239         stored_query     INT            NOT NULL REFERENCES query.stored_query
240                                         ON DELETE CASCADE
241                                         DEFERRABLE INITIALLY DEFERRED,
242         seq_no           INT            NOT NULL,
243         expression       INT            NOT NULL REFERENCES query.expression
244                                         DEFERRABLE INITIALLY DEFERRED,
245         column_alias     TEXT,
246         grouped_by       BOOL           NOT NULL DEFAULT FALSE,
247         CONSTRAINT select_sequence UNIQUE( stored_query, seq_no )
248 );
249
250 CREATE TABLE query.order_by_item (
251         id               SERIAL         PRIMARY KEY,
252         stored_query     INT            NOT NULL REFERENCES query.stored_query
253                                         ON DELETE CASCADE
254                                         DEFERRABLE INITIALLY DEFERRED,
255         seq_no           INT            NOT NULL,
256         expression       INT            NOT NULL REFERENCES query.expression
257                                         ON DELETE CASCADE
258                                         DEFERRABLE INITIALLY DEFERRED,
259         CONSTRAINT order_by_sequence UNIQUE( stored_query, seq_no )
260 );
261
262 -- Create updatable views -------------------------------------------
263
264 -- Create updatable view for BETWEEN expressions
265
266 CREATE OR REPLACE VIEW query.expr_xbet AS
267     SELECT
268                 id,
269                 parenthesize,
270                 parent_expr,
271                 seq_no
272     FROM
273         query.expression
274     WHERE
275         type = 'xbet';
276
277 CREATE OR REPLACE RULE query_expr_xbet_insert_rule AS
278     ON INSERT TO query.expr_xbet
279     DO INSTEAD
280     INSERT INTO query.expression (
281                 id,
282                 type,
283                 parenthesize,
284                 parent_expr,
285                 seq_no
286     ) VALUES (
287         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
288         'xbet',
289         COALESCE(NEW.parenthesize, FALSE),
290         NEW.parent_expr,
291         COALESCE(NEW.seq_no, 1)
292     );
293
294 CREATE OR REPLACE RULE query_expr_xbet_update_rule AS
295     ON UPDATE TO query.expr_xbet
296     DO INSTEAD
297     UPDATE query.expression SET
298         id = NEW.id,
299         parenthesize = NEW.parenthesize,
300         parent_expr = NEW.parent_expr,
301         seq_no = NEW.seq_no
302     WHERE
303         id = OLD.id;
304
305 CREATE OR REPLACE RULE query_expr_xbet_delete_rule AS
306     ON DELETE TO query.expr_xbet
307     DO INSTEAD
308     DELETE FROM query.expression WHERE id = OLD.id;
309
310 -- Create updatable view for boolean expressions
311
312 CREATE OR REPLACE VIEW query.expr_xbool AS
313     SELECT
314                 id,
315                 parenthesize,
316                 parent_expr,
317                 seq_no,
318                 literal
319     FROM
320         query.expression
321     WHERE
322         type = 'xbool';
323
324 CREATE OR REPLACE RULE query_expr_xbool_insert_rule AS
325     ON INSERT TO query.expr_xbool
326     DO INSTEAD
327     INSERT INTO query.expression (
328                 id,
329                 type,
330                 parenthesize,
331                 parent_expr,
332                 seq_no,
333                 literal
334     ) VALUES (
335         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
336         'xbool',
337         COALESCE(NEW.parenthesize, FALSE),
338         NEW.parent_expr,
339         COALESCE(NEW.seq_no, 1),
340         NEW.literal
341     );
342
343 CREATE OR REPLACE RULE query_expr_xbool_update_rule AS
344     ON UPDATE TO query.expr_xbool
345     DO INSTEAD
346     UPDATE query.expression SET
347         id = NEW.id,
348         parenthesize = NEW.parenthesize,
349         parent_expr = NEW.parent_expr,
350         seq_no = NEW.seq_no,
351         literal = NEW.literal
352     WHERE
353         id = OLD.id;
354
355 CREATE OR REPLACE RULE query_expr_xbool_delete_rule AS
356     ON DELETE TO query.expr_xbool
357     DO INSTEAD
358     DELETE FROM query.expression WHERE id = OLD.id;
359
360 -- Create updatable view for CASE expressions
361
362 CREATE OR REPLACE VIEW query.expr_xcase AS
363     SELECT
364                 id,
365                 parenthesize,
366                 parent_expr,
367                 seq_no
368     FROM
369         query.expression
370     WHERE
371         type = 'xcase';
372
373 CREATE OR REPLACE RULE query_expr_xcase_insert_rule AS
374     ON INSERT TO query.expr_xcase
375     DO INSTEAD
376     INSERT INTO query.expression (
377                 id,
378                 type,
379                 parenthesize,
380                 parent_expr,
381                 seq_no
382     ) VALUES (
383         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
384         'xcase',
385         COALESCE(NEW.parenthesize, FALSE),
386         NEW.parent_expr,
387         COALESCE(NEW.seq_no, 1)
388     );
389
390 CREATE OR REPLACE RULE query_expr_xcase_update_rule AS
391     ON UPDATE TO query.expr_xcase
392     DO INSTEAD
393     UPDATE query.expression SET
394         id = NEW.id,
395         parenthesize = NEW.parenthesize,
396         parent_expr = NEW.parent_expr,
397         seq_no = NEW.seq_no
398     WHERE
399         id = OLD.id;
400
401 CREATE OR REPLACE RULE query_expr_xcase_delete_rule AS
402     ON DELETE TO query.expr_xcase
403     DO INSTEAD
404     DELETE FROM query.expression WHERE id = OLD.id;
405
406 -- Create updatable view for cast expressions
407
408 CREATE OR REPLACE VIEW query.expr_xcast AS
409     SELECT
410                 id,
411                 parenthesize,
412                 parent_expr,
413                 seq_no,
414                 left_operand,
415                 cast_type
416     FROM
417         query.expression
418     WHERE
419         type = 'xcast';
420
421 CREATE OR REPLACE RULE query_expr_xcast_insert_rule AS
422     ON INSERT TO query.expr_xcast
423     DO INSTEAD
424     INSERT INTO query.expression (
425                 id,
426                 type,
427                 parenthesize,
428                 parent_expr,
429                 seq_no,
430                 left_operand,
431                 cast_type
432     ) VALUES (
433         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
434         'xcast',
435         COALESCE(NEW.parenthesize, FALSE),
436         NEW.parent_expr,
437         COALESCE(NEW.seq_no, 1),
438                 NEW.left_operand,
439                 NEW.cast_type
440     );
441
442 CREATE OR REPLACE RULE query_expr_xcast_update_rule AS
443     ON UPDATE TO query.expr_xcast
444     DO INSTEAD
445     UPDATE query.expression SET
446         id = NEW.id,
447         parenthesize = NEW.parenthesize,
448         parent_expr = NEW.parent_expr,
449         seq_no = NEW.seq_no,
450                 left_operand = NEW.left_operand,
451                 cast_type = NEW.cast_type
452     WHERE
453         id = OLD.id;
454
455 CREATE OR REPLACE RULE query_expr_xcast_delete_rule AS
456     ON DELETE TO query.expr_xcast
457     DO INSTEAD
458     DELETE FROM query.expression WHERE id = OLD.id;
459
460 -- Create updatable view for column expressions
461
462 CREATE OR REPLACE VIEW query.expr_xcol AS
463     SELECT
464                 id,
465                 parenthesize,
466                 parent_expr,
467                 seq_no,
468                 table_alias,
469                 column_name
470     FROM
471         query.expression
472     WHERE
473         type = 'xcol';
474
475 CREATE OR REPLACE RULE query_expr_xcol_insert_rule AS
476     ON INSERT TO query.expr_xcol
477     DO INSTEAD
478     INSERT INTO query.expression (
479                 id,
480                 type,
481                 parenthesize,
482                 parent_expr,
483                 seq_no,
484                 table_alias,
485                 column_name
486     ) VALUES (
487         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
488         'xcol',
489         COALESCE(NEW.parenthesize, FALSE),
490         NEW.parent_expr,
491         COALESCE(NEW.seq_no, 1),
492                 NEW.table_alias,
493                 NEW.column_name
494     );
495
496 CREATE OR REPLACE RULE query_expr_xcol_update_rule AS
497     ON UPDATE TO query.expr_xcol
498     DO INSTEAD
499     UPDATE query.expression SET
500         id = NEW.id,
501         parenthesize = NEW.parenthesize,
502         parent_expr = NEW.parent_expr,
503         seq_no = NEW.seq_no,
504                 table_alias = NEW.table_alias,
505                 column_name = NEW.column_name
506     WHERE
507         id = OLD.id;
508
509 CREATE OR REPLACE RULE query_expr_xcol_delete_rule AS
510     ON DELETE TO query.expr_xcol
511     DO INSTEAD
512     DELETE FROM query.expression WHERE id = OLD.id;
513
514 -- Create updatable view for EXISTS expressions
515
516 CREATE OR REPLACE VIEW query.expr_xex AS
517     SELECT
518                 id,
519                 parenthesize,
520                 parent_expr,
521                 seq_no,
522                 subquery
523     FROM
524         query.expression
525     WHERE
526         type = 'xex';
527
528 CREATE OR REPLACE RULE query_expr_xex_insert_rule AS
529     ON INSERT TO query.expr_xex
530     DO INSTEAD
531     INSERT INTO query.expression (
532                 id,
533                 type,
534                 parenthesize,
535                 parent_expr,
536                 seq_no,
537                 subquery
538     ) VALUES (
539         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
540         'xex',
541         COALESCE(NEW.parenthesize, FALSE),
542         NEW.parent_expr,
543         COALESCE(NEW.seq_no, 1),
544                 NEW.subquery
545     );
546
547 CREATE OR REPLACE RULE query_expr_xex_update_rule AS
548     ON UPDATE TO query.expr_xex
549     DO INSTEAD
550     UPDATE query.expression SET
551         id = NEW.id,
552         parenthesize = NEW.parenthesize,
553         parent_expr = NEW.parent_expr,
554         seq_no = NEW.seq_no,
555                 subquery = NEW.subquery
556     WHERE
557         id = OLD.id;
558
559 CREATE OR REPLACE RULE query_expr_xex_delete_rule AS
560     ON DELETE TO query.expr_xex
561     DO INSTEAD
562     DELETE FROM query.expression WHERE id = OLD.id;
563
564 -- Create updatable view for field expressions
565
566 CREATE OR REPLACE VIEW query.expr_xfld AS
567     SELECT
568                 id,
569                 parenthesize,
570                 parent_expr,
571                 seq_no,
572                 column_name,
573                 left_operand
574     FROM
575         query.expression
576     WHERE
577         type = 'xfld';
578
579 CREATE OR REPLACE RULE query_expr_xfld_insert_rule AS
580     ON INSERT TO query.expr_xfld
581     DO INSTEAD
582     INSERT INTO query.expression (
583                 id,
584                 type,
585                 parenthesize,
586                 parent_expr,
587                 seq_no,
588                 column_name,
589                 left_operand
590     ) VALUES (
591         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
592         'xfld',
593         COALESCE(NEW.parenthesize, FALSE),
594         NEW.parent_expr,
595         COALESCE(NEW.seq_no, 1),
596                 NEW.column_name,
597                 NEW.left_operand
598     );
599
600 CREATE OR REPLACE RULE query_expr_xfld_update_rule AS
601     ON UPDATE TO query.expr_xfld
602     DO INSTEAD
603     UPDATE query.expression SET
604         id = NEW.id,
605         parenthesize = NEW.parenthesize,
606         parent_expr = NEW.parent_expr,
607         seq_no = NEW.seq_no,
608                 column_name = NEW.column_name,
609                 left_operand = NEW.left_operand
610     WHERE
611         id = OLD.id;
612
613 CREATE OR REPLACE RULE query_expr_xfld_delete_rule AS
614     ON DELETE TO query.expr_xfld
615     DO INSTEAD
616     DELETE FROM query.expression WHERE id = OLD.id;
617
618 -- Create updatable view for function call expressions
619
620 CREATE OR REPLACE VIEW query.expr_xfunc AS
621     SELECT
622                 id,
623                 parenthesize,
624                 parent_expr,
625                 seq_no,
626                 function_id
627     FROM
628         query.expression
629     WHERE
630         type = 'xfunc';
631
632 CREATE OR REPLACE RULE query_expr_xfunc_insert_rule AS
633     ON INSERT TO query.expr_xfunc
634     DO INSTEAD
635     INSERT INTO query.expression (
636                 id,
637                 type,
638                 parenthesize,
639                 parent_expr,
640                 seq_no,
641                 function_id
642     ) VALUES (
643         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
644         'xfunc',
645         COALESCE(NEW.parenthesize, FALSE),
646         NEW.parent_expr,
647         COALESCE(NEW.seq_no, 1),
648                 NEW.function_id
649     );
650
651 CREATE OR REPLACE RULE query_expr_xfunc_update_rule AS
652     ON UPDATE TO query.expr_xfunc
653     DO INSTEAD
654     UPDATE query.expression SET
655         id = NEW.id,
656         parenthesize = NEW.parenthesize,
657         parent_expr = NEW.parent_expr,
658         seq_no = NEW.seq_no,
659                 function_id = NEW.function_id
660     WHERE
661         id = OLD.id;
662
663 CREATE OR REPLACE RULE query_expr_xfunc_delete_rule AS
664     ON DELETE TO query.expr_xfunc
665     DO INSTEAD
666     DELETE FROM query.expression WHERE id = OLD.id;
667
668 -- Create updatable view for IN expressions
669
670 CREATE OR REPLACE VIEW query.expr_xin AS
671     SELECT
672                 id,
673                 parenthesize,
674                 parent_expr,
675                 seq_no,
676                 subquery
677     FROM
678         query.expression
679     WHERE
680         type = 'xin';
681
682 CREATE OR REPLACE RULE query_expr_xin_insert_rule AS
683     ON INSERT TO query.expr_xin
684     DO INSTEAD
685     INSERT INTO query.expression (
686                 id,
687                 type,
688                 parenthesize,
689                 parent_expr,
690                 seq_no,
691                 subquery
692     ) VALUES (
693         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
694         'xin',
695         COALESCE(NEW.parenthesize, FALSE),
696         NEW.parent_expr,
697         COALESCE(NEW.seq_no, 1),
698                 NEW.subquery
699     );
700
701 CREATE OR REPLACE RULE query_expr_xin_update_rule AS
702     ON UPDATE TO query.expr_xin
703     DO INSTEAD
704     UPDATE query.expression SET
705         id = NEW.id,
706         parenthesize = NEW.parenthesize,
707         parent_expr = NEW.parent_expr,
708         seq_no = NEW.seq_no,
709                 subquery = NEW.subquery
710     WHERE
711         id = OLD.id;
712
713 CREATE OR REPLACE RULE query_expr_xin_delete_rule AS
714     ON DELETE TO query.expr_xin
715     DO INSTEAD
716     DELETE FROM query.expression WHERE id = OLD.id;
717
718 -- Create updatable view for NULL expressions
719
720 CREATE OR REPLACE VIEW query.expr_xnull AS
721     SELECT
722                 id,
723                 parenthesize,
724                 parent_expr,
725                 seq_no
726     FROM
727         query.expression
728     WHERE
729         type = 'xnull';
730
731 CREATE OR REPLACE RULE query_expr_xnull_insert_rule AS
732     ON INSERT TO query.expr_xnull
733     DO INSTEAD
734     INSERT INTO query.expression (
735                 id,
736                 type,
737                 parenthesize,
738                 parent_expr,
739                 seq_no
740     ) VALUES (
741         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
742         'xnull',
743         COALESCE(NEW.parenthesize, FALSE),
744         NEW.parent_expr,
745         COALESCE(NEW.seq_no, 1)
746     );
747
748 CREATE OR REPLACE RULE query_expr_xnull_update_rule AS
749     ON UPDATE TO query.expr_xnull
750     DO INSTEAD
751     UPDATE query.expression SET
752         id = NEW.id,
753         parenthesize = NEW.parenthesize,
754         parent_expr = NEW.parent_expr,
755         seq_no = NEW.seq_no
756     WHERE
757         id = OLD.id;
758
759 CREATE OR REPLACE RULE query_expr_xnull_delete_rule AS
760     ON DELETE TO query.expr_xnull
761     DO INSTEAD
762     DELETE FROM query.expression WHERE id = OLD.id;
763
764 -- Create updatable view for numeric literal expressions
765
766 CREATE OR REPLACE VIEW query.expr_xnum AS
767     SELECT
768                 id,
769                 parenthesize,
770                 parent_expr,
771                 seq_no,
772                 literal
773     FROM
774         query.expression
775     WHERE
776         type = 'xnum';
777
778 CREATE OR REPLACE RULE query_expr_xnum_insert_rule AS
779     ON INSERT TO query.expr_xnum
780     DO INSTEAD
781     INSERT INTO query.expression (
782                 id,
783                 type,
784                 parenthesize,
785                 parent_expr,
786                 seq_no,
787                 literal
788     ) VALUES (
789         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
790         'xnum',
791         COALESCE(NEW.parenthesize, FALSE),
792         NEW.parent_expr,
793         COALESCE(NEW.seq_no, 1),
794         NEW.literal
795     );
796
797 CREATE OR REPLACE RULE query_expr_xnum_update_rule AS
798     ON UPDATE TO query.expr_xnum
799     DO INSTEAD
800     UPDATE query.expression SET
801         id = NEW.id,
802         parenthesize = NEW.parenthesize,
803         parent_expr = NEW.parent_expr,
804         seq_no = NEW.seq_no,
805         literal = NEW.literal
806     WHERE
807         id = OLD.id;
808
809 CREATE OR REPLACE RULE query_expr_xnum_delete_rule AS
810     ON DELETE TO query.expr_xnum
811     DO INSTEAD
812     DELETE FROM query.expression WHERE id = OLD.id;
813
814 -- Create updatable view for operator expressions
815
816 CREATE OR REPLACE VIEW query.expr_xop AS
817     SELECT
818                 id,
819                 parenthesize,
820                 parent_expr,
821                 seq_no,
822                 left_operand,
823                 operator,
824                 right_operand
825     FROM
826         query.expression
827     WHERE
828         type = 'xop';
829
830 CREATE OR REPLACE RULE query_expr_xop_insert_rule AS
831     ON INSERT TO query.expr_xop
832     DO INSTEAD
833     INSERT INTO query.expression (
834                 id,
835                 type,
836                 parenthesize,
837                 parent_expr,
838                 seq_no,
839                 left_operand,
840                 operator,
841                 right_operand
842     ) VALUES (
843         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
844         'xop',
845         COALESCE(NEW.parenthesize, FALSE),
846         NEW.parent_expr,
847         COALESCE(NEW.seq_no, 1),
848                 NEW.left_operand,
849                 NEW.operator,
850                 NEW.right_operand
851     );
852
853 CREATE OR REPLACE RULE query_expr_xop_update_rule AS
854     ON UPDATE TO query.expr_xop
855     DO INSTEAD
856     UPDATE query.expression SET
857         id = NEW.id,
858         parenthesize = NEW.parenthesize,
859         parent_expr = NEW.parent_expr,
860         seq_no = NEW.seq_no,
861                 left_operand = NEW.left_operand,
862                 operator = NEW.operator,
863                 right_operand = NEW.right_operand
864     WHERE
865         id = OLD.id;
866
867 CREATE OR REPLACE RULE query_expr_xop_delete_rule AS
868     ON DELETE TO query.expr_xop
869     DO INSTEAD
870     DELETE FROM query.expression WHERE id = OLD.id;
871
872 -- Create updatable view for string literal expressions
873
874 CREATE OR REPLACE VIEW query.expr_string AS
875     SELECT
876         id,
877         parenthesize,
878         parent_expr,
879         seq_no,
880         literal
881     FROM
882         query.expression
883     WHERE
884         type = 'xstr';
885
886 CREATE OR REPLACE RULE query_expr_string_insert_rule AS
887     ON INSERT TO query.expr_string
888     DO INSTEAD
889     INSERT INTO query.expression (
890         id,
891         type,
892         parenthesize,
893         parent_expr,
894         seq_no,
895         literal
896     ) VALUES (
897         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
898         'xstr',
899         COALESCE(NEW.parenthesize, FALSE),
900         NEW.parent_expr,
901         COALESCE(NEW.seq_no, 1),
902         NEW.literal
903     );
904
905 CREATE OR REPLACE RULE query_expr_string_update_rule AS
906     ON UPDATE TO query.expr_string
907     DO INSTEAD
908     UPDATE query.expression SET
909         id = NEW.id,
910         parenthesize = NEW.parenthesize,
911         parent_expr = NEW.parent_expr,
912         seq_no = NEW.seq_no,
913         literal = NEW.literal
914     WHERE
915         id = OLD.id;
916
917 CREATE OR REPLACE RULE query_expr_string_delete_rule AS
918     ON DELETE TO query.expr_string
919     DO INSTEAD
920     DELETE FROM query.expression WHERE id = OLD.id;
921
922 -- Create updatable view for subquery expressions
923
924 CREATE OR REPLACE VIEW query.expr_xsubq AS
925     SELECT
926                 id,
927                 parenthesize,
928                 parent_expr,
929                 seq_no,
930                 subquery
931     FROM
932         query.expression
933     WHERE
934         type = 'xsubq';
935
936 CREATE OR REPLACE RULE query_expr_xsubq_insert_rule AS
937     ON INSERT TO query.expr_xsubq
938     DO INSTEAD
939     INSERT INTO query.expression (
940                 id,
941                 type,
942                 parenthesize,
943                 parent_expr,
944                 seq_no,
945                 subquery
946     ) VALUES (
947         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
948         'xsubq',
949         COALESCE(NEW.parenthesize, FALSE),
950         NEW.parent_expr,
951         COALESCE(NEW.seq_no, 1),
952                 NEW.subquery
953     );
954
955 CREATE OR REPLACE RULE query_expr_xsubq_update_rule AS
956     ON UPDATE TO query.expr_xsubq
957     DO INSTEAD
958     UPDATE query.expression SET
959         id = NEW.id,
960         parenthesize = NEW.parenthesize,
961         parent_expr = NEW.parent_expr,
962         seq_no = NEW.seq_no,
963                 subquery = NEW.subquery
964     WHERE
965         id = OLD.id;
966
967 CREATE OR REPLACE RULE query_expr_xsubq_delete_rule AS
968     ON DELETE TO query.expr_xsubq
969     DO INSTEAD
970     DELETE FROM query.expression WHERE id = OLD.id;
971
972 COMMIT;