4.3BSD - /usr/ingres/source/dbu/pr_tree.c

   1: # include   <symbol.h>
   2: # include   <ingres.h>
   3: # include   <tree.h>
   4: # include   <aux.h>
   5: # include   <sccs.h>
   6: 
   7: SCCSID(@(#)pr_tree.c	8.2	1/15/85)
   8: 
   9: /*
  10: **  PR_TREE.C -- Query tree printing routines
  11: **
  12: **	Trace Flags:
  13: **		52
  14: */
  15: 
  16: 
  17: 
  18: 
  19: char    *pr_trim();
  20: char    *resultres();
  21: 
  22: struct tab
  23: {
  24:     char    t_opcode;
  25:     char    *t_string;
  26: };
  27: 
  28: 
  29: struct tab  Uop_tab[] =
  30: {
  31:     opPLUS,     "+ ",
  32:     opMINUS,    "- ",
  33:     opNOT,      "not[ERROR]",
  34:     opATAN,     "atan",
  35:     opCOS,      "cos",
  36:     opGAMMA,    "gamma",
  37:     opLOG,      "log",
  38:     opASCII,    "ascii",
  39:     opSIN,      "sin",
  40:     opSQRT,     "sqrt",
  41:     opABS,      "abs",
  42:     opEXP,      "exp",
  43:     opINT1,     "int1",
  44:     opINT2,     "int2",
  45:     opINT4,     "int4",
  46:     opFLOAT4,   "float4",
  47:     opFLOAT8,   "float8",
  48: };
  49: struct tab  Bop_tab[] =
  50: {
  51:     opADD,      "+",
  52:     opSUB,      "-",
  53:     opMUL,      "*",
  54:     opDIV,      "/",
  55:     opPOW,      "**",
  56:     opEQ,       "=",
  57:     opNE,       "!=",
  58:     opLT,       "<",
  59:     opLE,       "<=",
  60:     opGT,       ">",
  61:     opGE,       ">=",
  62:     opMOD,      "%",
  63: };
  64: 
  65: struct tab  Cop_tab[] =
  66: {
  67:     opDBA,      "dba",
  68:     opUSERCODE, "usercode",
  69:     opDATE,     "date",
  70:     opTIME,     "time",
  71: };
  72: 
  73: struct tab  Aop_tab[] =
  74: {
  75:     opCOUNT,    "count",
  76:     opCOUNTU,   "countu",
  77:     opSUM,      "sum",
  78:     opSUMU,     "sumu",
  79:     opAVG,      "avg",
  80:     opAVGU,     "avgu",
  81:     opMIN,      "min",
  82:     opMAX,      "max",
  83:     opANY,      "any",
  84: };
  85: 
  86: 
  87: DESC        Attdes;
  88: int     Tl_elm;
  89: int     Dom_num;
  90: char        *Resrel;
  91: /*
  92: **  PR_TREE
  93: **
  94: **	tree:	tl_clause ROOT tl_clause
  95: **
  96: **	prints out a tree assuming a mdVIEW-like mode
  97: **
  98: */
  99: 
 100: pr_tree(root)
 101: QTREE   *root;
 102: {
 103: 
 104: #	ifdef xZTR1
 105:     if (tTf(52, -1))
 106:         printf("pr_tree: root %u Resultvar %d Resrel %s\n",
 107:             root, Qt.qt_resvar, Resrel);
 108: #	endif
 109: 
 110:     printf("%s ", pr_trim(resultres(), MAXNAME));
 111: 
 112:     pr_dom_init();
 113:     Tl_elm = 0;
 114: 
 115:     /* print target list */
 116:     printf("(\n");
 117:     pr_tl_clause(root->left, TRUE);
 118:     putchar(')');
 119: 
 120:     /* print qualification */
 121:     if (root->right->sym.type != QLEND)
 122:     {
 123:                 printf("\nwhere ");
 124:         pr_qual(root->right);
 125:     }
 126:     putchar('\n');
 127: }
 128: /*
 129: **  PR_TL_CLAUSE
 130: **
 131: **	tl_clause:	TREE
 132: **		|	tl_clause RESDOM expr
 133: **
 134: ** target_flag = "in a target list (as opposed to in a by list)"
 135: */
 136: 
 137: pr_tl_clause(t_l, target_flag)
 138: QTREE       *t_l;
 139: register bool   target_flag;
 140: {
 141: 
 142: #	ifdef xZTR1
 143:     if (tTf(52, 1))
 144:         printf("tl_clause target %d Tl_elm %d\n", target_flag, Tl_elm);
 145: #	endif
 146: 
 147:     if (t_l->sym.type != TREE)
 148:     {
 149:         pr_tl_clause(t_l->left, target_flag);
 150:         if (Tl_elm)
 151:         {
 152:             printf(", ");
 153:             if (target_flag)
 154:                 putchar('\n');
 155:         }
 156:         /* print out info on result variable */
 157:         pr_resdom(t_l, target_flag);
 158:         pr_expr(t_l->right);
 159:         Tl_elm++;
 160:     }
 161: }
 162: /*
 163: **  PR_RESDOM
 164: **
 165: **	print out info on a result attribute.
 166: **	this will be done only if the RESDOM node
 167: **	is inside a target_list and if the Qt.qt_resvar >= 0.
 168: **	Qt.qt_resvar == -1 inside a target list indicates that this is
 169: **	a retrieve to terminal.
 170: */
 171: 
 172: pr_resdom(resdom, target_flag)
 173: QTREE   *resdom;
 174: int target_flag;
 175: {
 176: 
 177: #	ifdef xZTR1
 178:     if (tTf(52, 2))
 179:         printf("pr_resdom: target_flag %d\n", target_flag);
 180: #	endif
 181: 
 182:     if (target_flag)
 183:     {
 184:         printf("\t");
 185:         pr_attname(resultres(), resdom->sym.value.sym_resdom.resno);
 186:         printf(" = ");
 187:     }
 188: }
 189: /*
 190: **  PR_ATTNAME
 191: **
 192: **	give a relation name, and the attribute number of that
 193: **	relation, looks in the attribute relation for the name of the
 194: **	attribute.
 195: */
 196: 
 197: pr_attname(rel, attno)
 198: char    *rel;
 199: int attno;
 200: {
 201:     TID         tid;
 202:     struct attribute    key, tuple;
 203:     short           attnum;
 204:     register        i;
 205: 
 206: #	ifdef xZTR1
 207:     if (tTf(52, 3))
 208:         printf("pr_attname: rel %s attno %d\n",
 209:         rel, attno);
 210: #	endif
 211: 
 212:     if (attno == 0)
 213:     {
 214:         printf("tid");
 215:         return;
 216:     }
 217:     opencatalog("attribute", OR_READ);
 218:     clearkeys(&Attdes);
 219:     attnum = (short) attno;
 220:     setkey(&Attdes, &key, rel, ATTRELID);
 221:     setkey(&Attdes, &key, &attnum, ATTID);
 222:     i = getequal(&Attdes, &key, &tuple, &tid);
 223:     if (i)
 224:         syserr("pr_attname: bad getequal %d rel %s attno %d",
 225:         i, rel, attno);
 226:     printf("%s", pr_trim(tuple.attname, MAXNAME));
 227: }
 228: /*
 229: **  PR_EXPR
 230: **
 231: **	expr:		VAR
 232: **		|	expr BOP expr
 233: **		|	expr UOP
 234: **		|	AOP AGHEAD qual
 235: **			  \
 236: **			   expr
 237: **		|	BYHEAD	  AGHEAD qual
 238: **		        /    \
 239: **		tl_clause     AOP
 240: **				\
 241: **				 expr
 242: **		|	INT
 243: **		|	FLOAT
 244: **		| 	CHAR
 245: */
 246: 
 247: pr_expr(e)
 248: register QTREE  *e;
 249: {
 250:     register int    op;
 251:     register int    tl_elm;
 252: 
 253:     switch (e->sym.type)
 254:     {
 255:       case VAR:
 256:         pr_var(e);
 257:         break;
 258: 
 259:       case BOP:
 260:         if (e->sym.value.sym_op.opno == opCONCAT)
 261:         {
 262:             printf("concat(");
 263:             pr_expr(e->left);
 264:             printf(", ");
 265:             pr_expr(e->right);
 266:             putchar(')');
 267:         }
 268:         else
 269:         {
 270:             putchar('(');
 271:             pr_expr(e->left);
 272:             pr_op(BOP, e->sym.value.sym_op.opno);
 273:             pr_expr(e->right);
 274:             putchar(')');
 275:         }
 276:         break;
 277: 
 278:       case UOP:
 279:         if ((op = e->sym.value.sym_op.opno) == opMINUS || op == opPLUS || op == opNOT)
 280:         {
 281:             pr_op(UOP, e->sym.value.sym_op.opno);
 282:             pr_expr(e->left);
 283:             putchar(')');
 284:         }
 285:         else
 286:         {
 287:             /* functional operators */
 288:             pr_op(UOP, e->sym.value.sym_op.opno);
 289:             pr_expr(e->left);
 290:             putchar(')');
 291:         }
 292:         break;
 293: 
 294:       case AGHEAD:
 295:         if (e->left->sym.type == AOP)
 296:         {
 297:             /* simple aggregate */
 298:             pr_op(AOP, e->left->sym.value.sym_op.opno);
 299:             pr_expr(e->left->right);
 300:             if (e->right->sym.type != QLEND)
 301:             {
 302:                 printf("\where ");
 303:                 pr_qual(e->right);
 304:             }
 305:             putchar(')');
 306:         }
 307:         else
 308:         {
 309:             /* aggregate function */
 310:             pr_op(AOP, e->left->right->sym.value.sym_op.opno);
 311:             pr_expr(e->left->right->right);
 312:             printf(" by ");
 313:             /* avoid counting target list elements
 314: 			 * in determining wether to put out
 315: 			 * commas after list's elements
 316: 			 */
 317:             tl_elm = Tl_elm;
 318:             Tl_elm = 0;
 319:             pr_tl_clause(e->left->left, FALSE);
 320:             Tl_elm = tl_elm;
 321:             if (e->right->sym.type != QLEND)
 322:             {
 323:                 printf("\n\t\twhere ");
 324:                 pr_qual(e->right);
 325:             }
 326:             putchar(')');
 327:         }
 328:         break;
 329: 
 330:       case INT:
 331:       case FLOAT:
 332:       case CHAR:
 333:         pr_const(e);
 334:         break;
 335: 
 336:       default:
 337:         syserr("expr %d", e->sym.type);
 338:     }
 339: }
 340: /*
 341: **  PR_CONST -- print constant
 342: */
 343: 
 344: pr_const(c)
 345: register QTREE  *c;
 346: {
 347:     register char   *cp;
 348:     register int    i;
 349:     char        ch;
 350:     double      d;
 351: 
 352:     switch (c->sym.type)
 353:     {
 354:       case INT:
 355:         if (c->sym.len == 1)
 356:             printf("%d", c->sym.value.sym_data.i1type);
 357:         else if (c->sym.len == 2)
 358:             printf("%d", c->sym.value.sym_data.i2type);
 359:         else    /* i4 */
 360:             printf("%D", c->sym.value.sym_data.i4type);
 361:         break;
 362: 
 363:       case FLOAT:
 364:         if (c->sym.len == 4)
 365:             d = c->sym.value.sym_data.f4type;
 366:         else
 367:             d = c->sym.value.sym_data.f8type;
 368:         printf("%-10.3f", c->sym.value.sym_data.f8type);
 369:         break;
 370: 
 371:       case CHAR:
 372:         printf("\"");
 373:         cp = c->sym.value.sym_data.c0type;
 374:         for (i = c->sym.len; i--; cp++)
 375:         {
 376:             if (any(*cp, "\"\\[]*?") == TRUE)
 377:                 putchar('\\');
 378: 
 379:             if (*cp >= ' ')
 380:             {
 381:                 putchar(*cp);
 382:                 continue;
 383:             }
 384:             /* perform pattern matching character replacement */
 385:             switch (*cp)
 386:             {
 387:               case PAT_ANY:
 388:                 ch = '*';
 389:                 break;
 390: 
 391:               case PAT_ONE:
 392:                 ch = '?';
 393:                 break;
 394: 
 395:               case PAT_LBRAC:
 396:                 ch = '[';
 397:                 break;
 398: 
 399:               case PAT_RBRAC:
 400:                 ch = ']';
 401:                 break;
 402: 
 403:               default:
 404:                 ch = *cp;
 405:             }
 406:             putchar(ch);
 407:         }
 408:         putchar('"');
 409:         break;
 410: 
 411:       default:
 412:         syserr("bad constant %d", c->sym.type);
 413:     }
 414: }
 415: /*
 416: **  PR_OP -- print out operator of a certain type
 417: */
 418: 
 419: pr_op(op_type, op_code)
 420: int     op_type;
 421: register int    op_code;
 422: {
 423:     register struct tab *s;
 424: 
 425:     switch (op_type)
 426:     {
 427:       case UOP:
 428:         s = &Uop_tab[op_code];
 429:         printf("%s(", s->t_string);
 430:         break;
 431: 
 432:       case BOP:
 433:         s = &Bop_tab[op_code];
 434:         printf(" %s ", s->t_string);
 435:         break;
 436: 
 437:       case AOP:
 438:         s = &Aop_tab[op_code];
 439:         printf("%s(", s->t_string);
 440:         break;
 441: 
 442:       case COP:
 443:         s = &Cop_tab[op_code];
 444:         printf("%s", s->t_string);
 445:         break;
 446:     }
 447:     if (op_code != s->t_opcode)
 448:         syserr("pr_op: op in wrong place type %d, code %d", op_type,
 449:         s->t_opcode);
 450: }
 451: /*
 452: **  PR_VAR
 453: **
 454: **	print a VAR node: that is, a var.attno pair
 455: **	at present the var part is the relation name over which var
 456: **	ranges.
 457: */
 458: 
 459: pr_var(var)
 460: QTREE   *var;
 461: {
 462: 
 463: #	ifdef xZTR1
 464:     if (tTf(52, 4))
 465:         printf("pr_var(var=%d)\n", var);
 466: #	endif
 467:     pr_rv(var->sym.value.sym_var.varno);
 468:     putchar('.');
 469:     pr_attname(Qt.qt_rangev[var->sym.value.sym_var.varno].rngvdesc->reldum.relid, var->sym.value.sym_var.attno);
 470: }
 471: /*
 472: **  PR_QUAL
 473: **
 474: **	qual:		QLEND
 475: **		|	q_clause AND qual
 476: **
 477: */
 478: 
 479: pr_qual(q)
 480: register QTREE  *q;
 481: {
 482: 
 483:     pr_q_clause(q->left);
 484:     if (q->right->sym.type != QLEND)
 485:     {
 486:         printf(" and ");
 487:         pr_qual(q->right);
 488:     }
 489: }
 490: /*
 491: **  PR_Q_CLAUSE
 492: **
 493: **	q_clause:	q_clause OR q_clause
 494: **		|	expr
 495: */
 496: 
 497: pr_q_clause(q)
 498: QTREE   *q;
 499: {
 500: 
 501:     if (q->sym.type == OR)
 502:     {
 503:         pr_q_clause(q->left);
 504:         printf(" or ");
 505:         pr_q_clause(q->right);
 506:     }
 507:     else
 508:         pr_expr(q);
 509: }
 510: /*
 511: **  PR_TRIM
 512: */
 513: 
 514: char *
 515: pr_trim(s, l)
 516: register char   *s;
 517: register int    l;
 518: {
 519:     static char buf[30];
 520: 
 521:     bmove(s, buf, l);
 522:     for (s = buf; l && *s != ' ' && *s; --l)
 523:         s++;
 524:     *s = '\0';
 525:     return (buf);
 526: }
 527: /*
 528: **  PR_DOM_INIT
 529: */
 530: 
 531: pr_dom_init()
 532: {
 533:     Dom_num = 0;
 534: }
 535: 
 536: pr_ddom()
 537: {
 538:     printf("d%d = ", Dom_num++);
 539: }
 540: /*
 541: **  PR_RANGE -- print the range table
 542: */
 543: 
 544: pr_range()
 545: {
 546:     register int    i;
 547: 
 548:     for (i = 0; i <= MAXVAR; i++)
 549:     {
 550:         if (Qt.qt_rangev[i].rngvdesc != NULL)
 551:         {
 552:             printf("range of ");
 553:             pr_rv(i);
 554:             printf(" is %s\n",
 555:               pr_trim(Qt.qt_rangev[i].rngvdesc->reldum.relid, MAXNAME));
 556:         }
 557:     }
 558: }
 559: /*
 560: **  PR_RV -- print range variable
 561: */
 562: 
 563: pr_rv(re)
 564: register int    re;
 565: {
 566:     register int    j;
 567:     register char   ch;
 568: 
 569:     ch = Qt.qt_rangev[re].rngvdesc->reldum.relid[0];
 570: 
 571: #	ifdef xZTR1
 572:     if (tTf(52, 6))
 573:         printf("pr_rv(%d) ch '%c'\n", re, ch);
 574: #	endif
 575: 
 576:     for (j = 0; j <= MAXVAR; j++)
 577:     {
 578:         if (Qt.qt_rangev[j].rngvdesc == NULL)
 579:             continue;
 580:         if (ch == Qt.qt_rangev[j].rngvdesc->reldum.relid[0])
 581:             break;
 582:     }
 583:     if (j < re)
 584:         printf("rv%d", re);
 585:     else
 586:         printf("%c", ch);
 587: }
 588: /*
 589: **  RESULTRES
 590: */
 591: 
 592: char *
 593: resultres()
 594: {
 595:     extern char *Resrel;
 596: 
 597: #	ifdef xZTR1
 598:     if (tTf(52, 5))
 599:         printf("resultres: Resultvar %d, Resrel %s\n", Qt.qt_resvar, Resrel);
 600: #	endif
 601:     if (Qt.qt_resvar > 0)
 602:         return (Qt.qt_rangev[Qt.qt_resvar].rngvdesc->reldum.relid);
 603:     if (Resrel == 0)
 604:         syserr("resultres: Resrel == 0");
 605: 
 606:     return (Resrel);
 607: }
 608: 
 609: any(c, s)
 610: register char   c;
 611: register char   *s;
 612: {
 613: 
 614:     while (*s != '\0')
 615:         if (*s++ == c)
 616:             return (TRUE);
 617:     return (FALSE);
 618: }

Defined functions

Defined variables

Defined struct's