Open-ILS/src/sql/Pg/upgrade/0107.schema.query-updatable_views.sql

   1 BEGIN;
   2
   3 -- Create updatable view for BETWEEN expressions
   4
   5 INSERT INTO config.upgrade_log (version) VALUES ('0107'); -- Scott McKellar
   6
   7 CREATE OR REPLACE VIEW query.expr_xbet AS
   8     SELECT
   9                 id,
  10                 parenthesize,
  11                 parent_expr,
  12                 seq_no
  13     FROM
  14         query.expression
  15     WHERE
  16         type = 'xbet';
  17
  18 CREATE OR REPLACE RULE query_expr_xbet_insert_rule AS
  19     ON INSERT TO query.expr_xbet
  20     DO INSTEAD
  21     INSERT INTO query.expression (
  22                 id,
  23                 type,
  24                 parenthesize,
  25                 parent_expr,
  26                 seq_no
  27     ) VALUES (
  28         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
  29         'xbet',
  30         COALESCE(NEW.parenthesize, FALSE),
  31         NEW.parent_expr,
  32         COALESCE(NEW.seq_no, 1)
  33     );
  34
  35 CREATE OR REPLACE RULE query_expr_xbet_update_rule AS
  36     ON UPDATE TO query.expr_xbet
  37     DO INSTEAD
  38     UPDATE query.expression SET
  39         id = NEW.id,
  40         parenthesize = NEW.parenthesize,
  41         parent_expr = NEW.parent_expr,
  42         seq_no = NEW.seq_no
  43     WHERE
  44         id = OLD.id;
  45
  46 CREATE OR REPLACE RULE query_expr_xbet_delete_rule AS
  47     ON DELETE TO query.expr_xbet
  48     DO INSTEAD
  49     DELETE FROM query.expression WHERE id = OLD.id;
  50
  51 -- Create updatable view for boolean expressions
  52
  53 CREATE OR REPLACE VIEW query.expr_xbool AS
  54     SELECT
  55                 id,
  56                 parenthesize,
  57                 parent_expr,
  58                 seq_no,
  59                 literal
  60     FROM
  61         query.expression
  62     WHERE
  63         type = 'xbool';
  64
  65 CREATE OR REPLACE RULE query_expr_xbool_insert_rule AS
  66     ON INSERT TO query.expr_xbool
  67     DO INSTEAD
  68     INSERT INTO query.expression (
  69                 id,
  70                 type,
  71                 parenthesize,
  72                 parent_expr,
  73                 seq_no,
  74                 literal
  75     ) VALUES (
  76         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
  77         'xbool',
  78         COALESCE(NEW.parenthesize, FALSE),
  79         NEW.parent_expr,
  80         COALESCE(NEW.seq_no, 1),
  81         NEW.literal
  82     );
  83
  84 CREATE OR REPLACE RULE query_expr_xbool_update_rule AS
  85     ON UPDATE TO query.expr_xbool
  86     DO INSTEAD
  87     UPDATE query.expression SET
  88         id = NEW.id,
  89         parenthesize = NEW.parenthesize,
  90         parent_expr = NEW.parent_expr,
  91         seq_no = NEW.seq_no,
  92         literal = NEW.literal
  93     WHERE
  94         id = OLD.id;
  95
  96 CREATE OR REPLACE RULE query_expr_xbool_delete_rule AS
  97     ON DELETE TO query.expr_xbool
  98     DO INSTEAD
  99     DELETE FROM query.expression WHERE id = OLD.id;
 100
 101 -- Create updatable view for CASE expressions
 102
 103 CREATE OR REPLACE VIEW query.expr_xcase AS
 104     SELECT
 105                 id,
 106                 parenthesize,
 107                 parent_expr,
 108                 seq_no
 109     FROM
 110         query.expression
 111     WHERE
 112         type = 'xcase';
 113
 114 CREATE OR REPLACE RULE query_expr_xcase_insert_rule AS
 115     ON INSERT TO query.expr_xcase
 116     DO INSTEAD
 117     INSERT INTO query.expression (
 118                 id,
 119                 type,
 120                 parenthesize,
 121                 parent_expr,
 122                 seq_no
 123     ) VALUES (
 124         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 125         'xcase',
 126         COALESCE(NEW.parenthesize, FALSE),
 127         NEW.parent_expr,
 128         COALESCE(NEW.seq_no, 1)
 129     );
 130
 131 CREATE OR REPLACE RULE query_expr_xcase_update_rule AS
 132     ON UPDATE TO query.expr_xcase
 133     DO INSTEAD
 134     UPDATE query.expression SET
 135         id = NEW.id,
 136         parenthesize = NEW.parenthesize,
 137         parent_expr = NEW.parent_expr,
 138         seq_no = NEW.seq_no
 139     WHERE
 140         id = OLD.id;
 141
 142 CREATE OR REPLACE RULE query_expr_xcase_delete_rule AS
 143     ON DELETE TO query.expr_xcase
 144     DO INSTEAD
 145     DELETE FROM query.expression WHERE id = OLD.id;
 146
 147 -- Create updatable view for cast expressions
 148
 149 CREATE OR REPLACE VIEW query.expr_xcast AS
 150     SELECT
 151                 id,
 152                 parenthesize,
 153                 parent_expr,
 154                 seq_no,
 155                 left_operand,
 156                 cast_type
 157     FROM
 158         query.expression
 159     WHERE
 160         type = 'xcast';
 161
 162 CREATE OR REPLACE RULE query_expr_xcast_insert_rule AS
 163     ON INSERT TO query.expr_xcast
 164     DO INSTEAD
 165     INSERT INTO query.expression (
 166                 id,
 167                 type,
 168                 parenthesize,
 169                 parent_expr,
 170                 seq_no,
 171                 left_operand,
 172                 cast_type
 173     ) VALUES (
 174         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 175         'xcast',
 176         COALESCE(NEW.parenthesize, FALSE),
 177         NEW.parent_expr,
 178         COALESCE(NEW.seq_no, 1),
 179                 NEW.left_operand,
 180                 NEW.cast_type
 181     );
 182
 183 CREATE OR REPLACE RULE query_expr_xcast_update_rule AS
 184     ON UPDATE TO query.expr_xcast
 185     DO INSTEAD
 186     UPDATE query.expression SET
 187         id = NEW.id,
 188         parenthesize = NEW.parenthesize,
 189         parent_expr = NEW.parent_expr,
 190         seq_no = NEW.seq_no,
 191                 left_operand = NEW.left_operand,
 192                 cast_type = NEW.cast_type
 193     WHERE
 194         id = OLD.id;
 195
 196 CREATE OR REPLACE RULE query_expr_xcast_delete_rule AS
 197     ON DELETE TO query.expr_xcast
 198     DO INSTEAD
 199     DELETE FROM query.expression WHERE id = OLD.id;
 200
 201 -- Create updatable view for column expressions
 202
 203 CREATE OR REPLACE VIEW query.expr_xcol AS
 204     SELECT
 205                 id,
 206                 parenthesize,
 207                 parent_expr,
 208                 seq_no,
 209                 table_alias,
 210                 column_name
 211     FROM
 212         query.expression
 213     WHERE
 214         type = 'xcol';
 215
 216 CREATE OR REPLACE RULE query_expr_xcol_insert_rule AS
 217     ON INSERT TO query.expr_xcol
 218     DO INSTEAD
 219     INSERT INTO query.expression (
 220                 id,
 221                 type,
 222                 parenthesize,
 223                 parent_expr,
 224                 seq_no,
 225                 table_alias,
 226                 column_name
 227     ) VALUES (
 228         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 229         'xcol',
 230         COALESCE(NEW.parenthesize, FALSE),
 231         NEW.parent_expr,
 232         COALESCE(NEW.seq_no, 1),
 233                 NEW.table_alias,
 234                 NEW.column_name
 235     );
 236
 237 CREATE OR REPLACE RULE query_expr_xcol_update_rule AS
 238     ON UPDATE TO query.expr_xcol
 239     DO INSTEAD
 240     UPDATE query.expression SET
 241         id = NEW.id,
 242         parenthesize = NEW.parenthesize,
 243         parent_expr = NEW.parent_expr,
 244         seq_no = NEW.seq_no,
 245                 table_alias = NEW.table_alias,
 246                 column_name = NEW.column_name
 247     WHERE
 248         id = OLD.id;
 249
 250 CREATE OR REPLACE RULE query_expr_xcol_delete_rule AS
 251     ON DELETE TO query.expr_xcol
 252     DO INSTEAD
 253     DELETE FROM query.expression WHERE id = OLD.id;
 254
 255 -- Create updatable view for EXISTS expressions
 256
 257 CREATE OR REPLACE VIEW query.expr_xex AS
 258     SELECT
 259                 id,
 260                 parenthesize,
 261                 parent_expr,
 262                 seq_no,
 263                 subquery
 264     FROM
 265         query.expression
 266     WHERE
 267         type = 'xex';
 268
 269 CREATE OR REPLACE RULE query_expr_xex_insert_rule AS
 270     ON INSERT TO query.expr_xex
 271     DO INSTEAD
 272     INSERT INTO query.expression (
 273                 id,
 274                 type,
 275                 parenthesize,
 276                 parent_expr,
 277                 seq_no,
 278                 subquery
 279     ) VALUES (
 280         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 281         'xex',
 282         COALESCE(NEW.parenthesize, FALSE),
 283         NEW.parent_expr,
 284         COALESCE(NEW.seq_no, 1),
 285                 NEW.subquery
 286     );
 287
 288 CREATE OR REPLACE RULE query_expr_xex_update_rule AS
 289     ON UPDATE TO query.expr_xex
 290     DO INSTEAD
 291     UPDATE query.expression SET
 292         id = NEW.id,
 293         parenthesize = NEW.parenthesize,
 294         parent_expr = NEW.parent_expr,
 295         seq_no = NEW.seq_no,
 296                 subquery = NEW.subquery
 297     WHERE
 298         id = OLD.id;
 299
 300 CREATE OR REPLACE RULE query_expr_xex_delete_rule AS
 301     ON DELETE TO query.expr_xex
 302     DO INSTEAD
 303     DELETE FROM query.expression WHERE id = OLD.id;
 304
 305 -- Create updatable view for field expressions
 306
 307 CREATE OR REPLACE VIEW query.expr_xfld AS
 308     SELECT
 309                 id,
 310                 parenthesize,
 311                 parent_expr,
 312                 seq_no,
 313                 column_name,
 314                 left_operand
 315     FROM
 316         query.expression
 317     WHERE
 318         type = 'xfld';
 319
 320 CREATE OR REPLACE RULE query_expr_xfld_insert_rule AS
 321     ON INSERT TO query.expr_xfld
 322     DO INSTEAD
 323     INSERT INTO query.expression (
 324                 id,
 325                 type,
 326                 parenthesize,
 327                 parent_expr,
 328                 seq_no,
 329                 column_name,
 330                 left_operand
 331     ) VALUES (
 332         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 333         'xfld',
 334         COALESCE(NEW.parenthesize, FALSE),
 335         NEW.parent_expr,
 336         COALESCE(NEW.seq_no, 1),
 337                 NEW.column_name,
 338                 NEW.left_operand
 339     );
 340
 341 CREATE OR REPLACE RULE query_expr_xfld_update_rule AS
 342     ON UPDATE TO query.expr_xfld
 343     DO INSTEAD
 344     UPDATE query.expression SET
 345         id = NEW.id,
 346         parenthesize = NEW.parenthesize,
 347         parent_expr = NEW.parent_expr,
 348         seq_no = NEW.seq_no,
 349                 column_name = NEW.column_name,
 350                 left_operand = NEW.left_operand
 351     WHERE
 352         id = OLD.id;
 353
 354 CREATE OR REPLACE RULE query_expr_xfld_delete_rule AS
 355     ON DELETE TO query.expr_xfld
 356     DO INSTEAD
 357     DELETE FROM query.expression WHERE id = OLD.id;
 358
 359 -- Create updatable view for function call expressions
 360
 361 CREATE OR REPLACE VIEW query.expr_xfunc AS
 362     SELECT
 363                 id,
 364                 parenthesize,
 365                 parent_expr,
 366                 seq_no,
 367                 function_id
 368     FROM
 369         query.expression
 370     WHERE
 371         type = 'xfunc';
 372
 373 CREATE OR REPLACE RULE query_expr_xfunc_insert_rule AS
 374     ON INSERT TO query.expr_xfunc
 375     DO INSTEAD
 376     INSERT INTO query.expression (
 377                 id,
 378                 type,
 379                 parenthesize,
 380                 parent_expr,
 381                 seq_no,
 382                 function_id
 383     ) VALUES (
 384         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 385         'xfunc',
 386         COALESCE(NEW.parenthesize, FALSE),
 387         NEW.parent_expr,
 388         COALESCE(NEW.seq_no, 1),
 389                 NEW.function_id
 390     );
 391
 392 CREATE OR REPLACE RULE query_expr_xfunc_update_rule AS
 393     ON UPDATE TO query.expr_xfunc
 394     DO INSTEAD
 395     UPDATE query.expression SET
 396         id = NEW.id,
 397         parenthesize = NEW.parenthesize,
 398         parent_expr = NEW.parent_expr,
 399         seq_no = NEW.seq_no,
 400                 function_id = NEW.function_id
 401     WHERE
 402         id = OLD.id;
 403
 404 CREATE OR REPLACE RULE query_expr_xfunc_delete_rule AS
 405     ON DELETE TO query.expr_xfunc
 406     DO INSTEAD
 407     DELETE FROM query.expression WHERE id = OLD.id;
 408
 409 -- Create updatable view for IN expressions
 410
 411 CREATE OR REPLACE VIEW query.expr_xin AS
 412     SELECT
 413                 id,
 414                 parenthesize,
 415                 parent_expr,
 416                 seq_no,
 417                 subquery
 418     FROM
 419         query.expression
 420     WHERE
 421         type = 'xin';
 422
 423 CREATE OR REPLACE RULE query_expr_xin_insert_rule AS
 424     ON INSERT TO query.expr_xin
 425     DO INSTEAD
 426     INSERT INTO query.expression (
 427                 id,
 428                 type,
 429                 parenthesize,
 430                 parent_expr,
 431                 seq_no,
 432                 subquery
 433     ) VALUES (
 434         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 435         'xin',
 436         COALESCE(NEW.parenthesize, FALSE),
 437         NEW.parent_expr,
 438         COALESCE(NEW.seq_no, 1),
 439                 NEW.subquery
 440     );
 441
 442 CREATE OR REPLACE RULE query_expr_xin_update_rule AS
 443     ON UPDATE TO query.expr_xin
 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                 subquery = NEW.subquery
 451     WHERE
 452         id = OLD.id;
 453
 454 CREATE OR REPLACE RULE query_expr_xin_delete_rule AS
 455     ON DELETE TO query.expr_xin
 456     DO INSTEAD
 457     DELETE FROM query.expression WHERE id = OLD.id;
 458
 459 -- Create updatable view for NOT BETWEEN expressions
 460
 461 CREATE OR REPLACE VIEW query.expr_xnbet AS
 462     SELECT
 463                 id,
 464                 parenthesize,
 465                 parent_expr,
 466                 seq_no
 467     FROM
 468         query.expression
 469     WHERE
 470         type = 'xnbet';
 471
 472 CREATE OR REPLACE RULE query_expr_xnbet_insert_rule AS
 473     ON INSERT TO query.expr_xnbet
 474     DO INSTEAD
 475     INSERT INTO query.expression (
 476                 id,
 477                 type,
 478                 parenthesize,
 479                 parent_expr,
 480                 seq_no
 481     ) VALUES (
 482         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 483         'xnbet',
 484         COALESCE(NEW.parenthesize, FALSE),
 485         NEW.parent_expr,
 486         COALESCE(NEW.seq_no, 1)
 487     );
 488
 489 CREATE OR REPLACE RULE query_expr_xnbet_update_rule AS
 490     ON UPDATE TO query.expr_xnbet
 491     DO INSTEAD
 492     UPDATE query.expression SET
 493         id = NEW.id,
 494         parenthesize = NEW.parenthesize,
 495         parent_expr = NEW.parent_expr,
 496         seq_no = NEW.seq_no
 497     WHERE
 498         id = OLD.id;
 499
 500 CREATE OR REPLACE RULE query_expr_xnbet_delete_rule AS
 501     ON DELETE TO query.expr_xnbet
 502     DO INSTEAD
 503     DELETE FROM query.expression WHERE id = OLD.id;
 504
 505 -- Create updatable view for NOT EXISTS expressions
 506
 507 CREATE OR REPLACE VIEW query.expr_xnex AS
 508     SELECT
 509                 id,
 510                 parenthesize,
 511                 parent_expr,
 512                 seq_no,
 513                 subquery
 514     FROM
 515         query.expression
 516     WHERE
 517         type = 'xnex';
 518
 519 CREATE OR REPLACE RULE query_expr_xnex_insert_rule AS
 520     ON INSERT TO query.expr_xnex
 521     DO INSTEAD
 522     INSERT INTO query.expression (
 523                 id,
 524                 type,
 525                 parenthesize,
 526                 parent_expr,
 527                 seq_no,
 528                 subquery
 529     ) VALUES (
 530         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 531         'xnex',
 532         COALESCE(NEW.parenthesize, FALSE),
 533         NEW.parent_expr,
 534         COALESCE(NEW.seq_no, 1),
 535                 NEW.subquery
 536     );
 537
 538 CREATE OR REPLACE RULE query_expr_xnex_update_rule AS
 539     ON UPDATE TO query.expr_xnex
 540     DO INSTEAD
 541     UPDATE query.expression SET
 542         id = NEW.id,
 543         parenthesize = NEW.parenthesize,
 544         parent_expr = NEW.parent_expr,
 545         seq_no = NEW.seq_no,
 546                 subquery = NEW.subquery
 547     WHERE
 548         id = OLD.id;
 549
 550 CREATE OR REPLACE RULE query_expr_xnex_delete_rule AS
 551     ON DELETE TO query.expr_xnex
 552     DO INSTEAD
 553     DELETE FROM query.expression WHERE id = OLD.id;
 554
 555 -- Create updatable view for NOT IN expressions
 556
 557 CREATE OR REPLACE VIEW query.expr_xnin AS
 558     SELECT
 559                 id,
 560                 parenthesize,
 561                 parent_expr,
 562                 seq_no,
 563                 subquery
 564     FROM
 565         query.expression
 566     WHERE
 567         type = 'xnin';
 568
 569 CREATE OR REPLACE RULE query_expr_xnin_insert_rule AS
 570     ON INSERT TO query.expr_xnin
 571     DO INSTEAD
 572     INSERT INTO query.expression (
 573                 id,
 574                 type,
 575                 parenthesize,
 576                 parent_expr,
 577                 seq_no,
 578                 subquery
 579     ) VALUES (
 580         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 581         'xnin',
 582         COALESCE(NEW.parenthesize, FALSE),
 583         NEW.parent_expr,
 584         COALESCE(NEW.seq_no, 1),
 585                 NEW.subquery
 586     );
 587
 588 CREATE OR REPLACE RULE query_expr_xnin_update_rule AS
 589     ON UPDATE TO query.expr_xnin
 590     DO INSTEAD
 591     UPDATE query.expression SET
 592         id = NEW.id,
 593         parenthesize = NEW.parenthesize,
 594         parent_expr = NEW.parent_expr,
 595         seq_no = NEW.seq_no,
 596                 subquery = NEW.subquery
 597     WHERE
 598         id = OLD.id;
 599
 600 CREATE OR REPLACE RULE query_expr_xnin_delete_rule AS
 601     ON DELETE TO query.expr_xnin
 602     DO INSTEAD
 603     DELETE FROM query.expression WHERE id = OLD.id;
 604
 605 -- Create updatable view for NULL expressions
 606
 607 CREATE OR REPLACE VIEW query.expr_xnull AS
 608     SELECT
 609                 id,
 610                 parenthesize,
 611                 parent_expr,
 612                 seq_no
 613     FROM
 614         query.expression
 615     WHERE
 616         type = 'xnull';
 617
 618 CREATE OR REPLACE RULE query_expr_xnull_insert_rule AS
 619     ON INSERT TO query.expr_xnull
 620     DO INSTEAD
 621     INSERT INTO query.expression (
 622                 id,
 623                 type,
 624                 parenthesize,
 625                 parent_expr,
 626                 seq_no
 627     ) VALUES (
 628         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 629         'xnull',
 630         COALESCE(NEW.parenthesize, FALSE),
 631         NEW.parent_expr,
 632         COALESCE(NEW.seq_no, 1)
 633     );
 634
 635 CREATE OR REPLACE RULE query_expr_xnull_update_rule AS
 636     ON UPDATE TO query.expr_xnull
 637     DO INSTEAD
 638     UPDATE query.expression SET
 639         id = NEW.id,
 640         parenthesize = NEW.parenthesize,
 641         parent_expr = NEW.parent_expr,
 642         seq_no = NEW.seq_no
 643     WHERE
 644         id = OLD.id;
 645
 646 CREATE OR REPLACE RULE query_expr_xnull_delete_rule AS
 647     ON DELETE TO query.expr_xnull
 648     DO INSTEAD
 649     DELETE FROM query.expression WHERE id = OLD.id;
 650
 651 -- Create updatable view for numeric literal expressions
 652
 653 CREATE OR REPLACE VIEW query.expr_xnum AS
 654     SELECT
 655                 id,
 656                 parenthesize,
 657                 parent_expr,
 658                 seq_no,
 659                 literal
 660     FROM
 661         query.expression
 662     WHERE
 663         type = 'xnum';
 664
 665 CREATE OR REPLACE RULE query_expr_xnum_insert_rule AS
 666     ON INSERT TO query.expr_xnum
 667     DO INSTEAD
 668     INSERT INTO query.expression (
 669                 id,
 670                 type,
 671                 parenthesize,
 672                 parent_expr,
 673                 seq_no,
 674                 literal
 675     ) VALUES (
 676         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 677         'xnum',
 678         COALESCE(NEW.parenthesize, FALSE),
 679         NEW.parent_expr,
 680         COALESCE(NEW.seq_no, 1),
 681         NEW.literal
 682     );
 683
 684 CREATE OR REPLACE RULE query_expr_xnum_update_rule AS
 685     ON UPDATE TO query.expr_xnum
 686     DO INSTEAD
 687     UPDATE query.expression SET
 688         id = NEW.id,
 689         parenthesize = NEW.parenthesize,
 690         parent_expr = NEW.parent_expr,
 691         seq_no = NEW.seq_no,
 692         literal = NEW.literal
 693     WHERE
 694         id = OLD.id;
 695
 696 CREATE OR REPLACE RULE query_expr_xnum_delete_rule AS
 697     ON DELETE TO query.expr_xnum
 698     DO INSTEAD
 699     DELETE FROM query.expression WHERE id = OLD.id;
 700
 701 -- Create updatable view for operator expressions
 702
 703 CREATE OR REPLACE VIEW query.expr_xop AS
 704     SELECT
 705                 id,
 706                 parenthesize,
 707                 parent_expr,
 708                 seq_no,
 709                 left_operand,
 710                 operator,
 711                 right_operand
 712     FROM
 713         query.expression
 714     WHERE
 715         type = 'xop';
 716
 717 CREATE OR REPLACE RULE query_expr_xop_insert_rule AS
 718     ON INSERT TO query.expr_xop
 719     DO INSTEAD
 720     INSERT INTO query.expression (
 721                 id,
 722                 type,
 723                 parenthesize,
 724                 parent_expr,
 725                 seq_no,
 726                 left_operand,
 727                 operator,
 728                 right_operand
 729     ) VALUES (
 730         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 731         'xop',
 732         COALESCE(NEW.parenthesize, FALSE),
 733         NEW.parent_expr,
 734         COALESCE(NEW.seq_no, 1),
 735                 NEW.left_operand,
 736                 NEW.operator,
 737                 NEW.right_operand
 738     );
 739
 740 CREATE OR REPLACE RULE query_expr_xop_update_rule AS
 741     ON UPDATE TO query.expr_xop
 742     DO INSTEAD
 743     UPDATE query.expression SET
 744         id = NEW.id,
 745         parenthesize = NEW.parenthesize,
 746         parent_expr = NEW.parent_expr,
 747         seq_no = NEW.seq_no,
 748                 left_operand = NEW.left_operand,
 749                 operator = NEW.operator,
 750                 right_operand = NEW.right_operand
 751     WHERE
 752         id = OLD.id;
 753
 754 CREATE OR REPLACE RULE query_expr_xop_delete_rule AS
 755     ON DELETE TO query.expr_xop
 756     DO INSTEAD
 757     DELETE FROM query.expression WHERE id = OLD.id;
 758
 759 -- Create updatable view for subquery expressions
 760
 761 CREATE OR REPLACE VIEW query.expr_xsubq AS
 762     SELECT
 763                 id,
 764                 parenthesize,
 765                 parent_expr,
 766                 seq_no,
 767                 subquery
 768     FROM
 769         query.expression
 770     WHERE
 771         type = 'xsubq';
 772
 773 CREATE OR REPLACE RULE query_expr_xsubq_insert_rule AS
 774     ON INSERT TO query.expr_xsubq
 775     DO INSTEAD
 776     INSERT INTO query.expression (
 777                 id,
 778                 type,
 779                 parenthesize,
 780                 parent_expr,
 781                 seq_no,
 782                 subquery
 783     ) VALUES (
 784         COALESCE(NEW.id, NEXTVAL('query.expression_id_seq'::REGCLASS)),
 785         'xsubq',
 786         COALESCE(NEW.parenthesize, FALSE),
 787         NEW.parent_expr,
 788         COALESCE(NEW.seq_no, 1),
 789                 NEW.subquery
 790     );
 791
 792 CREATE OR REPLACE RULE query_expr_xsubq_update_rule AS
 793     ON UPDATE TO query.expr_xsubq
 794     DO INSTEAD
 795     UPDATE query.expression SET
 796         id = NEW.id,
 797         parenthesize = NEW.parenthesize,
 798         parent_expr = NEW.parent_expr,
 799         seq_no = NEW.seq_no,
 800                 subquery = NEW.subquery
 801     WHERE
 802         id = OLD.id;
 803
 804 CREATE OR REPLACE RULE query_expr_xsubq_delete_rule AS
 805     ON DELETE TO query.expr_xsubq
 806     DO INSTEAD
 807     DELETE FROM query.expression WHERE id = OLD.id;
 808
 809 COMMIT;