Return to util.c CVS log

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

Annotation of 42BSD/ingres/source/qrymod/util.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <symbol.h>
        !             4: # include      <tree.h>
        !             5: # include      "qrymod.h"
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)util.c      7.1     2/5/81)
        !             9: 
        !            10: /*
        !            11: **  TRIMQLEND -- trim QLEND node off of qualification
        !            12: **
        !            13: **     The QLEND node, and possible the AND node preceeding it,
        !            14: **     are trimmed off.  The result of this routine should be
        !            15: **     a very ordinary tree like you might see in some textbook.
        !            16: **
        !            17: **     A fast not on the algorithm: the pointer 't' points to the
        !            18: **     current node (the one which we are checking for a QLEND).
        !            19: **     's' points to 't's parent, and 'r' points to 's's parent;
        !            20: **     'r' is NULL at the top of the tree.
        !            21: **
        !            22: **     This routine works correctly on trees with no QLEND in
        !            23: **     the first place, returning the original tree.
        !            24: **
        !            25: **     If there is a QLEND, it must be on the far right branch
        !            26: **     of the tree, that is, the tree must be INGRES-canonical.
        !            27: **
        !            28: **     Parameters:
        !            29: **             qual -- the qualification to be trimmed.
        !            30: **
        !            31: **     Returns:
        !            32: **             A pointer to the new qualification.
        !            33: **             NULL if the qualification was null once the
        !            34: **                     QLEND is stripped.
        !            35: **
        !            36: **     Side Effects:
        !            37: **             The tree pointed to by 'qual' may be modified.
        !            38: **
        !            39: **     Trace Flags:
        !            40: **             none
        !            41: */
        !            42: 
        !            43: QTREE *
        !            44: trimqlend(qual)
        !            45: QTREE  *qual;
        !            46: {
        !            47:        register QTREE  *t;
        !            48:        register QTREE  *s;
        !            49:        register QTREE  *r;
        !            50: 
        !            51:        t = qual;
        !            52: 
        !            53:        /* check for the simple null qualification case */
        !            54:        if (t == NULL || t->sym.type == QLEND)
        !            55:                return (NULL);
        !            56:        
        !            57:        /* scan tree for QLEND node */
        !            58:        for (r = NULL, s = t; (t = t->right) != NULL; r = s, s = t)
        !            59:        {
        !            60:                if (t->sym.type == QLEND)
        !            61:                {
        !            62:                        /* trim of QLEND and AND node */
        !            63:                        if (r == NULL)
        !            64:                        {
        !            65:                                /* only one AND -- return its operand */
        !            66:                                return (s->left);
        !            67:                        }
        !            68: 
        !            69:                        r->right = s->left;
        !            70:                        break;
        !            71:                }
        !            72:        }
        !            73: 
        !            74:        /* return tree with final AND node and QLEND node pruned */
        !            75:        return (qual);
        !            76: }
        !            77: /*
        !            78: **  APPQUAL -- append qualification to tree
        !            79: **
        !            80: **     The qualification is conjoined to the qualificaion of the
        !            81: **     tree which is passed.
        !            82: **
        !            83: **     Parameters:
        !            84: **             qual -- a pointer to the qualification to be appended.
        !            85: **             root -- a pointer to the tree to be appended to.
        !            86: **
        !            87: **     Returns:
        !            88: **             none
        !            89: **
        !            90: **     Side Effects:
        !            91: **             Both 'qual' ad 'root' may be modified.  Note that
        !            92: **                     'qual' is linked into 'root', and must be
        !            93: **                     retained.
        !            94: **
        !            95: **     Trace Flags:
        !            96: **             13
        !            97: */
        !            98: 
        !            99: appqual(qual, root)
        !           100: QTREE  *qual;
        !           101: QTREE  *root;
        !           102: {
        !           103:        register QTREE  *p;
        !           104:        register QTREE  *r;
        !           105: 
        !           106:        r = root;
        !           107: #      ifdef xQTR3
        !           108:        if (r == NULL)
        !           109:                syserr("appqual: NULL root");
        !           110: #      endif
        !           111: 
        !           112:        /*
        !           113:        **  Find node before QLEND node
        !           114:        **      p points the node we are examining, r points to
        !           115:        **      it's parent.
        !           116:        */
        !           117: 
        !           118:        while ((p = r->right) != NULL && p->sym.type != QLEND)
        !           119:        {
        !           120: #              ifdef xQTR3
        !           121:                if (p->sym.type != AND)
        !           122:                        syserr("appqual: node %d", p->sym.type);
        !           123: #              endif
        !           124:                r = p;
        !           125:        }
        !           126:        
        !           127:        /* link in qualification */
        !           128:        r->right = qual;
        !           129: }
        !           130: /*
        !           131: **  QMERROR -- issue fatal error message and abort query
        !           132: **
        !           133: **     This call is almost exactly like 'error' (which is called),
        !           134: **     but never returns: the return is done by 'reset'.  Also, the
        !           135: **     R_up pipe is flushed.
        !           136: **
        !           137: **     Parameters:
        !           138: **             errno -- the error number.
        !           139: **             qmode -- the query mode to pass as $0, -1 if none.
        !           140: **             vn -- the varno of the relation name to pass as
        !           141: **                     $1, -1 if none.
        !           142: **             p1 to p5 -- the parameters $2 through $6
        !           143: **
        !           144: **     Returns:
        !           145: **             non-local (via reset())
        !           146: **
        !           147: **     Side Effects:
        !           148: **             The error message is generated.
        !           149: **
        !           150: **     Trace Flags:
        !           151: **             none
        !           152: */
        !           153: 
        !           154: char *QmdName[] =
        !           155: {
        !           156:        "[ERROR]",      /* 0 = mdRETTERM */
        !           157:        "RETRIEVE",     /* 1 = mdRETR */
        !           158:        "APPEND",       /* 2 = mdAPP */
        !           159:        "REPLACE",      /* 3 = mdREPL */
        !           160:        "DELETE",       /* 4 = mdDEL */
        !           161:        "",             /* 5 = mdCOPY */
        !           162:        "",             /* 6 = mdCREATE */
        !           163:        "",             /* 7 = mdDESTROY */
        !           164:        "",             /* 8 = mdHELP */
        !           165:        "",             /* 9 = mdINDEX */
        !           166:        "",             /* 10 = mdMODIFY */
        !           167:        "",             /* 11 = mdPRINT */
        !           168:        "",             /* 12 = mdRANGE */
        !           169:        "",             /* 13 = mdSAVE */
        !           170:        "DEFINE",       /* 14 = mdDEFINE */
        !           171:        "RET_UNIQUE",   /* 15 = mdRET_UNI */
        !           172:        "",             /* 16 = mdVIEW */
        !           173:        "",             /* 17 = mdUPDATE */
        !           174:        "",             /* 18 = mdRESETREL */
        !           175:        "",             /* 19 = mdERIC */
        !           176:        "",             /* 20 = mdNETQRY */
        !           177:        "",             /* 21 = mdMOVEREL */
        !           178:        "",             /* 22 = mdPROT */
        !           179:        "",             /* 23 = mdINTEG */
        !           180:        "",             /* 24 = mdDCREATE */
        !           181: };
        !           182: 
        !           183: 
        !           184: qmerror(errno, qmode, vn, p1, p2, p3, p4, p5, p6)
        !           185: int    errno;
        !           186: int    qmode;
        !           187: int    vn;
        !           188: char   *p1, *p2, *p3, *p4, *p5, *p6;
        !           189: {
        !           190:        register char           *x1;
        !           191:        register char           *x2;
        !           192:        char                    xbuf[MAXNAME + 1];
        !           193:        register int            i;
        !           194:        extern char             *trim_relname();
        !           195: 
        !           196:        /* set up qmode and varno parameters */
        !           197:        x1 = x2 = "";
        !           198:        i = qmode;
        !           199:        if (i >= 0)
        !           200:                x1 = QmdName[i];
        !           201:        i = vn;
        !           202:        if (i >= 0)
        !           203:                smove(trim_relname(Qt.qt_rangev[i].rngvdesc->reldum.relid),
        !           204:                      x2 = xbuf);
        !           205: 
        !           206:        /* issue the error message and exit */
        !           207:        error(errno, x1, x2, p1, p2, p3, p4, p5, p6, 0);
        !           208:        syserr("qmerror");
        !           209: }
        !           210: /*
        !           211: **  LSETBIT -- set a bit in a domain set
        !           212: **
        !           213: **     Parameters:
        !           214: **             bitno -- the bit number to set (0 -> 127)
        !           215: **             xset -- the set to set it in.
        !           216: **
        !           217: **     Returns:
        !           218: **             none
        !           219: **
        !           220: **     Side Effects:
        !           221: **             none
        !           222: */
        !           223: 
        !           224: lsetbit(bitno, xset)
        !           225: int    bitno;
        !           226: int    xset[8];
        !           227: {
        !           228:        register int    b;
        !           229:        register int    n;
        !           230:        register int    *x;
        !           231: 
        !           232:        x = xset;
        !           233: 
        !           234:        b = bitno;
        !           235:        n = b >> LOG2WORDSIZE;
        !           236:        b &= WORDSIZE - 1;
        !           237: 
        !           238:        x[n] |= 1 << b;
        !           239: }
        !           240: /*
        !           241: **  MERGEVAR -- merge variable numbers to link terms
        !           242: **
        !           243: **     One specified variable gets mapped into another, effectively
        !           244: **     merging those two variables.  This is used for protection
        !           245: **     and integrity, since the constraint read from the tree
        !           246: **     must coincide with one of the variables in the query tree.
        !           247: **
        !           248: **     Parameters:
        !           249: **             va -- the variable which will dissappear.
        !           250: **             vb -- the variable which 'va' gets mapped into.
        !           251: **             root -- the root of the tree to map.
        !           252: **
        !           253: **     Returns:
        !           254: **             none
        !           255: **
        !           256: **     Side Effects:
        !           257: **             The tree pointed at by 'root' gets VAR and RESDOM
        !           258: **                     nodes mapped.
        !           259: **             Range table entry for 'va' is deallocated.
        !           260: **             The 'Qt.qt_remap' vector gets reset and left in an
        !           261: **                     undefined state.
        !           262: **
        !           263: **     Trace Flags:
        !           264: **             72
        !           265: */
        !           266: 
        !           267: mergevar(a, b, root)
        !           268: register int   a;
        !           269: register int   b;
        !           270: QTREE          *root;
        !           271: {
        !           272:        register int    i;
        !           273: 
        !           274: #      ifdef xQTR1
        !           275:        if (tTf(72, 0))
        !           276:        {
        !           277:                printf("\nmergevar(%d->%d)", a, b);
        !           278:                treepr(root, NULL);
        !           279:        }
        !           280: #      endif
        !           281: 
        !           282:        /*
        !           283:        **  Insure that 'a' and 'b' are consistant, that is,
        !           284:        **  that they both are in range, are defined, and range over
        !           285:        **  the same relation.
        !           286:        */
        !           287: 
        !           288:        if (a < 0 || b < 0 || a >= MAXVAR + 1 || b >= MAXVAR + 1)
        !           289:                syserr("mergevar: range %d %d", a, b);
        !           290:        if (Qt.qt_rangev[a].rngvdesc == NULL || Qt.qt_rangev[b].rngvdesc == NULL)
        !           291:                syserr("mergevar: undef %d %d", a, b);
        !           292:        if (!bequal(Qt.qt_rangev[a].rngvdesc->reldum.relid,
        !           293:                    Qt.qt_rangev[b].rngvdesc->reldum.relid, MAXNAME) ||
        !           294:            !bequal(Qt.qt_rangev[a].rngvdesc->reldum.relowner,
        !           295:                    Qt.qt_rangev[b].rngvdesc->reldum.relowner, 2))
        !           296:        {
        !           297:                syserr("mergevar: incon %.14s %.14s",
        !           298:                    Qt.qt_rangev[a].rngvdesc->reldum.relid,
        !           299:                    Qt.qt_rangev[b].rngvdesc->reldum.relid);
        !           300:        }
        !           301:        
        !           302:        /*
        !           303:        **  To do the actual mapping, we will set up 'Qt.qt_remap' and
        !           304:        **  call 'mapvars()'.  This is because I am too lazy to
        !           305:        **  do it myself.
        !           306:        */
        !           307: 
        !           308:        for (i = 0; i < MAXRANGE; i++)
        !           309:                Qt.qt_remap[i] = i;
        !           310:        Qt.qt_remap[a] = b;
        !           311:        mapvars(root);
        !           312: 
        !           313:        /* delete a from the range table */
        !           314:        declare(a, NULL);
        !           315: }
        !           316: /*
        !           317: **  MAKEZERO -- make a node with value 'zero'
        !           318: **
        !           319: **     A node is created with value representing the zero value
        !           320: **     for the specified type, that is, 0 for integers, 0.0 for
        !           321: **     floats, and the blank string for chars.
        !           322: **
        !           323: **     Parameters:
        !           324: **             typ -- the node type.
        !           325: **
        !           326: **     Returns:
        !           327: **             a pointer to the zero node.
        !           328: **
        !           329: **     Side Effects:
        !           330: **             space is grabbed from Qbuf
        !           331: */
        !           332: 
        !           333: QTREE *
        !           334: makezero(typ)
        !           335: int    typ;
        !           336: {
        !           337:        register int            l;
        !           338:        register QTREE          *s;
        !           339:        int                     symbuf[(sizeof *s) / sizeof l]; /*word aligned*/
        !           340:        extern char             *need();
        !           341: 
        !           342:        s = (QTREE *) symbuf;
        !           343:        s->sym.type = typ;
        !           344: 
        !           345:        switch (typ)
        !           346:        {
        !           347:          case INT:
        !           348:                s->sym.len = l = 2;
        !           349:                s->sym.value.sym_data.i2type = 0;
        !           350:                break;
        !           351: 
        !           352:          case FLOAT:
        !           353:                s->sym.len = l = 4;
        !           354:                s->sym.value.sym_data.f4type = 0.0;
        !           355:                break;
        !           356: 
        !           357:          case CHAR:
        !           358:                s->sym.len = l = 2;
        !           359:                s->sym.value.sym_data.i2type = '  ';    /* (two spaces) */
        !           360:                break;
        !           361: 
        !           362:          default:
        !           363:                syserr("makezero: typ %d", typ);
        !           364:        }
        !           365: 
        !           366:        /* duplicate the node into Qbuf */
        !           367:        l += 2 + 2 * QT_HDR_SIZ;        /* size of type + len + left + right */
        !           368:        s = (QTREE *) need(Qbuf, l);
        !           369:        bmove(symbuf, s, l);
        !           370:        return (s);
        !           371: }

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