Return to integrity.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / qrymod

Annotation of 43BSD/ingres/source/qrymod/integrity.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <catalog.h>
        !             4: # include      <access.h>
        !             5: # include      <tree.h>
        !             6: # include      <symbol.h>
        !             7: # include      "qrymod.h"
        !             8: # include      <sccs.h>
        !             9: 
        !            10: SCCSID(@(#)integrity.c 8.3     5/12/85)
        !            11: 
        !            12: /*
        !            13: **  INTEGRITY.C -- Integrity Constraint Processor
        !            14: **
        !            15: **     This module contains the integrity constraint processor.  This
        !            16: **     processor modifies the query to add integrity constraints.
        !            17: **
        !            18: **     Currently only single-variable aggregate-free constraints are
        !            19: **     handled.  Thus the algorithm is reduced to scanning the tree
        !            20: **     for each variable modified and appending the constraints for
        !            21: **     that variable to the tree.
        !            22: **
        !            23: **     Parameters:
        !            24: **             none
        !            25: **
        !            26: **     Returns:
        !            27: **             The root of the modified tree.
        !            28: **
        !            29: **     Side Effects:
        !            30: **             Much relation I/O.
        !            31: **             Modifies the tree in place, so the previous one is
        !            32: **                     lost.
        !            33: **
        !            34: **     Trace Flags:
        !            35: **             40 -> 49
        !            36: */
        !            37: 
        !            38: extern DESC    Intdes;
        !            39: 
        !            40: QTREE *
        !            41: integrity(root)
        !            42: QTREE  *root;
        !            43: {
        !            44:        register QTREE          *r;
        !            45:        int                     dset[8];
        !            46:        register QTREE          *p;
        !            47:        register int            i;
        !            48:        auto QTREE              *iqual;
        !            49:        struct integrity        inttup, intkey;
        !            50:        struct tup_id           hitid, lotid;
        !            51:        extern QTREE            *gettree();
        !            52:        extern QTREE            *norml();
        !            53: 
        !            54: #      ifdef xQTR1
        !            55:        tTfp(40, -1, "\n->INTEGRITY\n");
        !            56: #      endif
        !            57: 
        !            58:        r = root;
        !            59: 
        !            60:        /*
        !            61:        **  Check to see if we should apply the integrity
        !            62:        **  algorithm.
        !            63:        **
        !            64:        **  This means checking to insure that we have an update
        !            65:        **  and seeing if any integrity constraints apply.
        !            66:        */
        !            67: 
        !            68:        if (Qt.qt_qmode == mdRETR || Qt.qt_qmode == mdRET_UNI ||
        !            69:            (Qt.qt_rangev[Qt.qt_resvar].rngvdesc->reldum.relstat & S_INTEG) == 0)
        !            70:        {
        !            71: #              ifdef xQTR2
        !            72:                tTfp(40, 0, "->INTEGRITY: no integ\n");
        !            73: #              endif
        !            74:                return(r);
        !            75:        }
        !            76: 
        !            77:        /*
        !            78:        **  Create a set of the domains updated in this query.
        !            79:        */
        !            80: 
        !            81:        for (i = 0; i < 8; i++)
        !            82:                dset[i] = 0;
        !            83:        for (p = r->left; p != NULL && p->sym.type != TREE; p = p->left)
        !            84:        {
        !            85: #              ifdef xQTR3
        !            86:                if (p->sym.type != RESDOM)
        !            87:                        syserr("integrity: RESDOM %d", p->sym.type);
        !            88: #              endif
        !            89:                lsetbit(p->sym.value.sym_resdom.resno, dset);
        !            90:        }
        !            91: 
        !            92: #      ifdef xQTR3
        !            93:        if (p == NULL)
        !            94:                syserr("integrity: NULL LHS");
        !            95: #      endif
        !            96: #      ifdef xQTR1
        !            97:        if (tTf(40, 1))
        !            98:                pr_set(dset, "dset");
        !            99: #      endif
        !           100:        
        !           101:        /*
        !           102:        **  Scan integrity catalog for possible tuples.  If found,
        !           103:        **  include them in the integrity qualification.
        !           104:        */
        !           105: 
        !           106:        iqual = NULL;
        !           107:        opencatalog("integrities", OR_READ);
        !           108:        setkey(&Intdes, &intkey, Qt.qt_rangev[Qt.qt_resvar].rngvdesc->reldum.relid, INTRELID);
        !           109:        setkey(&Intdes, &intkey, Qt.qt_rangev[Qt.qt_resvar].rngvdesc->reldum.relowner, INTRELOWNER);
        !           110:        find(&Intdes, EXACTKEY, &lotid, &hitid, &intkey);
        !           111: 
        !           112:        while ((i = get(&Intdes, &lotid, &hitid, &inttup, TRUE)) == 0)
        !           113:        {
        !           114:                if (kcompare(&Intdes, &intkey, &inttup) != 0)
        !           115:                        continue;
        !           116: 
        !           117: #              ifdef xQTR1
        !           118:                if (tTf(40, 2))
        !           119:                        printup(&Intdes, &inttup);
        !           120: #              endif
        !           121:                
        !           122:                /* check for some domain set overlap */
        !           123:                for (i = 0; i < 8; i++)
        !           124:                        if ((dset[i] & inttup.intdomset[i]) != 0)
        !           125:                                break;
        !           126:                if (i >= 8)
        !           127:                        continue;
        !           128:                
        !           129:                /* some domain matches, include in integrity qual */
        !           130:                i = Qt.qt_resvar;
        !           131:                p = gettree(Qt.qt_rangev[i].rngvdesc->reldum.relid,
        !           132:                            Qt.qt_rangev[i].rngvdesc->reldum.relowner,
        !           133:                            mdINTEG, inttup.inttree, FALSE);
        !           134: #              ifdef xQTR1
        !           135:                if (tTf(40, 3))
        !           136:                        treepr(p, "int_qual");
        !           137: #              endif
        !           138: 
        !           139:                /* trim off (null) target list */
        !           140:                p = p->right;
        !           141: 
        !           142:                /* merge the 'integrity' var into the Qt.qt_resvar */
        !           143:                i = inttup.intresvar;
        !           144:                if (Qt.qt_remap[i] >= 0)
        !           145:                        i = Qt.qt_remap[i];
        !           146:                mergevar(i, Qt.qt_resvar, p);
        !           147: 
        !           148:                /* add to integrity qual */
        !           149:                if (iqual == NULL)
        !           150:                        iqual = p;
        !           151:                else
        !           152:                        appqual(p, iqual);
        !           153:        }
        !           154:        if (i < 0)
        !           155:                syserr("integrity: get %d", i);
        !           156:        
        !           157:        /*
        !           158:        **  Clean up the integrity qualification so that it will merge
        !           159:        **  nicely into the tree, and then append it to the user's
        !           160:        **  qualification.
        !           161:        */
        !           162: 
        !           163:        if (iqual != NULL)
        !           164:        {
        !           165:                /* replace VAR nodes by corresponding user afcn */
        !           166:                subsvars(&iqual, Qt.qt_resvar, r->left, Qt.qt_qmode);
        !           167: 
        !           168:                /* append to tree and normalize */
        !           169:                appqual(iqual, r);
        !           170: #              ifdef xQTR3
        !           171:                if (tTf(40, 8))
        !           172:                        treepr(r, "Unnormalized tree");
        !           173: #              endif
        !           174:                r->right = norml(trimqlend(r->right));
        !           175:        }
        !           176: 
        !           177: #      ifdef xQTR1
        !           178:        if (tTf(40, 15))
        !           179:                treepr(r, "INTEGRITY->");
        !           180: #      endif
        !           181: 
        !           182:        return (r);
        !           183: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.