Open-ILS/src/sql/Pg/upgrade/0253.schema.query_expr_view.sql

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