开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
gram.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：504k
源码类别：

数据库系统

开发平台：

Unix_Linux

gram.c：源码内容
  1. case 644:
  2. #line 3558 "gram.y"
  3. {
  4. SubLink *n = makeNode(SubLink);
  5. n->lefthand = yyvsp[-6].list;
  6. n->oper = lcons(yyvsp[-4].str, NIL);
  7. if (strcmp(yyvsp[-4].str,"<>") == 0)
  8. n->useor = true;
  9. else
  10. n->useor = false;
  11. n->subLinkType = yyvsp[-3].ival;
  12. n->subselect = yyvsp[-1].node;
  13. yyval.node = (Node *)n;
  14. ;
  15.     break;}
  16. case 645:
  17. #line 3571 "gram.y"
  18. {
  19. SubLink *n = makeNode(SubLink);
  20. n->lefthand = yyvsp[-5].list;
  21. n->oper = lcons(yyvsp[-3].str, NIL);
  22. if (strcmp(yyvsp[-3].str,"<>") == 0)
  23. n->useor = true;
  24. else
  25. n->useor = false;
  26. n->subLinkType = EXPR_SUBLINK;
  27. n->subselect = yyvsp[-1].node;
  28. yyval.node = (Node *)n;
  29. ;
  30.     break;}
  31. case 646:
  32. #line 3584 "gram.y"
  33. {
  34. yyval.node = makeRowExpr(yyvsp[-3].str, yyvsp[-5].list, yyvsp[-1].list);
  35. ;
  36.     break;}
  37. case 647:
  38. #line 3590 "gram.y"
  39. {
  40. yyval.list = lappend(yyvsp[-2].list, yyvsp[0].node);
  41. ;
  42.     break;}
  43. case 648:
  44. #line 3596 "gram.y"
  45. {
  46. yyval.list = lappend(yyvsp[-2].list, yyvsp[0].node);
  47. ;
  48.     break;}
  49. case 649:
  50. #line 3600 "gram.y"
  51. {
  52. yyval.list = lcons(yyvsp[0].node, NIL);
  53. ;
  54.     break;}
  55. case 650:
  56. #line 3605 "gram.y"
  57. { yyval.str = yyvsp[0].str; ;
  58.     break;}
  59. case 651:
  60. #line 3606 "gram.y"
  61. { yyval.str = "<"; ;
  62.     break;}
  63. case 652:
  64. #line 3607 "gram.y"
  65. { yyval.str = "="; ;
  66.     break;}
  67. case 653:
  68. #line 3608 "gram.y"
  69. { yyval.str = ">"; ;
  70.     break;}
  71. case 654:
  72. #line 3609 "gram.y"
  73. { yyval.str = "+"; ;
  74.     break;}
  75. case 655:
  76. #line 3610 "gram.y"
  77. { yyval.str = "-"; ;
  78.     break;}
  79. case 656:
  80. #line 3611 "gram.y"
  81. { yyval.str = "*"; ;
  82.     break;}
  83. case 657:
  84. #line 3612 "gram.y"
  85. { yyval.str = "/"; ;
  86.     break;}
  87. case 658:
  88. #line 3613 "gram.y"
  89. { yyval.str = "%"; ;
  90.     break;}
  91. case 659:
  92. #line 3616 "gram.y"
  93. { yyval.ival = ANY_SUBLINK; ;
  94.     break;}
  95. case 660:
  96. #line 3617 "gram.y"
  97. { yyval.ival = ALL_SUBLINK; ;
  98.     break;}
  99. case 661:
  100. #line 3629 "gram.y"
  101. {
  102. yyvsp[-1].attr->indirection = yyvsp[0].list;
  103. yyval.node = (Node *)yyvsp[-1].attr;
  104. ;
  105.     break;}
  106. case 662:
  107. #line 3634 "gram.y"
  108. { yyval.node = yyvsp[0].node;  ;
  109.     break;}
  110. case 663:
  111. #line 3636 "gram.y"
  112. { yyval.node = yyvsp[0].node;  ;
  113.     break;}
  114. case 664:
  115. #line 3638 "gram.y"
  116. {
  117. /* could be a column name or a relation_name */
  118. Ident *n = makeNode(Ident);
  119. n->name = yyvsp[0].str;
  120. n->indirection = NULL;
  121. yyval.node = (Node *)n;
  122. ;
  123.     break;}
  124. case 665:
  125. #line 3646 "gram.y"
  126. { yyval.node = doNegate(yyvsp[0].node); ;
  127.     break;}
  128. case 666:
  129. #line 3648 "gram.y"
  130. { yyval.node = makeA_Expr(OP, "%", NULL, yyvsp[0].node); ;
  131.     break;}
  132. case 667:
  133. #line 3650 "gram.y"
  134. { yyval.node = makeA_Expr(OP, "^", NULL, yyvsp[0].node); ;
  135.     break;}
  136. case 668:
  137. #line 3652 "gram.y"
  138. { yyval.node = makeA_Expr(OP, "%", yyvsp[-1].node, NULL); ;
  139.     break;}
  140. case 669:
  141. #line 3654 "gram.y"
  142. { yyval.node = makeA_Expr(OP, "^", yyvsp[-1].node, NULL); ;
  143.     break;}
  144. case 670:
  145. #line 3656 "gram.y"
  146. { yyval.node = makeA_Expr(OP, "+", yyvsp[-2].node, yyvsp[0].node); ;
  147.     break;}
  148. case 671:
  149. #line 3658 "gram.y"
  150. { yyval.node = makeA_Expr(OP, "-", yyvsp[-2].node, yyvsp[0].node); ;
  151.     break;}
  152. case 672:
  153. #line 3660 "gram.y"
  154. { yyval.node = makeA_Expr(OP, "/", yyvsp[-2].node, yyvsp[0].node); ;
  155.     break;}
  156. case 673:
  157. #line 3662 "gram.y"
  158. { yyval.node = makeA_Expr(OP, "%", yyvsp[-2].node, yyvsp[0].node); ;
  159.     break;}
  160. case 674:
  161. #line 3664 "gram.y"
  162. { yyval.node = makeA_Expr(OP, "*", yyvsp[-2].node, yyvsp[0].node); ;
  163.     break;}
  164. case 675:
  165. #line 3666 "gram.y"
  166. { yyval.node = makeA_Expr(OP, "^", yyvsp[-2].node, yyvsp[0].node); ;
  167.     break;}
  168. case 676:
  169. #line 3668 "gram.y"
  170. { yyval.node = makeA_Expr(OP, "<", yyvsp[-2].node, yyvsp[0].node); ;
  171.     break;}
  172. case 677:
  173. #line 3670 "gram.y"
  174. { yyval.node = makeA_Expr(OP, ">", yyvsp[-2].node, yyvsp[0].node); ;
  175.     break;}
  176. case 678:
  177. #line 3673 "gram.y"
  178. { yyval.node = makeA_Expr(ISNULL, NULL, yyvsp[-2].node, NULL); ;
  179.     break;}
  180. case 679:
  181. #line 3676 "gram.y"
  182. { yyval.node = makeA_Expr(ISNULL, NULL, yyvsp[0].node, NULL); ;
  183.     break;}
  184. case 680:
  185. #line 3679 "gram.y"
  186. { yyval.node = makeA_Expr(OP, "=", yyvsp[-2].node, yyvsp[0].node); ;
  187.     break;}
  188. case 681:
  189. #line 3681 "gram.y"
  190. { yyval.node = makeA_Expr(OP, ":", NULL, yyvsp[0].node); ;
  191.     break;}
  192. case 682:
  193. #line 3683 "gram.y"
  194. { yyval.node = makeA_Expr(OP, ";", NULL, yyvsp[0].node); ;
  195.     break;}
  196. case 683:
  197. #line 3685 "gram.y"
  198. { yyval.node = makeA_Expr(OP, "|", NULL, yyvsp[0].node); ;
  199.     break;}
  200. case 684:
  201. #line 3687 "gram.y"
  202. {
  203. yyval.node = (Node *)yyvsp[-2].node;
  204. /* AexprConst can be either A_Const or ParamNo */
  205. if (nodeTag(yyvsp[-2].node) == T_A_Const) {
  206. ((A_Const *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  207. } else if (nodeTag(yyvsp[-2].node) == T_Param) {
  208. ((ParamNo *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  209. /* otherwise, try to transform to a function call */
  210. } else {
  211. FuncCall *n = makeNode(FuncCall);
  212. n->funcname = yyvsp[0].typnam->name;
  213. n->args = lcons(yyvsp[-2].node,NIL);
  214. yyval.node = (Node *)n;
  215. }
  216. ;
  217.     break;}
  218. case 685:
  219. #line 3703 "gram.y"
  220. {
  221. yyval.node = (Node *)yyvsp[-3].node;
  222. /* AexprConst can be either A_Const or ParamNo */
  223. if (nodeTag(yyvsp[-3].node) == T_A_Const) {
  224. ((A_Const *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  225. } else if (nodeTag(yyvsp[-1].typnam) == T_Param) {
  226. ((ParamNo *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  227. /* otherwise, try to transform to a function call */
  228. } else {
  229. FuncCall *n = makeNode(FuncCall);
  230. n->funcname = yyvsp[-1].typnam->name;
  231. n->args = lcons(yyvsp[-3].node,NIL);
  232. yyval.node = (Node *)n;
  233. }
  234. ;
  235.     break;}
  236. case 686:
  237. #line 3719 "gram.y"
  238. { yyval.node = yyvsp[-1].node; ;
  239.     break;}
  240. case 687:
  241. #line 3721 "gram.y"
  242. { yyval.node = makeIndexable(yyvsp[-1].str,yyvsp[-2].node,yyvsp[0].node); ;
  243.     break;}
  244. case 688:
  245. #line 3723 "gram.y"
  246. { yyval.node = makeIndexable("~~", yyvsp[-2].node, yyvsp[0].node); ;
  247.     break;}
  248. case 689:
  249. #line 3725 "gram.y"
  250. { yyval.node = makeA_Expr(OP, "!~~", yyvsp[-3].node, yyvsp[0].node); ;
  251.     break;}
  252. case 690:
  253. #line 3727 "gram.y"
  254. { yyval.node = makeA_Expr(OP, yyvsp[-1].str, NULL, yyvsp[0].node); ;
  255.     break;}
  256. case 691:
  257. #line 3729 "gram.y"
  258. { yyval.node = makeA_Expr(OP, yyvsp[0].str, yyvsp[-1].node, NULL); ;
  259.     break;}
  260. case 692:
  261. #line 3731 "gram.y"
  262. {
  263. /* cheap hack for aggregate (eg. count) */
  264. FuncCall *n = makeNode(FuncCall);
  265. A_Const *star = makeNode(A_Const);
  267. star->val.type = T_String;
  268. star->val.val.str = "";
  269. n->funcname = yyvsp[-3].str;
  270. n->args = lcons(star, NIL);
  271. yyval.node = (Node *)n;
  272. ;
  273.     break;}
  274. case 693:
  275. #line 3743 "gram.y"
  276. {
  277. FuncCall *n = makeNode(FuncCall);
  278. n->funcname = yyvsp[-2].str;
  279. n->args = NIL;
  280. yyval.node = (Node *)n;
  281. ;
  282.     break;}
  283. case 694:
  284. #line 3750 "gram.y"
  285. {
  286. FuncCall *n = makeNode(FuncCall);
  287. n->funcname = yyvsp[-3].str;
  288. n->args = yyvsp[-1].list;
  289. yyval.node = (Node *)n;
  290. ;
  291.     break;}
  292. case 695:
  293. #line 3757 "gram.y"
  294. {
  295. A_Const *n = makeNode(A_Const);
  296. TypeName *t = makeNode(TypeName);
  298. n->val.type = T_String;
  299. n->val.val.str = "now";
  300. n->typename = t;
  302. t->name = xlateSqlType("date");
  303. t->setof = FALSE;
  304. t->typmod = -1;
  305.  
  306. yyval.node = (Node *)n;
  307. ;
  308.     break;}
  309. case 696:
  310. #line 3772 "gram.y"
  311. {
  312. A_Const *n = makeNode(A_Const);
  313. TypeName *t = makeNode(TypeName);
  315. n->val.type = T_String;
  316. n->val.val.str = "now";
  317. n->typename = t;
  319. t->name = xlateSqlType("time");
  320. t->setof = FALSE;
  321. t->typmod = -1;
  323. yyval.node = (Node *)n;
  324. ;
  325.     break;}
  326. case 697:
  327. #line 3787 "gram.y"
  328. {
  329. FuncCall *n = makeNode(FuncCall);
  330. A_Const *s = makeNode(A_Const);
  331. TypeName *t = makeNode(TypeName);
  333. n->funcname = xlateSqlType("time");
  334. n->args = lcons(s, NIL);
  336. s->val.type = T_String;
  337. s->val.val.str = "now";
  338. s->typename = t;
  340. t->name = xlateSqlType("time");
  341. t->setof = FALSE;
  342. t->typmod = -1;
  344. if (yyvsp[-1].ival != 0)
  345. elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",yyvsp[-1].ival);
  347. yyval.node = (Node *)n;
  348. ;
  349.     break;}
  350. case 698:
  351. #line 3809 "gram.y"
  352. {
  353. A_Const *n = makeNode(A_Const);
  354. TypeName *t = makeNode(TypeName);
  356. n->val.type = T_String;
  357. n->val.val.str = "now";
  358. n->typename = t;
  360. t->name = xlateSqlType("timestamp");
  361. t->setof = FALSE;
  362. t->typmod = -1;
  364. yyval.node = (Node *)n;
  365. ;
  366.     break;}
  367. case 699:
  368. #line 3824 "gram.y"
  369. {
  370. FuncCall *n = makeNode(FuncCall);
  371. A_Const *s = makeNode(A_Const);
  372. TypeName *t = makeNode(TypeName);
  374. n->funcname = xlateSqlType("timestamp");
  375. n->args = lcons(s, NIL);
  377. s->val.type = T_String;
  378. s->val.val.str = "now";
  379. s->typename = t;
  381. t->name = xlateSqlType("timestamp");
  382. t->setof = FALSE;
  383. t->typmod = -1;
  385. if (yyvsp[-1].ival != 0)
  386. elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",yyvsp[-1].ival);
  388. yyval.node = (Node *)n;
  389. ;
  390.     break;}
  391. case 700:
  392. #line 3846 "gram.y"
  393. {
  394. FuncCall *n = makeNode(FuncCall);
  395. n->funcname = "getpgusername";
  396. n->args = NIL;
  397. yyval.node = (Node *)n;
  398. ;
  399.     break;}
  400. case 701:
  401. #line 3853 "gram.y"
  402. {
  403. FuncCall *n = makeNode(FuncCall);
  404. n->funcname = "getpgusername";
  405. n->args = NIL;
  406. yyval.node = (Node *)n;
  407. ;
  408.     break;}
  409. case 702:
  410. #line 3860 "gram.y"
  411. {
  412. SubLink *n = makeNode(SubLink);
  413. n->lefthand = NIL;
  414. n->useor = false;
  415. n->oper = NIL;
  416. n->subLinkType = EXISTS_SUBLINK;
  417. n->subselect = yyvsp[-1].node;
  418. yyval.node = (Node *)n;
  419. ;
  420.     break;}
  421. case 703:
  422. #line 3870 "gram.y"
  423. {
  424. FuncCall *n = makeNode(FuncCall);
  425. n->funcname = "date_part";
  426. n->args = yyvsp[-1].list;
  427. yyval.node = (Node *)n;
  428. ;
  429.     break;}
  430. case 704:
  431. #line 3877 "gram.y"
  432. {
  433. FuncCall *n = makeNode(FuncCall);
  434. n->funcname = "strpos";
  435. n->args = yyvsp[-1].list;
  436. yyval.node = (Node *)n;
  437. ;
  438.     break;}
  439. case 705:
  440. #line 3884 "gram.y"
  441. {
  442. FuncCall *n = makeNode(FuncCall);
  443. n->funcname = "substr";
  444. n->args = yyvsp[-1].list;
  445. yyval.node = (Node *)n;
  446. ;
  447.     break;}
  448. case 706:
  449. #line 3892 "gram.y"
  450. {
  451. FuncCall *n = makeNode(FuncCall);
  452. n->funcname = "btrim";
  453. n->args = yyvsp[-1].list;
  454. yyval.node = (Node *)n;
  455. ;
  456.     break;}
  457. case 707:
  458. #line 3899 "gram.y"
  459. {
  460. FuncCall *n = makeNode(FuncCall);
  461. n->funcname = "ltrim";
  462. n->args = yyvsp[-1].list;
  463. yyval.node = (Node *)n;
  464. ;
  465.     break;}
  466. case 708:
  467. #line 3906 "gram.y"
  468. {
  469. FuncCall *n = makeNode(FuncCall);
  470. n->funcname = "rtrim";
  471. n->args = yyvsp[-1].list;
  472. yyval.node = (Node *)n;
  473. ;
  474.     break;}
  475. case 709:
  476. #line 3913 "gram.y"
  477. {
  478. FuncCall *n = makeNode(FuncCall);
  479. n->funcname = "btrim";
  480. n->args = yyvsp[-1].list;
  481. yyval.node = (Node *)n;
  482. ;
  483.     break;}
  484. case 710:
  485. #line 3920 "gram.y"
  486. { yyval.node = makeA_Expr(ISNULL, NULL, yyvsp[-1].node, NULL); ;
  487.     break;}
  488. case 711:
  489. #line 3922 "gram.y"
  490. { yyval.node = makeA_Expr(ISNULL, NULL, yyvsp[-2].node, NULL); ;
  491.     break;}
  492. case 712:
  493. #line 3924 "gram.y"
  494. { yyval.node = makeA_Expr(NOTNULL, NULL, yyvsp[-1].node, NULL); ;
  495.     break;}
  496. case 713:
  497. #line 3926 "gram.y"
  498. { yyval.node = makeA_Expr(NOTNULL, NULL, yyvsp[-3].node, NULL); ;
  499.     break;}
  500. case 714:
  501. #line 3933 "gram.y"
  502. {
  503. A_Const *n = makeNode(A_Const);
  504. n->val.type = T_String;
  505. n->val.val.str = "t";
  506. n->typename = makeNode(TypeName);
  507. n->typename->name = xlateSqlType("bool");
  508. n->typename->typmod = -1;
  509. yyval.node = makeA_Expr(OP, "=", yyvsp[-2].node,(Node *)n);
  510. ;
  511.     break;}
  512. case 715:
  513. #line 3943 "gram.y"
  514. {
  515. A_Const *n = makeNode(A_Const);
  516. n->val.type = T_String;
  517. n->val.val.str = "t";
  518. n->typename = makeNode(TypeName);
  519. n->typename->name = xlateSqlType("bool");
  520. n->typename->typmod = -1;
  521. yyval.node = makeA_Expr(OP, "=", yyvsp[-3].node,(Node *)n);
  522. ;
  523.     break;}
  524. case 716:
  525. #line 3953 "gram.y"
  526. {
  527. A_Const *n = makeNode(A_Const);
  528. n->val.type = T_String;
  529. n->val.val.str = "f";
  530. n->typename = makeNode(TypeName);
  531. n->typename->name = xlateSqlType("bool");
  532. n->typename->typmod = -1;
  533. yyval.node = makeA_Expr(OP, "=", yyvsp[-2].node,(Node *)n);
  534. ;
  535.     break;}
  536. case 717:
  537. #line 3963 "gram.y"
  538. {
  539. A_Const *n = makeNode(A_Const);
  540. n->val.type = T_String;
  541. n->val.val.str = "f";
  542. n->typename = makeNode(TypeName);
  543. n->typename->name = xlateSqlType("bool");
  544. n->typename->typmod = -1;
  545. yyval.node = makeA_Expr(OP, "=", yyvsp[-3].node,(Node *)n);
  546. ;
  547.     break;}
  548. case 718:
  549. #line 3973 "gram.y"
  550. {
  551. yyval.node = makeA_Expr(AND, NULL,
  552. makeA_Expr(OP, ">=", yyvsp[-4].node, yyvsp[-2].node),
  553. makeA_Expr(OP, "<=", yyvsp[-4].node, yyvsp[0].node));
  554. ;
  555.     break;}
  556. case 719:
  557. #line 3979 "gram.y"
  558. {
  559. yyval.node = makeA_Expr(OR, NULL,
  560. makeA_Expr(OP, "<", yyvsp[-5].node, yyvsp[-2].node),
  561. makeA_Expr(OP, ">", yyvsp[-5].node, yyvsp[0].node));
  562. ;
  563.     break;}
  564. case 720:
  565. #line 3984 "gram.y"
  566. { saved_In_Expr = lcons(yyvsp[-1].node,saved_In_Expr); ;
  567.     break;}
  568. case 721:
  569. #line 3985 "gram.y"
  570. {
  571. saved_In_Expr = lnext(saved_In_Expr);
  572. if (nodeTag(yyvsp[-1].node) == T_SubLink)
  573. {
  574. SubLink *n = (SubLink *)yyvsp[-1].node;
  575. n->lefthand = lcons(yyvsp[-5].node, NIL);
  576. n->oper = lcons("=",NIL);
  577. n->useor = false;
  578. n->subLinkType = ANY_SUBLINK;
  579. yyval.node = (Node *)n;
  580. }
  581. else yyval.node = yyvsp[-1].node;
  582. ;
  583.     break;}
  584. case 722:
  585. #line 3998 "gram.y"
  586. { saved_In_Expr = lcons(yyvsp[-2].node,saved_In_Expr); ;
  587.     break;}
  588. case 723:
  589. #line 3999 "gram.y"
  590. {
  591. saved_In_Expr = lnext(saved_In_Expr);
  592. if (nodeTag(yyvsp[-1].node) == T_SubLink)
  593. {
  594. SubLink *n = (SubLink *)yyvsp[-1].node;
  595. n->lefthand = lcons(yyvsp[-6].node, NIL);
  596. n->oper = lcons("<>",NIL);
  597. n->useor = false;
  598. n->subLinkType = ALL_SUBLINK;
  599. yyval.node = (Node *)n;
  600. }
  601. else yyval.node = yyvsp[-1].node;
  602. ;
  603.     break;}
  604. case 724:
  605. #line 4013 "gram.y"
  606. {
  607. SubLink *n = makeNode(SubLink);
  608. n->lefthand = lcons(yyvsp[-4].node, NULL);
  609. n->oper = lcons(yyvsp[-3].str,NIL);
  610. n->useor = false;
  611. n->subLinkType = EXPR_SUBLINK;
  612. n->subselect = yyvsp[-1].node;
  613. yyval.node = (Node *)n;
  614. ;
  615.     break;}
  616. case 725:
  617. #line 4023 "gram.y"
  618. {
  619. SubLink *n = makeNode(SubLink);
  620. n->lefthand = lcons(yyvsp[-4].node, NULL);
  621. n->oper = lcons("+",NIL);
  622. n->useor = false;
  623. n->subLinkType = EXPR_SUBLINK;
  624. n->subselect = yyvsp[-1].node;
  625. yyval.node = (Node *)n;
  626. ;
  627.     break;}
  628. case 726:
  629. #line 4033 "gram.y"
  630. {
  631. SubLink *n = makeNode(SubLink);
  632. n->lefthand = lcons(yyvsp[-4].node, NULL);
  633. n->oper = lcons("-",NIL);
  634. n->useor = false;
  635. n->subLinkType = EXPR_SUBLINK;
  636. n->subselect = yyvsp[-1].node;
  637. yyval.node = (Node *)n;
  638. ;
  639.     break;}
  640. case 727:
  641. #line 4043 "gram.y"
  642. {
  643. SubLink *n = makeNode(SubLink);
  644. n->lefthand = lcons(yyvsp[-4].node, NULL);
  645. n->oper = lcons("/",NIL);
  646. n->useor = false;
  647. n->subLinkType = EXPR_SUBLINK;
  648. n->subselect = yyvsp[-1].node;
  649. yyval.node = (Node *)n;
  650. ;
  651.     break;}
  652. case 728:
  653. #line 4053 "gram.y"
  654. {
  655. SubLink *n = makeNode(SubLink);
  656. n->lefthand = lcons(yyvsp[-4].node, NULL);
  657. n->oper = lcons("%",NIL);
  658. n->useor = false;
  659. n->subLinkType = EXPR_SUBLINK;
  660. n->subselect = yyvsp[-1].node;
  661. yyval.node = (Node *)n;
  662. ;
  663.     break;}
  664. case 729:
  665. #line 4063 "gram.y"
  666. {
  667. SubLink *n = makeNode(SubLink);
  668. n->lefthand = lcons(yyvsp[-4].node, NULL);
  669. n->oper = lcons("*",NIL);
  670. n->useor = false;
  671. n->subLinkType = EXPR_SUBLINK;
  672. n->subselect = yyvsp[-1].node;
  673. yyval.node = (Node *)n;
  674. ;
  675.     break;}
  676. case 730:
  677. #line 4073 "gram.y"
  678. {
  679. SubLink *n = makeNode(SubLink);
  680. n->lefthand = lcons(yyvsp[-4].node, NULL);
  681. n->oper = lcons("<",NIL);
  682. n->useor = false;
  683. n->subLinkType = EXPR_SUBLINK;
  684. n->subselect = yyvsp[-1].node;
  685. yyval.node = (Node *)n;
  686. ;
  687.     break;}
  688. case 731:
  689. #line 4083 "gram.y"
  690. {
  691. SubLink *n = makeNode(SubLink);
  692. n->lefthand = lcons(yyvsp[-4].node, NULL);
  693. n->oper = lcons(">",NIL);
  694. n->useor = false;
  695. n->subLinkType = EXPR_SUBLINK;
  696. n->subselect = yyvsp[-1].node;
  697. yyval.node = (Node *)n;
  698. ;
  699.     break;}
  700. case 732:
  701. #line 4093 "gram.y"
  702. {
  703. SubLink *n = makeNode(SubLink);
  704. n->lefthand = lcons(yyvsp[-4].node, NULL);
  705. n->oper = lcons("=",NIL);
  706. n->useor = false;
  707. n->subLinkType = EXPR_SUBLINK;
  708. n->subselect = yyvsp[-1].node;
  709. yyval.node = (Node *)n;
  710. ;
  711.     break;}
  712. case 733:
  713. #line 4103 "gram.y"
  714. {
  715. SubLink *n = makeNode(SubLink);
  716. n->lefthand = lcons(yyvsp[-5].node,NIL);
  717. n->oper = lcons(yyvsp[-4].str,NIL);
  718. n->useor = false;
  719. n->subLinkType = ANY_SUBLINK;
  720. n->subselect = yyvsp[-1].node;
  721. yyval.node = (Node *)n;
  722. ;
  723.     break;}
  724. case 734:
  725. #line 4113 "gram.y"
  726. {
  727. SubLink *n = makeNode(SubLink);
  728. n->lefthand = lcons(yyvsp[-5].node,NIL);
  729. n->oper = lcons("+",NIL);
  730. n->useor = false;
  731. n->subLinkType = ANY_SUBLINK;
  732. n->subselect = yyvsp[-1].node;
  733. yyval.node = (Node *)n;
  734. ;
  735.     break;}
  736. case 735:
  737. #line 4123 "gram.y"
  738. {
  739. SubLink *n = makeNode(SubLink);
  740. n->lefthand = lcons(yyvsp[-5].node,NIL);
  741. n->oper = lcons("-",NIL);
  742. n->useor = false;
  743. n->subLinkType = ANY_SUBLINK;
  744. n->subselect = yyvsp[-1].node;
  745. yyval.node = (Node *)n;
  746. ;
  747.     break;}
  748. case 736:
  749. #line 4133 "gram.y"
  750. {
  751. SubLink *n = makeNode(SubLink);
  752. n->lefthand = lcons(yyvsp[-5].node,NIL);
  753. n->oper = lcons("/",NIL);
  754. n->useor = false;
  755. n->subLinkType = ANY_SUBLINK;
  756. n->subselect = yyvsp[-1].node;
  757. yyval.node = (Node *)n;
  758. ;
  759.     break;}
  760. case 737:
  761. #line 4143 "gram.y"
  762. {
  763. SubLink *n = makeNode(SubLink);
  764. n->lefthand = lcons(yyvsp[-5].node,NIL);
  765. n->oper = lcons("%",NIL);
  766. n->useor = false;
  767. n->subLinkType = ANY_SUBLINK;
  768. n->subselect = yyvsp[-1].node;
  769. yyval.node = (Node *)n;
  770. ;
  771.     break;}
  772. case 738:
  773. #line 4153 "gram.y"
  774. {
  775. SubLink *n = makeNode(SubLink);
  776. n->lefthand = lcons(yyvsp[-5].node,NIL);
  777. n->oper = lcons("*",NIL);
  778. n->useor = false;
  779. n->subLinkType = ANY_SUBLINK;
  780. n->subselect = yyvsp[-1].node;
  781. yyval.node = (Node *)n;
  782. ;
  783.     break;}
  784. case 739:
  785. #line 4163 "gram.y"
  786. {
  787. SubLink *n = makeNode(SubLink);
  788. n->lefthand = lcons(yyvsp[-5].node,NIL);
  789. n->oper = lcons("<",NIL);
  790. n->useor = false;
  791. n->subLinkType = ANY_SUBLINK;
  792. n->subselect = yyvsp[-1].node;
  793. yyval.node = (Node *)n;
  794. ;
  795.     break;}
  796. case 740:
  797. #line 4173 "gram.y"
  798. {
  799. SubLink *n = makeNode(SubLink);
  800. n->lefthand = lcons(yyvsp[-5].node,NIL);
  801. n->oper = lcons(">",NIL);
  802. n->useor = false;
  803. n->subLinkType = ANY_SUBLINK;
  804. n->subselect = yyvsp[-1].node;
  805. yyval.node = (Node *)n;
  806. ;
  807.     break;}
  808. case 741:
  809. #line 4183 "gram.y"
  810. {
  811. SubLink *n = makeNode(SubLink);
  812. n->lefthand = lcons(yyvsp[-5].node,NIL);
  813. n->oper = lcons("=",NIL);
  814. n->useor = false;
  815. n->subLinkType = ANY_SUBLINK;
  816. n->subselect = yyvsp[-1].node;
  817. yyval.node = (Node *)n;
  818. ;
  819.     break;}
  820. case 742:
  821. #line 4193 "gram.y"
  822. {
  823. SubLink *n = makeNode(SubLink);
  824. n->lefthand = lcons(yyvsp[-5].node, NULL);
  825. n->oper = lcons(yyvsp[-4].str,NIL);
  826. n->useor = false;
  827. n->subLinkType = ALL_SUBLINK;
  828. n->subselect = yyvsp[-1].node;
  829. yyval.node = (Node *)n;
  830. ;
  831.     break;}
  832. case 743:
  833. #line 4203 "gram.y"
  834. {
  835. SubLink *n = makeNode(SubLink);
  836. n->lefthand = lcons(yyvsp[-5].node, NULL);
  837. n->oper = lcons("+",NIL);
  838. n->useor = false;
  839. n->subLinkType = ALL_SUBLINK;
  840. n->subselect = yyvsp[-1].node;
  841. yyval.node = (Node *)n;
  842. ;
  843.     break;}
  844. case 744:
  845. #line 4213 "gram.y"
  846. {
  847. SubLink *n = makeNode(SubLink);
  848. n->lefthand = lcons(yyvsp[-5].node, NULL);
  849. n->oper = lcons("-",NIL);
  850. n->useor = false;
  851. n->subLinkType = ALL_SUBLINK;
  852. n->subselect = yyvsp[-1].node;
  853. yyval.node = (Node *)n;
  854. ;
  855.     break;}
  856. case 745:
  857. #line 4223 "gram.y"
  858. {
  859. SubLink *n = makeNode(SubLink);
  860. n->lefthand = lcons(yyvsp[-5].node, NULL);
  861. n->oper = lcons("/",NIL);
  862. n->useor = false;
  863. n->subLinkType = ALL_SUBLINK;
  864. n->subselect = yyvsp[-1].node;
  865. yyval.node = (Node *)n;
  866. ;
  867.     break;}
  868. case 746:
  869. #line 4233 "gram.y"
  870. {
  871. SubLink *n = makeNode(SubLink);
  872. n->lefthand = lcons(yyvsp[-5].node, NULL);
  873. n->oper = lcons("%",NIL);
  874. n->useor = false;
  875. n->subLinkType = ALL_SUBLINK;
  876. n->subselect = yyvsp[-1].node;
  877. yyval.node = (Node *)n;
  878. ;
  879.     break;}
  880. case 747:
  881. #line 4243 "gram.y"
  882. {
  883. SubLink *n = makeNode(SubLink);
  884. n->lefthand = lcons(yyvsp[-5].node, NULL);
  885. n->oper = lcons("*",NIL);
  886. n->useor = false;
  887. n->subLinkType = ALL_SUBLINK;
  888. n->subselect = yyvsp[-1].node;
  889. yyval.node = (Node *)n;
  890. ;
  891.     break;}
  892. case 748:
  893. #line 4253 "gram.y"
  894. {
  895. SubLink *n = makeNode(SubLink);
  896. n->lefthand = lcons(yyvsp[-5].node, NULL);
  897. n->oper = lcons("<",NIL);
  898. n->useor = false;
  899. n->subLinkType = ALL_SUBLINK;
  900. n->subselect = yyvsp[-1].node;
  901. yyval.node = (Node *)n;
  902. ;
  903.     break;}
  904. case 749:
  905. #line 4263 "gram.y"
  906. {
  907. SubLink *n = makeNode(SubLink);
  908. n->lefthand = lcons(yyvsp[-5].node, NULL);
  909. n->oper = lcons(">",NIL);
  910. n->useor = false;
  911. n->subLinkType = ALL_SUBLINK;
  912. n->subselect = yyvsp[-1].node;
  913. yyval.node = (Node *)n;
  914. ;
  915.     break;}
  916. case 750:
  917. #line 4273 "gram.y"
  918. {
  919. SubLink *n = makeNode(SubLink);
  920. n->lefthand = lcons(yyvsp[-5].node, NULL);
  921. n->oper = lcons("=",NIL);
  922. n->useor = false;
  923. n->subLinkType = ALL_SUBLINK;
  924. n->subselect = yyvsp[-1].node;
  925. yyval.node = (Node *)n;
  926. ;
  927.     break;}
  928. case 751:
  929. #line 4283 "gram.y"
  930. { yyval.node = makeA_Expr(AND, NULL, yyvsp[-2].node, yyvsp[0].node); ;
  931.     break;}
  932. case 752:
  933. #line 4285 "gram.y"
  934. { yyval.node = makeA_Expr(OR, NULL, yyvsp[-2].node, yyvsp[0].node); ;
  935.     break;}
  936. case 753:
  937. #line 4287 "gram.y"
  938. { yyval.node = makeA_Expr(NOT, NULL, NULL, yyvsp[0].node); ;
  939.     break;}
  940. case 754:
  941. #line 4289 "gram.y"
  942. { yyval.node = yyvsp[0].node; ;
  943.     break;}
  944. case 755:
  945. #line 4298 "gram.y"
  946. {
  947. yyvsp[-1].attr->indirection = yyvsp[0].list;
  948. yyval.node = (Node *)yyvsp[-1].attr;
  949. ;
  950.     break;}
  951. case 756:
  952. #line 4303 "gram.y"
  953. { yyval.node = yyvsp[0].node;  ;
  954.     break;}
  955. case 757:
  956. #line 4305 "gram.y"
  957. {
  958. /* could be a column name or a relation_name */
  959. Ident *n = makeNode(Ident);
  960. n->name = yyvsp[0].str;
  961. n->indirection = NULL;
  962. yyval.node = (Node *)n;
  963. ;
  964.     break;}
  965. case 758:
  966. #line 4313 "gram.y"
  967. { yyval.node = doNegate(yyvsp[0].node); ;
  968.     break;}
  969. case 759:
  970. #line 4315 "gram.y"
  971. { yyval.node = makeA_Expr(OP, "%", NULL, yyvsp[0].node); ;
  972.     break;}
  973. case 760:
  974. #line 4317 "gram.y"
  975. { yyval.node = makeA_Expr(OP, "^", NULL, yyvsp[0].node); ;
  976.     break;}
  977. case 761:
  978. #line 4319 "gram.y"
  979. { yyval.node = makeA_Expr(OP, "%", yyvsp[-1].node, NULL); ;
  980.     break;}
  981. case 762:
  982. #line 4321 "gram.y"
  983. { yyval.node = makeA_Expr(OP, "^", yyvsp[-1].node, NULL); ;
  984.     break;}
  985. case 763:
  986. #line 4323 "gram.y"
  987. { yyval.node = makeA_Expr(OP, "+", yyvsp[-2].node, yyvsp[0].node); ;
  988.     break;}
  989. case 764:
  990. #line 4325 "gram.y"
  991. { yyval.node = makeA_Expr(OP, "-", yyvsp[-2].node, yyvsp[0].node); ;
  992.     break;}
  993. case 765:
  994. #line 4327 "gram.y"
  995. { yyval.node = makeA_Expr(OP, "/", yyvsp[-2].node, yyvsp[0].node); ;
  996.     break;}
  997. case 766:
  998. #line 4329 "gram.y"
  999. { yyval.node = makeA_Expr(OP, "%", yyvsp[-2].node, yyvsp[0].node); ;
  1000.     break;}
  1001. case 767:
  1002. #line 4331 "gram.y"
  1003. { yyval.node = makeA_Expr(OP, "^", yyvsp[-2].node, yyvsp[0].node); ;
  1004.     break;}
  1005. case 768:
  1006. #line 4333 "gram.y"
  1007. { yyval.node = makeA_Expr(OP, "*", yyvsp[-2].node, yyvsp[0].node); ;
  1008.     break;}
  1009. case 769:
  1010. #line 4335 "gram.y"
  1011. { yyval.node = makeA_Expr(OP, ":", NULL, yyvsp[0].node); ;
  1012.     break;}
  1013. case 770:
  1014. #line 4337 "gram.y"
  1015. { yyval.node = makeA_Expr(OP, ";", NULL, yyvsp[0].node); ;
  1016.     break;}
  1017. case 771:
  1018. #line 4339 "gram.y"
  1019. { yyval.node = makeA_Expr(OP, "|", NULL, yyvsp[0].node); ;
  1020.     break;}
  1021. case 772:
  1022. #line 4341 "gram.y"
  1023. {
  1024. yyval.node = (Node *)yyvsp[-2].node;
  1025. /* AexprConst can be either A_Const or ParamNo */
  1026. if (nodeTag(yyvsp[-2].node) == T_A_Const) {
  1027. ((A_Const *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  1028. } else if (nodeTag(yyvsp[-2].node) == T_Param) {
  1029. ((ParamNo *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  1030. /* otherwise, try to transform to a function call */
  1031. } else {
  1032. FuncCall *n = makeNode(FuncCall);
  1033. n->funcname = yyvsp[0].typnam->name;
  1034. n->args = lcons(yyvsp[-2].node,NIL);
  1035. yyval.node = (Node *)n;
  1036. }
  1037. ;
  1038.     break;}
  1039. case 773:
  1040. #line 4357 "gram.y"
  1041. {
  1042. yyval.node = (Node *)yyvsp[-3].node;
  1043. /* AexprConst can be either A_Const or ParamNo */
  1044. if (nodeTag(yyvsp[-3].node) == T_A_Const) {
  1045. ((A_Const *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  1046. } else if (nodeTag(yyvsp[-3].node) == T_Param) {
  1047. ((ParamNo *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  1048. /* otherwise, try to transform to a function call */
  1049. } else {
  1050. FuncCall *n = makeNode(FuncCall);
  1051. n->funcname = yyvsp[-1].typnam->name;
  1052. n->args = lcons(yyvsp[-3].node,NIL);
  1053. yyval.node = (Node *)n;
  1054. }
  1055. ;
  1056.     break;}
  1057. case 774:
  1058. #line 4373 "gram.y"
  1059. { yyval.node = yyvsp[-1].node; ;
  1060.     break;}
  1061. case 775:
  1062. #line 4375 "gram.y"
  1063. { yyval.node = makeIndexable(yyvsp[-1].str,yyvsp[-2].node,yyvsp[0].node); ;
  1064.     break;}
  1065. case 776:
  1066. #line 4377 "gram.y"
  1067. { yyval.node = makeA_Expr(OP, yyvsp[-1].str, NULL, yyvsp[0].node); ;
  1068.     break;}
  1069. case 777:
  1070. #line 4379 "gram.y"
  1071. { yyval.node = makeA_Expr(OP, yyvsp[0].str, yyvsp[-1].node, NULL); ;
  1072.     break;}
  1073. case 778:
  1074. #line 4381 "gram.y"
  1075. {
  1076. FuncCall *n = makeNode(FuncCall);
  1077. n->funcname = yyvsp[-2].str;
  1078. n->args = NIL;
  1079. yyval.node = (Node *)n;
  1080. ;
  1081.     break;}
  1082. case 779:
  1083. #line 4388 "gram.y"
  1084. {
  1085. FuncCall *n = makeNode(FuncCall);
  1086. n->funcname = yyvsp[-3].str;
  1087. n->args = yyvsp[-1].list;
  1088. yyval.node = (Node *)n;
  1089. ;
  1090.     break;}
  1091. case 780:
  1092. #line 4395 "gram.y"
  1093. {
  1094. A_Const *n = makeNode(A_Const);
  1095. TypeName *t = makeNode(TypeName);
  1097. n->val.type = T_String;
  1098. n->val.val.str = "now";
  1099. n->typename = t;
  1101. t->name = xlateSqlType("date");
  1102. t->setof = FALSE;
  1103. t->typmod = -1;
  1105. yyval.node = (Node *)n;
  1106. ;
  1107.     break;}
  1108. case 781:
  1109. #line 4410 "gram.y"
  1110. {
  1111. A_Const *n = makeNode(A_Const);
  1112. TypeName *t = makeNode(TypeName);
  1114. n->val.type = T_String;
  1115. n->val.val.str = "now";
  1116. n->typename = t;
  1118. t->name = xlateSqlType("time");
  1119. t->setof = FALSE;
  1120. t->typmod = -1;
  1122. yyval.node = (Node *)n;
  1123. ;
  1124.     break;}
  1125. case 782:
  1126. #line 4425 "gram.y"
  1127. {
  1128. FuncCall *n = makeNode(FuncCall);
  1129. A_Const *s = makeNode(A_Const);
  1130. TypeName *t = makeNode(TypeName);
  1132. n->funcname = xlateSqlType("time");
  1133. n->args = lcons(s, NIL);
  1135. s->val.type = T_String;
  1136. s->val.val.str = "now";
  1137. s->typename = t;
  1139. t->name = xlateSqlType("time");
  1140. t->setof = FALSE;
  1141. t->typmod = -1;
  1143. if (yyvsp[-1].ival != 0)
  1144. elog(NOTICE,"CURRENT_TIME(%d) precision not implemented; zero used instead",yyvsp[-1].ival);
  1146. yyval.node = (Node *)n;
  1147. ;
  1148.     break;}
  1149. case 783:
  1150. #line 4447 "gram.y"
  1151. {
  1152. A_Const *n = makeNode(A_Const);
  1153. TypeName *t = makeNode(TypeName);
  1155. n->val.type = T_String;
  1156. n->val.val.str = "now";
  1157. n->typename = t;
  1159. t->name = xlateSqlType("timestamp");
  1160. t->setof = FALSE;
  1161. t->typmod = -1;
  1163. yyval.node = (Node *)n;
  1164. ;
  1165.     break;}
  1166. case 784:
  1167. #line 4462 "gram.y"
  1168. {
  1169. FuncCall *n = makeNode(FuncCall);
  1170. A_Const *s = makeNode(A_Const);
  1171. TypeName *t = makeNode(TypeName);
  1173. n->funcname = xlateSqlType("timestamp");
  1174. n->args = lcons(s, NIL);
  1176. s->val.type = T_String;
  1177. s->val.val.str = "now";
  1178. s->typename = t;
  1180. t->name = xlateSqlType("timestamp");
  1181. t->setof = FALSE;
  1182. t->typmod = -1;
  1184. if (yyvsp[-1].ival != 0)
  1185. elog(NOTICE,"CURRENT_TIMESTAMP(%d) precision not implemented; zero used instead",yyvsp[-1].ival);
  1187. yyval.node = (Node *)n;
  1188. ;
  1189.     break;}
  1190. case 785:
  1191. #line 4484 "gram.y"
  1192. {
  1193. FuncCall *n = makeNode(FuncCall);
  1194. n->funcname = "getpgusername";
  1195. n->args = NIL;
  1196. yyval.node = (Node *)n;
  1197. ;
  1198.     break;}
  1199. case 786:
  1200. #line 4491 "gram.y"
  1201. {
  1202. FuncCall *n = makeNode(FuncCall);
  1203. n->funcname = "getpgusername";
  1204. n->args = NIL;
  1205. yyval.node = (Node *)n;
  1206. ;
  1207.     break;}
  1208. case 787:
  1209. #line 4498 "gram.y"
  1210. {
  1211. FuncCall *n = makeNode(FuncCall);
  1212. n->funcname = "strpos";
  1213. n->args = yyvsp[-1].list;
  1214. yyval.node = (Node *)n;
  1215. ;
  1216.     break;}
  1217. case 788:
  1218. #line 4505 "gram.y"
  1219. {
  1220. FuncCall *n = makeNode(FuncCall);
  1221. n->funcname = "substr";
  1222. n->args = yyvsp[-1].list;
  1223. yyval.node = (Node *)n;
  1224. ;
  1225.     break;}
  1226. case 789:
  1227. #line 4513 "gram.y"
  1228. {
  1229. FuncCall *n = makeNode(FuncCall);
  1230. n->funcname = "btrim";
  1231. n->args = yyvsp[-1].list;
  1232. yyval.node = (Node *)n;
  1233. ;
  1234.     break;}
  1235. case 790:
  1236. #line 4520 "gram.y"
  1237. {
  1238. FuncCall *n = makeNode(FuncCall);
  1239. n->funcname = "ltrim";
  1240. n->args = yyvsp[-1].list;
  1241. yyval.node = (Node *)n;
  1242. ;
  1243.     break;}
  1244. case 791:
  1245. #line 4527 "gram.y"
  1246. {
  1247. FuncCall *n = makeNode(FuncCall);
  1248. n->funcname = "rtrim";
  1249. n->args = yyvsp[-1].list;
  1250. yyval.node = (Node *)n;
  1251. ;
  1252.     break;}
  1253. case 792:
  1254. #line 4534 "gram.y"
  1255. {
  1256. FuncCall *n = makeNode(FuncCall);
  1257. n->funcname = "btrim";
  1258. n->args = yyvsp[-1].list;
  1259. yyval.node = (Node *)n;
  1260. ;
  1261.     break;}
  1262. case 793:
  1263. #line 4543 "gram.y"
  1264. {
  1265. A_Indices *ai = makeNode(A_Indices);
  1266. ai->lidx = NULL;
  1267. ai->uidx = yyvsp[-2].node;
  1268. yyval.list = lcons(ai, yyvsp[0].list);
  1269. ;
  1270.     break;}
  1271. case 794:
  1272. #line 4550 "gram.y"
  1273. {
  1274. A_Indices *ai = makeNode(A_Indices);
  1275. ai->lidx = yyvsp[-4].node;
  1276. ai->uidx = yyvsp[-2].node;
  1277. yyval.list = lcons(ai, yyvsp[0].list);
  1278. ;
  1279.     break;}
  1280. case 795:
  1281. #line 4557 "gram.y"
  1282. { yyval.list = NIL; ;
  1283.     break;}
  1284. case 796:
  1285. #line 4561 "gram.y"
  1286. { yyval.list = lcons(yyvsp[0].node, NIL); ;
  1287.     break;}
  1288. case 797:
  1289. #line 4563 "gram.y"
  1290. { yyval.list = lappend(yyvsp[-2].list, yyvsp[0].node); ;
  1291.     break;}
  1292. case 798:
  1293. #line 4565 "gram.y"
  1294. { yyval.list = lappend(yyvsp[-2].list, yyvsp[0].node); ;
  1295.     break;}
  1296. case 799:
  1297. #line 4569 "gram.y"
  1298. {
  1299. A_Const *n = makeNode(A_Const);
  1300. n->val.type = T_String;
  1301. n->val.val.str = yyvsp[-2].str;
  1302. yyval.list = lappend(lcons((Node *)n,NIL), yyvsp[0].node);
  1303. ;
  1304.     break;}
  1305. case 800:
  1306. #line 4576 "gram.y"
  1307. { yyval.list = NIL; ;
  1308.     break;}
  1309. case 801:
  1310. #line 4579 "gram.y"
  1311. { yyval.str = yyvsp[0].str; ;
  1312.     break;}
  1313. case 802:
  1314. #line 4580 "gram.y"
  1315. { yyval.str = "tz_hour"; ;
  1316.     break;}
  1317. case 803:
  1318. #line 4581 "gram.y"
  1319. { yyval.str = "tz_minute"; ;
  1320.     break;}
  1321. case 804:
  1322. #line 4585 "gram.y"
  1323. { yyval.list = makeList(yyvsp[0].node, yyvsp[-2].node, -1); ;
  1324.     break;}
  1325. case 805:
  1326. #line 4587 "gram.y"
  1327. { yyval.list = NIL; ;
  1328.     break;}
  1329. case 806:
  1330. #line 4591 "gram.y"
  1331. {
  1332. yyvsp[-1].attr->indirection = yyvsp[0].list;
  1333. yyval.node = (Node *)yyvsp[-1].attr;
  1334. ;
  1335.     break;}
  1336. case 807:
  1337. #line 4596 "gram.y"
  1338. { yyval.node = yyvsp[0].node;  ;
  1339.     break;}
  1340. case 808:
  1341. #line 4598 "gram.y"
  1342. { yyval.node = makeA_Expr(OP, "-", NULL, yyvsp[0].node); ;
  1343.     break;}
  1344. case 809:
  1345. #line 4600 "gram.y"
  1346. { yyval.node = makeA_Expr(OP, "+", yyvsp[-2].node, yyvsp[0].node); ;
  1347.     break;}
  1348. case 810:
  1349. #line 4602 "gram.y"
  1350. { yyval.node = makeA_Expr(OP, "-", yyvsp[-2].node, yyvsp[0].node); ;
  1351.     break;}
  1352. case 811:
  1353. #line 4604 "gram.y"
  1354. { yyval.node = makeA_Expr(OP, "/", yyvsp[-2].node, yyvsp[0].node); ;
  1355.     break;}
  1356. case 812:
  1357. #line 4606 "gram.y"
  1358. { yyval.node = makeA_Expr(OP, "%", yyvsp[-2].node, yyvsp[0].node); ;
  1359.     break;}
  1360. case 813:
  1361. #line 4608 "gram.y"
  1362. { yyval.node = makeA_Expr(OP, "*", yyvsp[-2].node, yyvsp[0].node); ;
  1363.     break;}
  1364. case 814:
  1365. #line 4610 "gram.y"
  1366. { yyval.node = makeA_Expr(OP, "|", NULL, yyvsp[0].node); ;
  1367.     break;}
  1368. case 815:
  1369. #line 4612 "gram.y"
  1370. {
  1371. yyval.node = (Node *)yyvsp[-2].node;
  1372. /* AexprConst can be either A_Const or ParamNo */
  1373. if (nodeTag(yyvsp[-2].node) == T_A_Const) {
  1374. ((A_Const *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  1375. } else if (nodeTag(yyvsp[-2].node) == T_Param) {
  1376. ((ParamNo *)yyvsp[-2].node)->typename = yyvsp[0].typnam;
  1377. /* otherwise, try to transform to a function call */
  1378. } else {
  1379. FuncCall *n = makeNode(FuncCall);
  1380. n->funcname = yyvsp[0].typnam->name;
  1381. n->args = lcons(yyvsp[-2].node,NIL);
  1382. yyval.node = (Node *)n;
  1383. }
  1384. ;
  1385.     break;}
  1386. case 816:
  1387. #line 4628 "gram.y"
  1388. {
  1389. yyval.node = (Node *)yyvsp[-3].node;
  1390. /* AexprConst can be either A_Const or ParamNo */
  1391. if (nodeTag(yyvsp[-3].node) == T_A_Const) {
  1392. ((A_Const *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  1393. } else if (nodeTag(yyvsp[-3].node) == T_Param) {
  1394. ((ParamNo *)yyvsp[-3].node)->typename = yyvsp[-1].typnam;
  1395. /* otherwise, try to transform to a function call */
  1396. } else {
  1397. FuncCall *n = makeNode(FuncCall);
  1398. n->funcname = yyvsp[-1].typnam->name;
  1399. n->args = lcons(yyvsp[-3].node,NIL);
  1400. yyval.node = (Node *)n;
  1401. }
  1402. ;
  1403.     break;}
  1404. case 817:
  1405. #line 4644 "gram.y"
  1406. { yyval.node = yyvsp[-1].node; ;
  1407.     break;}
  1408. case 818:
  1409. #line 4646 "gram.y"
  1410. { yyval.node = makeA_Expr(OP, yyvsp[-1].str, yyvsp[-2].node, yyvsp[0].node); ;
  1411.     break;}
  1412. case 819:
  1413. #line 4648 "gram.y"
  1414. { yyval.node = makeA_Expr(OP, yyvsp[-1].str, NULL, yyvsp[0].node); ;
  1415.     break;}
  1416. case 820:
  1417. #line 4650 "gram.y"
  1418. { yyval.node = makeA_Expr(OP, yyvsp[0].str, yyvsp[-1].node, NULL); ;
  1419.     break;}
  1420. case 821:
  1421. #line 4652 "gram.y"
  1422. {
  1423. /* could be a column name or a relation_name */
  1424. Ident *n = makeNode(Ident);
  1425. n->name = yyvsp[0].str;
  1426. n->indirection = NULL;
  1427. yyval.node = (Node *)n;
  1428. ;
  1429.     break;}
  1430. case 822:
  1431. #line 4660 "gram.y"
  1432. {
  1433. FuncCall *n = makeNode(FuncCall);
  1434. n->funcname = yyvsp[-2].str;
  1435. n->args = NIL;
  1436. yyval.node = (Node *)n;
  1437. ;
  1438.     break;}
  1439. case 823:
  1440. #line 4667 "gram.y"
  1441. {
  1442. FuncCall *n = makeNode(FuncCall);
  1443. n->funcname = yyvsp[-3].str;
  1444. n->args = yyvsp[-1].list;
  1445. yyval.node = (Node *)n;
  1446. ;
  1447.     break;}
  1448. case 824:
  1449. #line 4674 "gram.y"
  1450. {
  1451. FuncCall *n = makeNode(FuncCall);
  1452. n->funcname = "strpos";
  1453. n->args = yyvsp[-1].list;
  1454. yyval.node = (Node *)n;
  1455. ;
  1456.     break;}
  1457. case 825:
  1458. #line 4681 "gram.y"
  1459. {
  1460. FuncCall *n = makeNode(FuncCall);
  1461. n->funcname = "substr";
  1462. n->args = yyvsp[-1].list;
  1463. yyval.node = (Node *)n;
  1464. ;
  1465.     break;}
  1466. case 826:
  1467. #line 4689 "gram.y"
  1468. {
  1469. FuncCall *n = makeNode(FuncCall);
  1470. n->funcname = "btrim";
  1471. n->args = yyvsp[-1].list;
  1472. yyval.node = (Node *)n;
  1473. ;
  1474.     break;}
  1475. case 827:
  1476. #line 4696 "gram.y"
  1477. {
  1478. FuncCall *n = makeNode(FuncCall);
  1479. n->funcname = "ltrim";
  1480. n->args = yyvsp[-1].list;
  1481. yyval.node = (Node *)n;
  1482. ;
  1483.     break;}
  1484. case 828:
  1485. #line 4703 "gram.y"
  1486. {
  1487. FuncCall *n = makeNode(FuncCall);
  1488. n->funcname = "rtrim";
  1489. n->args = yyvsp[-1].list;
  1490. yyval.node = (Node *)n;
  1491. ;
  1492.     break;}
  1493. case 829:
  1494. #line 4710 "gram.y"
  1495. {
  1496. FuncCall *n = makeNode(FuncCall);
  1497. n->funcname = "btrim";
  1498. n->args = yyvsp[-1].list;
  1499. yyval.node = (Node *)n;
  1500. ;
  1501.     break;}
  1502. case 830:
  1503. #line 4719 "gram.y"
  1504. {
  1505. yyval.list = nconc(nconc(yyvsp[-2].list,yyvsp[-1].list),yyvsp[0].list);
  1506. ;
  1507.     break;}
  1508. case 831:
  1509. #line 4723 "gram.y"
  1510. { yyval.list = NIL; ;
  1511.     break;}
  1512. case 832:
  1513. #line 4727 "gram.y"
  1514. { yyval.list = yyvsp[0].list; ;
  1515.     break;}
  1516. case 833:
  1517. #line 4729 "gram.y"
  1518. {
  1519. A_Const *n = makeNode(A_Const);
  1520. n->val.type = T_Integer;
  1521. n->val.val.ival = 1;
  1522. yyval.list = lcons((Node *)n,NIL);
  1523. ;
  1524.     break;}
  1525. case 834:
  1526. #line 4738 "gram.y"
  1527. { yyval.list = yyvsp[0].list; ;
  1528.     break;}
  1529. case 835:
  1530. #line 4740 "gram.y"
  1531. { yyval.list = NIL; ;
  1532.     break;}
  1533. case 836:
  1534. #line 4744 "gram.y"
  1535. { yyval.list = lappend(yyvsp[0].list, yyvsp[-2].node); ;
  1536.     break;}
  1537. case 837:
  1538. #line 4746 "gram.y"
  1539. { yyval.list = yyvsp[0].list; ;
  1540.     break;}
  1541. case 838:
  1542. #line 4748 "gram.y"
  1543. { yyval.list = yyvsp[0].list; ;
  1544.     break;}
  1545. case 839:
  1546. #line 4752 "gram.y"
  1547. {
  1548. SubLink *n = makeNode(SubLink);
  1549. n->subselect = yyvsp[0].node;
  1550. yyval.node = (Node *)n;
  1551. ;
  1552.     break;}
  1553. case 840:
  1554. #line 4758 "gram.y"
  1555. { yyval.node = yyvsp[0].node; ;
  1556.     break;}
  1557. case 841:
  1558. #line 4762 "gram.y"
  1559. { yyval.node = makeA_Expr(OP, "=", lfirst(saved_In_Expr), yyvsp[0].node); ;
  1560.     break;}
  1561. case 842:
  1562. #line 4764 "gram.y"
  1563. { yyval.node = makeA_Expr(OR, NULL, yyvsp[-2].node,
  1564. makeA_Expr(OP, "=", lfirst(saved_In_Expr), yyvsp[0].node));
  1565. ;
  1566.     break;}
  1567. case 843:
  1568. #line 4770 "gram.y"
  1569. {
  1570. SubLink *n = makeNode(SubLink);
  1571. n->subselect = yyvsp[0].node;
  1572. yyval.node = (Node *)n;
  1573. ;
  1574.     break;}
  1575. case 844:
  1576. #line 4776 "gram.y"
  1577. { yyval.node = yyvsp[0].node; ;
  1578.     break;}
  1579. case 845:
  1580. #line 4780 "gram.y"
  1581. { yyval.node = makeA_Expr(OP, "<>", lfirst(saved_In_Expr), yyvsp[0].node); ;
  1582.     break;}
  1583. case 846:
  1584. #line 4782 "gram.y"
  1585. { yyval.node = makeA_Expr(AND, NULL, yyvsp[-2].node,
  1586. makeA_Expr(OP, "<>", lfirst(saved_In_Expr), yyvsp[0].node));
  1587. ;
  1588.     break;}
  1589. case 847:
  1590. #line 4803 "gram.y"
  1591. {
  1592. CaseExpr *c = makeNode(CaseExpr);
  1593. c->arg = yyvsp[-3].node;
  1594. c->args = yyvsp[-2].list;
  1595. c->defresult = yyvsp[-1].node;
  1596. yyval.node = (Node *)c;
  1597. ;
  1598.     break;}
  1599. case 848:
  1600. #line 4811 "gram.y"
  1601. {
  1602. CaseExpr *c = makeNode(CaseExpr);
  1603. CaseWhen *w = makeNode(CaseWhen);
  1604. /*
  1605. A_Const *n = makeNode(A_Const);
  1606. n->val.type = T_Null;
  1607. w->result = (Node *)n;
  1608. */
  1609. w->expr = makeA_Expr(OP, "=", yyvsp[-3].node, yyvsp[-1].node);
  1610. c->args = lcons(w, NIL);
  1611. c->defresult = yyvsp[-3].node;
  1612. yyval.node = (Node *)c;
  1613. ;
  1614.     break;}
  1615. case 849:
  1616. #line 4825 "gram.y"
  1617. {
  1618. CaseExpr *c = makeNode(CaseExpr);
  1619. CaseWhen *w;
  1620. List *l;
  1621. foreach (l,yyvsp[-1].list)
  1622. {
  1623. w = makeNode(CaseWhen);
  1624. w->expr = makeA_Expr(NOTNULL, NULL, lfirst(l), NULL);
  1625. w->result = lfirst(l);
  1626. c->args = lappend(c->args, w);
  1627. }
  1628. yyval.node = (Node *)c;
  1629. ;
  1630.     break;}
  1631. case 850:
  1632. #line 4841 "gram.y"
  1633. { yyval.list = lappend(yyvsp[-1].list, yyvsp[0].node); ;
  1634.     break;}
  1635. case 851:
  1636. #line 4843 "gram.y"
  1637. { yyval.list = lcons(yyvsp[0].node, NIL); ;
  1638.     break;}
  1639. case 852:
  1640. #line 4847 "gram.y"
  1641. {
  1642. CaseWhen *w = makeNode(CaseWhen);
  1643. w->expr = yyvsp[-2].node;
  1644. w->result = yyvsp[0].node;
  1645. yyval.node = (Node *)w;
  1646. ;
  1647.     break;}
  1648. case 853:
  1649. #line 4855 "gram.y"
  1650. { yyval.node = yyvsp[0].node; ;
  1651.     break;}
  1652. case 854:
  1653. #line 4856 "gram.y"
  1654. { yyval.node = NULL; ;
  1655.     break;}
  1656. case 855:
  1657. #line 4860 "gram.y"
  1658. {
  1659. yyvsp[-1].attr->indirection = yyvsp[0].list;
  1660. yyval.node = (Node *)yyvsp[-1].attr;
  1661. ;
  1662.     break;}
  1663. case 856:
  1664. #line 4865 "gram.y"
  1665. {
  1666. /* could be a column name or a relation_name */
  1667. Ident *n = makeNode(Ident);
  1668. n->name = yyvsp[0].str;
  1669. n->indirection = NULL;
  1670. yyval.node = (Node *)n;
  1671. ;
  1672.     break;}
  1673. case 857:
  1674. #line 4873 "gram.y"
  1675. { yyval.node = NULL; ;
  1676.     break;}
  1677. case 858:
  1678. #line 4877 "gram.y"
  1679. {
  1680. yyval.attr = makeNode(Attr);
  1681. yyval.attr->relname = yyvsp[-2].str;
  1682. yyval.attr->paramNo = NULL;
  1683. yyval.attr->attrs = yyvsp[0].list;
  1684. yyval.attr->indirection = NULL;
  1685. ;
  1686.     break;}
  1687. case 859:
  1688. #line 4885 "gram.y"
  1689. {
  1690. yyval.attr = makeNode(Attr);
  1691. yyval.attr->relname = NULL;
  1692. yyval.attr->paramNo = yyvsp[-2].paramno;
  1693. yyval.attr->attrs = yyvsp[0].list;
  1694. yyval.attr->indirection = NULL;
  1695. ;
  1696.     break;}
  1697. case 860:
  1698. #line 4895 "gram.y"
  1699. { yyval.list = lcons(makeString(yyvsp[0].str), NIL); ;
  1700.     break;}
  1701. case 861:
  1702. #line 4897 "gram.y"
  1703. { yyval.list = lappend(yyvsp[-2].list, makeString(yyvsp[0].str)); ;
  1704.     break;}
  1705. case 862:
  1706. #line 4899 "gram.y"
  1707. { yyval.list = lappend(yyvsp[-2].list, makeString("*")); ;
  1708.     break;}
  1709. case 863:
  1710. #line 4910 "gram.y"
  1711. { yyval.list = lappend(yyvsp[-2].list,yyvsp[0].target);  ;
  1712.     break;}
  1713. case 864:
  1714. #line 4912 "gram.y"
  1715. { yyval.list = lcons(yyvsp[0].target, NIL);  ;
  1716.     break;}
  1717. case 865:
  1718. #line 4914 "gram.y"
  1719. {
  1720. ResTarget *rt = makeNode(ResTarget);
  1721. Attr *att = makeNode(Attr);
  1722. att->relname = "*";
  1723. att->paramNo = NULL;
  1724. att->attrs = NULL;
  1725. att->indirection = NIL;
  1726. rt->name = NULL;
  1727. rt->indirection = NULL;
  1728. rt->val = (Node *)att;
  1729. yyval.list = lcons(rt, NIL);
  1730. ;
  1731.     break;}
  1732. case 866:
  1733. #line 4929 "gram.y"
  1734. {
  1735. yyval.target = makeNode(ResTarget);
  1736. yyval.target->name = yyvsp[-3].str;
  1737. yyval.target->indirection = yyvsp[-2].list;
  1738. yyval.target->val = (Node *)yyvsp[0].node;
  1739. ;
  1740.     break;}
  1741. case 867:
  1742. #line 4936 "gram.y"
  1743. {
  1744. yyval.target = makeNode(ResTarget);
  1745. yyval.target->name = NULL;
  1746. yyval.target->indirection = yyvsp[0].list;
  1747. yyval.target->val = (Node *)yyvsp[-1].attr;
  1748. ;
  1749.     break;}
  1750. case 868:
  1751. #line 4943 "gram.y"
  1752. {
  1753. Attr *att = makeNode(Attr);
  1754. att->relname = yyvsp[-2].str;
  1755. att->paramNo = NULL;
  1756. att->attrs = lcons(makeString("*"), NIL);
  1757. att->indirection = NIL;
  1758. yyval.target = makeNode(ResTarget);
  1759. yyval.target->name = NULL;
  1760. yyval.target->indirection = NULL;
  1761. yyval.target->val = (Node *)att;
  1762. ;
  1763.     break;}
  1764. case 869:
  1765. #line 4962 "gram.y"
  1766. { yyval.list = lappend(yyvsp[-2].list, yyvsp[0].target);  ;
  1767.     break;}
  1768. case 870:
  1769. #line 4964 "gram.y"
  1770. { yyval.list = lcons(yyvsp[0].target, NIL);  ;
  1771.     break;}
  1772. case 871:
  1773. #line 4969 "gram.y"
  1774. {
  1775. yyval.target = makeNode(ResTarget);
  1776. yyval.target->name = yyvsp[0].str;
  1777. yyval.target->indirection = NULL;
  1778. yyval.target->val = (Node *)yyvsp[-2].node;
  1779. ;
  1780.     break;}
  1781. case 872:
  1782. #line 4976 "gram.y"
  1783. {
  1784. yyval.target = makeNode(ResTarget);
  1785. yyval.target->name = NULL;
  1786. yyval.target->indirection = NULL;
  1787. yyval.target->val = (Node *)yyvsp[0].node;
  1788. ;
  1789.     break;}
  1790. case 873:
  1791. #line 4983 "gram.y"
  1792. {
  1793. Attr *att = makeNode(Attr);
  1794. att->relname = yyvsp[-2].str;
  1795. att->paramNo = NULL;
  1796. att->attrs = lcons(makeString("*"), NIL);
  1797. att->indirection = NIL;
  1798. yyval.target = makeNode(ResTarget);
  1799. yyval.target->name = NULL;
  1800. yyval.target->indirection = NULL;
  1801. yyval.target->val = (Node *)att;
  1802. ;
  1803.     break;}
  1804. case 874:
  1805. #line 4995 "gram.y"
  1806. {
  1807. Attr *att = makeNode(Attr);
  1808. att->relname = "*";
  1809. att->paramNo = NULL;
  1810. att->attrs = NULL;
  1811. att->indirection = NIL;
  1812. yyval.target = makeNode(ResTarget);
  1813. yyval.target->name = NULL;
  1814. yyval.target->indirection = NULL;
  1815. yyval.target->val = (Node *)att;
  1816. ;
  1817.     break;}
  1818. case 875:
  1819. #line 5008 "gram.y"
  1820. { yyval.str = yyvsp[0].str; ;
  1821.     break;}
  1822. case 876:
  1823. #line 5009 "gram.y"
  1824. { yyval.str = NULL; ;
  1825.     break;}
  1826. case 877:
  1827. #line 5013 "gram.y"
  1828. {
  1829. yyval.str = yyvsp[0].str;
  1830. StrNCpy(saved_relname, yyvsp[0].str, NAMEDATALEN);
  1831. ;
  1832.     break;}
  1833. case 878:
  1834. #line 5018 "gram.y"
  1835. {
  1836. /* disallow refs to variable system tables */
  1837. if (strcmp(LogRelationName, yyvsp[0].str) == 0
  1838.    || strcmp(VariableRelationName, yyvsp[0].str) == 0)
  1839. elog(ERROR,"%s cannot be accessed by users",yyvsp[0].str);
  1840. else
  1841. yyval.str = yyvsp[0].str;
  1842. StrNCpy(saved_relname, yyvsp[0].str, NAMEDATALEN);
  1843. ;
  1844.     break;}
  1845. case 879:
  1846. #line 5029 "gram.y"
  1847. { yyval.str = yyvsp[0].str; ;
  1848.     break;}
  1849. case 880:
  1850. #line 5030 "gram.y"
  1851. { yyval.str = yyvsp[0].str; ;
  1852.     break;}
  1853. case 881:
  1854. #line 5031 "gram.y"
  1855. { yyval.str = yyvsp[0].str; ;
  1856.     break;}
  1857. case 882:
  1858. #line 5032 "gram.y"
  1859. { yyval.str = yyvsp[0].str; ;
  1860.     break;}
  1861. case 883:
  1862. #line 5033 "gram.y"
  1863. { yyval.str = yyvsp[0].str; ;
  1864.     break;}
  1865. case 884:
  1866. #line 5039 "gram.y"
  1867. { yyval.str = yyvsp[0].str; ;
  1868.     break;}
  1869. case 885:
  1870. #line 5040 "gram.y"
  1871. { yyval.str = xlateSqlFunc(yyvsp[0].str); ;
  1872.     break;}
  1873. case 886:
  1874. #line 5042 "gram.y"
  1875. { yyval.str = yyvsp[0].str; ;
  1876.     break;}
  1877. case 887:
  1878. #line 5049 "gram.y"
  1879. {
  1880. A_Const *n = makeNode(A_Const);
  1881. n->val.type = T_Integer;
  1882. n->val.val.ival = yyvsp[0].ival;
  1883. yyval.node = (Node *)n;
  1884. ;
  1885.     break;}
  1886. case 888:
  1887. #line 5056 "gram.y"
  1888. {
  1889. A_Const *n = makeNode(A_Const);
  1890. n->val.type = T_Float;
  1891. n->val.val.dval = yyvsp[0].dval;
  1892. yyval.node = (Node *)n;
  1893. ;
  1894.     break;}
  1895. case 889:
  1896. #line 5063 "gram.y"
  1897. {
  1898. A_Const *n = makeNode(A_Const);
  1899. n->val.type = T_String;
  1900. n->val.val.str = yyvsp[0].str;
  1901. yyval.node = (Node *)n;
  1902. ;
  1903.     break;}
  1904. case 890:
  1905. #line 5070 "gram.y"
  1906. {
  1907. A_Const *n = makeNode(A_Const);
  1908. n->typename = yyvsp[-1].typnam;
  1909. n->val.type = T_String;
  1910. n->val.val.str = yyvsp[0].str;
  1911. yyval.node = (Node *)n;
  1912. ;
  1913.     break;}
  1914. case 891:
  1915. #line 5078 "gram.y"
  1916. { yyval.node = (Node *)yyvsp[0].paramno;  ;
  1917.     break;}
  1918. case 892:
  1919. #line 5080 "gram.y"
  1920. {
  1921. A_Const *n = makeNode(A_Const);
  1922. n->val.type = T_String;
  1923. n->val.val.str = "t";
  1924. n->typename = makeNode(TypeName);
  1925. n->typename->name = xlateSqlType("bool");
  1926. n->typename->typmod = -1;
  1927. yyval.node = (Node *)n;
  1928. ;
  1929.     break;}
  1930. case 893:
  1931. #line 5090 "gram.y"
  1932. {
  1933. A_Const *n = makeNode(A_Const);
  1934. n->val.type = T_String;
  1935. n->val.val.str = "f";
  1936. n->typename = makeNode(TypeName);
  1937. n->typename->name = xlateSqlType("bool");
  1938. n->typename->typmod = -1;
  1939. yyval.node = (Node *)n;
  1940. ;
  1941.     break;}
  1942. case 894:
  1943. #line 5102 "gram.y"
  1944. {
  1945. yyval.paramno = makeNode(ParamNo);
  1946. yyval.paramno->number = yyvsp[-1].ival;
  1947. yyval.paramno->indirection = yyvsp[0].list;
  1948. ;
  1949.     break;}
  1950. case 895:
  1951. #line 5109 "gram.y"
  1952. { yyval.ival = yyvsp[0].ival; ;
  1953.     break;}
  1954. case 896:
  1955. #line 5110 "gram.y"
  1956. { yyval.str = yyvsp[0].str; ;
  1957.     break;}
  1958. case 897:
  1959. #line 5111 "gram.y"
  1960. { yyval.str = yyvsp[0].str; ;
  1961.     break;}
  1962. case 898:
  1963. #line 5119 "gram.y"
  1964. { yyval.str = xlateSqlType(yyvsp[0].str); ;
  1965.     break;}
  1966. case 899:
  1967. #line 5121 "gram.y"
  1968. { yyval.str = xlateSqlType(yyvsp[0].str); ;
  1969.     break;}
  1970. case 900:
  1971. #line 5123 "gram.y"
  1972. { yyval.str = xlateSqlType(yyvsp[0].str); ;
  1973.     break;}
  1974. case 901:
  1975. #line 5133 "gram.y"
  1976. { yyval.str = yyvsp[0].str; ;
  1977.     break;}
  1978. case 902:
  1979. #line 5134 "gram.y"
  1980. { yyval.str = yyvsp[0].str; ;
  1981.     break;}
  1982. case 903:
  1983. #line 5135 "gram.y"
  1984. { yyval.str = "absolute"; ;
  1985.     break;}
  1986. case 904:
  1987. #line 5136 "gram.y"
  1988. { yyval.str = "access"; ;
  1989.     break;}
  1990. case 905:
  1991. #line 5137 "gram.y"
  1992. { yyval.str = "action"; ;
  1993.     break;}
  1994. case 906:
  1995. #line 5138 "gram.y"
  1996. { yyval.str = "after"; ;
  1997.     break;}
  1998. case 907:
  1999. #line 5139 "gram.y"
  2000. { yyval.str = "aggregate"; ;
  2001.     break;}
  2002. case 908:
  2003. #line 5140 "gram.y"
  2004. { yyval.str = "backward"; ;
  2005.     break;}
  2006. case 909:
  2007. #line 5141 "gram.y"
  2008. { yyval.str = "before"; ;
  2009.     break;}
  2010. case 910:
  2011. #line 5142 "gram.y"
  2012. { yyval.str = "cache"; ;
  2013.     break;}
  2014. case 911:
  2015. #line 5143 "gram.y"
  2016. { yyval.str = "committed"; ;
  2017.     break;}
  2018. case 912:
  2019. #line 5144 "gram.y"
  2020. { yyval.str = "createdb"; ;
  2021.     break;}
  2022. case 913:
  2023. #line 5145 "gram.y"
  2024. { yyval.str = "createuser"; ;
  2025.     break;}
  2026. case 914:
  2027. #line 5146 "gram.y"
  2028. { yyval.str = "cycle"; ;
  2029.     break;}
  2030. case 915:
  2031. #line 5147 "gram.y"
  2032. { yyval.str = "database"; ;
  2033.     break;}
  2034. case 916:
  2035. #line 5148 "gram.y"
  2036. { yyval.str = "delimiters"; ;
  2037.     break;}
  2038. case 917:
  2039. #line 5149 "gram.y"
  2040. { yyval.str = "double"; ;
  2041.     break;}
  2042. case 918:
  2043. #line 5150 "gram.y"
  2044. { yyval.str = "each"; ;
  2045.     break;}
  2046. case 919:
  2047. #line 5151 "gram.y"
  2048. { yyval.str = "encoding"; ;
  2049.     break;}
  2050. case 920:
  2051. #line 5152 "gram.y"
  2052. { yyval.str = "exclusive"; ;
  2053.     break;}
  2054. case 921:
  2055. #line 5153 "gram.y"
  2056. { yyval.str = "forward"; ;
  2057.     break;}
  2058. case 922:
  2059. #line 5154 "gram.y"
  2060. { yyval.str = "function"; ;
  2061.     break;}
  2062. case 923:
  2063. #line 5155 "gram.y"
  2064. { yyval.str = "handler"; ;
  2065.     break;}
  2066. case 924:
  2067. #line 5156 "gram.y"
  2068. { yyval.str = "increment"; ;
  2069.     break;}
  2070. case 925:
  2071. #line 5157 "gram.y"
  2072. { yyval.str = "index"; ;
  2073.     break;}
  2074. case 926:
  2075. #line 5158 "gram.y"
  2076. { yyval.str = "inherits"; ;
  2077.     break;}
  2078. case 927:
  2079. #line 5159 "gram.y"
  2080. { yyval.str = "insensitive"; ;
  2081.     break;}
  2082. case 928:
  2083. #line 5160 "gram.y"
  2084. { yyval.str = "instead"; ;
  2085.     break;}
  2086. case 929:
  2087. #line 5161 "gram.y"
  2088. { yyval.str = "isnull"; ;
  2089.     break;}
  2090. case 930:
  2091. #line 5162 "gram.y"
  2092. { yyval.str = "isolation"; ;
  2093.     break;}
  2094. case 931:
  2095. #line 5163 "gram.y"
  2096. { yyval.str = "key"; ;
  2097.     break;}
  2098. case 932:
  2099. #line 5164 "gram.y"
  2100. { yyval.str = "language"; ;
  2101.     break;}
  2102. case 933:
  2103. #line 5165 "gram.y"
  2104. { yyval.str = "lancompiler"; ;
  2105.     break;}
  2106. case 934:
  2107. #line 5166 "gram.y"
  2108. { yyval.str = "level"; ;
  2109.     break;}
  2110. case 935:
  2111. #line 5167 "gram.y"
  2112. { yyval.str = "location"; ;
  2113.     break;}
  2114. case 936:
  2115. #line 5168 "gram.y"
  2116. { yyval.str = "match"; ;
  2117.     break;}
  2118. case 937:
  2119. #line 5169 "gram.y"
  2120. { yyval.str = "maxvalue"; ;
  2121.     break;}
  2122. case 938:
  2123. #line 5170 "gram.y"
  2124. { yyval.str = "minvalue"; ;
  2125.     break;}
  2126. case 939:
  2127. #line 5171 "gram.y"
  2128. { yyval.str = "mode"; ;
  2129.     break;}
  2130. case 940:
  2131. #line 5172 "gram.y"
  2132. { yyval.str = "next"; ;
  2133.     break;}
  2134. case 941:
  2135. #line 5173 "gram.y"
  2136. { yyval.str = "nocreatedb"; ;
  2137.     break;}
  2138. case 942:
  2139. #line 5174 "gram.y"
  2140. { yyval.str = "nocreateuser"; ;
  2141.     break;}
  2142. case 943:
  2143. #line 5175 "gram.y"
  2144. { yyval.str = "nothing"; ;
  2145.     break;}
  2146. case 944:
  2147. #line 5176 "gram.y"
  2148. { yyval.str = "notnull"; ;
  2149.     break;}
  2150. case 945:
  2151. #line 5177 "gram.y"
  2152. { yyval.str = "of"; ;
  2153.     break;}
  2154. case 946:
  2155. #line 5178 "gram.y"
  2156. { yyval.str = "oids"; ;
  2157.     break;}
  2158. case 947:
  2159. #line 5179 "gram.y"
  2160. { yyval.str = "only"; ;
  2161.     break;}
  2162. case 948:
  2163. #line 5180 "gram.y"
  2164. { yyval.str = "operator"; ;
  2165.     break;}
  2166. case 949:
  2167. #line 5181 "gram.y"
  2168. { yyval.str = "option"; ;
  2169.     break;}
  2170. case 950:
  2171. #line 5182 "gram.y"
  2172. { yyval.str = "password"; ;
  2173.     break;}
  2174. case 951:
  2175. #line 5183 "gram.y"
  2176. { yyval.str = "prior"; ;
  2177.     break;}
  2178. case 952:
  2179. #line 5184 "gram.y"
  2180. { yyval.str = "privileges"; ;
  2181.     break;}
  2182. case 953:
  2183. #line 5185 "gram.y"
  2184. { yyval.str = "procedural"; ;
  2185.     break;}
  2186. case 954:
  2187. #line 5186 "gram.y"
  2188. { yyval.str = "read"; ;
  2189.     break;}
  2190. case 955:
  2191. #line 5187 "gram.y"
  2192. { yyval.str = "relative"; ;
  2193.     break;}
  2194. case 956:
  2195. #line 5188 "gram.y"
  2196. { yyval.str = "rename"; ;
  2197.     break;}
  2198. case 957:
  2199. #line 5189 "gram.y"
  2200. { yyval.str = "returns"; ;
  2201.     break;}
  2202. case 958:
  2203. #line 5190 "gram.y"
  2204. { yyval.str = "row"; ;
  2205.     break;}
  2206. case 959:
  2207. #line 5191 "gram.y"
  2208. { yyval.str = "rule"; ;
  2209.     break;}
  2210. case 960:
  2211. #line 5192 "gram.y"
  2212. { yyval.str = "scroll"; ;
  2213.     break;}
  2214. case 961:
  2215. #line 5193 "gram.y"
  2216. { yyval.str = "sequence"; ;
  2217.     break;}
  2218. case 962:
  2219. #line 5194 "gram.y"
  2220. { yyval.str = "serial"; ;
  2221.     break;}
  2222. case 963:
  2223. #line 5195 "gram.y"
  2224. { yyval.str = "serializable"; ;
  2225.     break;}
  2226. case 964:
  2227. #line 5196 "gram.y"
  2228. { yyval.str = "share"; ;
  2229.     break;}
  2230. case 965:
  2231. #line 5197 "gram.y"
  2232. { yyval.str = "start"; ;
  2233.     break;}
  2234. case 966:
  2235. #line 5198 "gram.y"
  2236. { yyval.str = "statement"; ;
  2237.     break;}
  2238. case 967:
  2239. #line 5199 "gram.y"
  2240. { yyval.str = "stdin"; ;
  2241.     break;}
  2242. case 968:
  2243. #line 5200 "gram.y"
  2244. { yyval.str = "stdout"; ;
  2245.     break;}
  2246. case 969:
  2247. #line 5201 "gram.y"
  2248. { yyval.str = "time"; ;
  2249.     break;}
  2250. case 970:
  2251. #line 5202 "gram.y"
  2252. { yyval.str = "timestamp"; ;
  2253.     break;}
  2254. case 971:
  2255. #line 5203 "gram.y"
  2256. { yyval.str = "timezone_hour"; ;
  2257.     break;}
  2258. case 972:
  2259. #line 5204 "gram.y"
  2260. { yyval.str = "timezone_minute"; ;
  2261.     break;}
  2262. case 973:
  2263. #line 5205 "gram.y"
  2264. { yyval.str = "trigger"; ;
  2265.     break;}
  2266. case 974:
  2267. #line 5206 "gram.y"
  2268. { yyval.str = "trusted"; ;
  2269.     break;}
  2270. case 975:
  2271. #line 5207 "gram.y"
  2272. { yyval.str = "type"; ;
  2273.     break;}
  2274. case 976:
  2275. #line 5208 "gram.y"
  2276. { yyval.str = "valid"; ;
  2277.     break;}
  2278. case 977:
  2279. #line 5209 "gram.y"
  2280. { yyval.str = "version"; ;
  2281.     break;}
  2282. case 978:
  2283. #line 5210 "gram.y"
  2284. { yyval.str = "zone"; ;
  2285.     break;}
  2286. case 979:
  2287. #line 5223 "gram.y"
  2288. { yyval.str = yyvsp[0].str; ;
  2289.     break;}
  2290. case 980:
  2291. #line 5224 "gram.y"
  2292. { yyval.str = "abort"; ;
  2293.     break;}
  2294. case 981:
  2295. #line 5225 "gram.y"
  2296. { yyval.str = "analyze"; ;
  2297.     break;}
  2298. case 982:
  2299. #line 5226 "gram.y"
  2300. { yyval.str = "binary"; ;
  2301.     break;}
  2302. case 983:
  2303. #line 5227 "gram.y"
  2304. { yyval.str = "case"; ;
  2305.     break;}
  2306. case 984:
  2307. #line 5228 "gram.y"
  2308. { yyval.str = "cluster"; ;
  2309.     break;}
  2310. case 985:
  2311. #line 5229 "gram.y"
  2312. { yyval.str = "coalesce"; ;
  2313.     break;}
  2314. case 986:
  2315. #line 5230 "gram.y"
  2316. { yyval.str = "constraint"; ;
  2317.     break;}
  2318. case 987:
  2319. #line 5231 "gram.y"
  2320. { yyval.str = "copy"; ;
  2321.     break;}
  2322. case 988:
  2323. #line 5232 "gram.y"
  2324. { yyval.str = "current"; ;
  2325.     break;}
  2326. case 989:
  2327. #line 5233 "gram.y"
  2328. { yyval.str = "do"; ;
  2329.     break;}
  2330. case 990:
  2331. #line 5234 "gram.y"
  2332. { yyval.str = "else"; ;
  2333.     break;}
  2334. case 991:
  2335. #line 5235 "gram.y"
  2336. { yyval.str = "end"; ;
  2337.     break;}
  2338. case 992:
  2339. #line 5236 "gram.y"
  2340. { yyval.str = "explain"; ;
  2341.     break;}
  2342. case 993:
  2343. #line 5237 "gram.y"
  2344. { yyval.str = "extend"; ;
  2345.     break;}
  2346. case 994:
  2347. #line 5238 "gram.y"
  2348. { yyval.str = "false"; ;
  2349.     break;}
  2350. case 995:
  2351. #line 5239 "gram.y"
  2352. { yyval.str = "foreign"; ;
  2353.     break;}
  2354. case 996:
  2355. #line 5240 "gram.y"
  2356. { yyval.str = "global"; ;
  2357.     break;}
  2358. case 997:
  2359. #line 5241 "gram.y"
  2360. { yyval.str = "group"; ;
  2361.     break;}
  2362. case 998:
  2363. #line 5242 "gram.y"
  2364. { yyval.str = "listen"; ;
  2365.     break;}
  2366. case 999:
  2367. #line 5243 "gram.y"
  2368. { yyval.str = "load"; ;
  2369.     break;}
  2370. case 1000:
  2371. #line 5244 "gram.y"
  2372. { yyval.str = "local"; ;
  2373.     break;}
  2374. case 1001:
  2375. #line 5245 "gram.y"
  2376. { yyval.str = "lock"; ;
  2377.     break;}
  2378. case 1002:
  2379. #line 5246 "gram.y"
  2380. { yyval.str = "move"; ;
  2381.     break;}
  2382. case 1003:
  2383. #line 5247 "gram.y"
  2384. { yyval.str = "new"; ;
  2385.     break;}
  2386. case 1004:
  2387. #line 5248 "gram.y"
  2388. { yyval.str = "none"; ;
  2389.     break;}
  2390. case 1005:
  2391. #line 5249 "gram.y"
  2392. { yyval.str = "nullif"; ;
  2393.     break;}
  2394. case 1006:
  2395. #line 5250 "gram.y"
  2396. { yyval.str = "order"; ;
  2397.     break;}
  2398. case 1007:
  2399. #line 5251 "gram.y"
  2400. { yyval.str = "position"; ;
  2401.     break;}
  2402. case 1008:
  2403. #line 5252 "gram.y"
  2404. { yyval.str = "precision"; ;
  2405.     break;}
  2406. case 1009:
  2407. #line 5253 "gram.y"
  2408. { yyval.str = "reset"; ;
  2409.     break;}
  2410. case 1010:
  2411. #line 5254 "gram.y"
  2412. { yyval.str = "setof"; ;
  2413.     break;}
  2414. case 1011:
  2415. #line 5255 "gram.y"
  2416. { yyval.str = "show"; ;
  2417.     break;}
  2418. case 1012:
  2419. #line 5256 "gram.y"
  2420. { yyval.str = "table"; ;
  2421.     break;}
  2422. case 1013:
  2423. #line 5257 "gram.y"
  2424. { yyval.str = "then"; ;
  2425.     break;}
  2426. case 1014:
  2427. #line 5258 "gram.y"
  2428. { yyval.str = "transaction"; ;
  2429.     break;}
  2430. case 1015:
  2431. #line 5259 "gram.y"
  2432. { yyval.str = "true"; ;
  2433.     break;}
  2434. case 1016:
  2435. #line 5260 "gram.y"
  2436. { yyval.str = "vacuum"; ;
  2437.     break;}
  2438. case 1017:
  2439. #line 5261 "gram.y"
  2440. { yyval.str = "verbose"; ;
  2441.     break;}
  2442. case 1018:
  2443. #line 5262 "gram.y"
  2444. { yyval.str = "when"; ;
  2445.     break;}
  2446. case 1019:
  2447. #line 5266 "gram.y"
  2448. {
  2449. if (QueryIsRule)
  2450. yyval.str = "*CURRENT*";
  2451. else
  2452. elog(ERROR,"CURRENT used in non-rule query");
  2453. ;
  2454.     break;}
  2455. case 1020:
  2456. #line 5273 "gram.y"
  2457. {
  2458. if (QueryIsRule)
  2459. yyval.str = "*NEW*";
  2460. else
  2461. elog(ERROR,"NEW used in non-rule query");
  2462. ;
  2463.     break;}
  2464. }
  2465.    /* the action file gets copied in in place of this dollarsign */
  2466. #line 543 "/usr/share/misc/bison.simple"
  2468.   yyvsp -= yylen;
  2469.   yyssp -= yylen;
  2470. #ifdef YYLSP_NEEDED
  2471.   yylsp -= yylen;
  2472. #endif
  2474. #if YYDEBUG != 0
  2475.   if (yydebug)
  2476.     {
  2477.       short *ssp1 = yyss - 1;
  2478.       fprintf (stderr, "state stack now");
  2479.       while (ssp1 != yyssp)
  2480. fprintf (stderr, " %d", *++ssp1);
  2481.       fprintf (stderr, "n");
  2482.     }
  2483. #endif
  2485.   *++yyvsp = yyval;
  2487. #ifdef YYLSP_NEEDED
  2488.   yylsp++;
  2489.   if (yylen == 0)
  2490.     {
  2491.       yylsp->first_line = yylloc.first_line;
  2492.       yylsp->first_column = yylloc.first_column;
  2493.       yylsp->last_line = (yylsp-1)->last_line;
  2494.       yylsp->last_column = (yylsp-1)->last_column;
  2495.       yylsp->text = 0;
  2496.     }
  2497.   else
  2498.     {
  2499.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  2500.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  2501.     }
  2502. #endif
  2504.   /* Now "shift" the result of the reduction.
  2505.      Determine what state that goes to,
  2506.      based on the state we popped back to
  2507.      and the rule number reduced by.  */
  2509.   yyn = yyr1[yyn];
  2511.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  2512.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  2513.     yystate = yytable[yystate];
  2514.   else
  2515.     yystate = yydefgoto[yyn - YYNTBASE];
  2517.   goto yynewstate;
  2519. yyerrlab:   /* here on detecting error */
  2521.   if (! yyerrstatus)
  2522.     /* If not already recovering from an error, report this error.  */
  2523.     {
  2524.       ++yynerrs;
  2526. #ifdef YYERROR_VERBOSE
  2527.       yyn = yypact[yystate];
  2529.       if (yyn > YYFLAG && yyn < YYLAST)
  2530. {
  2531.   int size = 0;
  2532.   char *msg;
  2533.   int x, count;
  2535.   count = 0;
  2536.   /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
  2537.   for (x = (yyn < 0 ? -yyn : 0);
  2538.        x < (sizeof(yytname) / sizeof(char *)); x++)
  2539.     if (yycheck[x + yyn] == x)
  2540.       size += strlen(yytname[x]) + 15, count++;
  2541.   msg = (char *) malloc(size + 15);
  2542.   if (msg != 0)
  2543.     {
  2544.       strcpy(msg, "parse error");
  2546.       if (count < 5)
  2547. {
  2548.   count = 0;
  2549.   for (x = (yyn < 0 ? -yyn : 0);
  2550.        x < (sizeof(yytname) / sizeof(char *)); x++)
  2551.     if (yycheck[x + yyn] == x)
  2552.       {
  2553. strcat(msg, count == 0 ? ", expecting `" : " or `");
  2554. strcat(msg, yytname[x]);
  2555. strcat(msg, "'");
  2556. count++;
  2557.       }
  2558. }
  2559.       yyerror(msg);
  2560.       free(msg);
  2561.     }
  2562.   else
  2563.     yyerror ("parse error; also virtual memory exceeded");
  2564. }
  2565.       else
  2566. #endif /* YYERROR_VERBOSE */
  2567. yyerror("parse error");
  2568.     }
  2570.   goto yyerrlab1;
  2571. yyerrlab1:   /* here on error raised explicitly by an action */
  2573.   if (yyerrstatus == 3)
  2574.     {
  2575.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  2577.       /* return failure if at end of input */
  2578.       if (yychar == YYEOF)
  2579. YYABORT;
  2581. #if YYDEBUG != 0
  2582.       if (yydebug)
  2583. fprintf(stderr, "Discarding token %d (%s).n", yychar, yytname[yychar1]);
  2584. #endif
  2586.       yychar = YYEMPTY;
  2587.     }
  2589.   /* Else will try to reuse lookahead token
  2590.      after shifting the error token.  */
  2592.   yyerrstatus = 3; /* Each real token shifted decrements this */
  2594.   goto yyerrhandle;
  2596. yyerrdefault:  /* current state does not do anything special for the error token. */
  2598. #if 0
  2599.   /* This is wrong; only states that explicitly want error tokens
  2600.      should shift them.  */
  2601.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  2602.   if (yyn) goto yydefault;
  2603. #endif
  2605. yyerrpop:   /* pop the current state because it cannot handle the error token */
  2607.   if (yyssp == yyss) YYABORT;
  2608.   yyvsp--;
  2609.   yystate = *--yyssp;
  2610. #ifdef YYLSP_NEEDED
  2611.   yylsp--;
  2612. #endif
  2614. #if YYDEBUG != 0
  2615.   if (yydebug)
  2616.     {
  2617.       short *ssp1 = yyss - 1;
  2618.       fprintf (stderr, "Error: state stack now");
  2619.       while (ssp1 != yyssp)
  2620. fprintf (stderr, " %d", *++ssp1);
  2621.       fprintf (stderr, "n");
  2622.     }
  2623. #endif
  2625. yyerrhandle:
  2627.   yyn = yypact[yystate];
  2628.   if (yyn == YYFLAG)
  2629.     goto yyerrdefault;
  2631.   yyn += YYTERROR;
  2632.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  2633.     goto yyerrdefault;
  2635.   yyn = yytable[yyn];
  2636.   if (yyn < 0)
  2637.     {
  2638.       if (yyn == YYFLAG)
  2639. goto yyerrpop;
  2640.       yyn = -yyn;
  2641.       goto yyreduce;
  2642.     }
  2643.   else if (yyn == 0)
  2644.     goto yyerrpop;
  2646.   if (yyn == YYFINAL)
  2647.     YYACCEPT;
  2649. #if YYDEBUG != 0
  2650.   if (yydebug)
  2651.     fprintf(stderr, "Shifting error token, ");
  2652. #endif
  2654.   *++yyvsp = yylval;
  2655. #ifdef YYLSP_NEEDED
  2656.   *++yylsp = yylloc;
  2657. #endif
  2659.   yystate = yyn;
  2660.   goto yynewstate;
  2662.  yyacceptlab:
  2663.   /* YYACCEPT comes here.  */
  2664.   if (yyfree_stacks)
  2665.     {
  2666.       free (yyss);
  2667.       free (yyvs);
  2668. #ifdef YYLSP_NEEDED
  2669.       free (yyls);
  2670. #endif
  2671.     }
  2672.   return 0;
  2674.  yyabortlab:
  2675.   /* YYABORT comes here.  */
  2676.   if (yyfree_stacks)
  2677.     {
  2678.       free (yyss);
  2679.       free (yyvs);
  2680. #ifdef YYLSP_NEEDED
  2681.       free (yyls);
  2682. #endif
  2683.     }
  2684.   return 1;
  2685. }
  2686. #line 5281 "gram.y"
  2689. static Node *
  2690. makeA_Expr(int oper, char *opname, Node *lexpr, Node *rexpr)
  2691. {
  2692. A_Expr *a = makeNode(A_Expr);
  2693. a->oper = oper;
  2694. a->opname = opname;
  2695. a->lexpr = lexpr;
  2696. a->rexpr = rexpr;
  2697. return (Node *)a;
  2698. }
  2700. /* makeRowExpr()
  2701.  * Generate separate operator nodes for a single row descriptor expression.
  2702.  * Perhaps this should go deeper in the parser someday...
  2703.  * - thomas 1997-12-22
  2704.  */
  2705. static Node *
  2706. makeRowExpr(char *opr, List *largs, List *rargs)
  2707. {
  2708. Node *expr = NULL;
  2709. Node *larg, *rarg;
  2711. if (length(largs) != length(rargs))
  2712. elog(ERROR,"Unequal number of entries in row expression");
  2714. if (lnext(largs) != NIL)
  2715. expr = makeRowExpr(opr,lnext(largs),lnext(rargs));
  2717. larg = lfirst(largs);
  2718. rarg = lfirst(rargs);
  2720. if ((strcmp(opr, "=") == 0)
  2721.  || (strcmp(opr, "<") == 0)
  2722.  || (strcmp(opr, "<=") == 0)
  2723.  || (strcmp(opr, ">") == 0)
  2724.  || (strcmp(opr, ">=") == 0))
  2725. {
  2726. if (expr == NULL)
  2727. expr = makeA_Expr(OP, opr, larg, rarg);
  2728. else
  2729. expr = makeA_Expr(AND, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
  2730. }
  2731. else if (strcmp(opr, "<>") == 0)
  2732. {
  2733. if (expr == NULL)
  2734. expr = makeA_Expr(OP, opr, larg, rarg);
  2735. else
  2736. expr = makeA_Expr(OR, NULL, expr, makeA_Expr(OP, opr, larg, rarg));
  2737. }
  2738. else
  2739. {
  2740. elog(ERROR,"Operator '%s' not implemented for row expressions",opr);
  2741. }
  2743. return expr;
  2744. }
  2746. static void
  2747. mapTargetColumns(List *src, List *dst)
  2748. {
  2749. ColumnDef *s;
  2750. ResTarget *d;
  2752. if (length(src) != length(dst))
  2753. elog(ERROR,"CREATE TABLE/AS SELECT has mismatched column count");
  2755. while ((src != NIL) && (dst != NIL))
  2756. {
  2757. s = (ColumnDef *)lfirst(src);
  2758. d = (ResTarget *)lfirst(dst);
  2760. d->name = s->colname;
  2762. src = lnext(src);
  2763. dst = lnext(dst);
  2764. }
  2766. return;
  2767. } /* mapTargetColumns() */
  2769. static Node *makeIndexable(char *opname, Node *lexpr, Node *rexpr)
  2770. {
  2771. Node *result = NULL;
  2773. /* we do this so indexes can be used */
  2774. if (strcmp(opname,"~") == 0 ||
  2775. strcmp(opname,"~*") == 0)
  2776. {
  2777. if (nodeTag(rexpr) == T_A_Const &&
  2778.    ((A_Const *)rexpr)->val.type == T_String &&
  2779.    ((A_Const *)rexpr)->val.val.str[0] == '^')
  2780. {
  2781. A_Const *n = (A_Const *)rexpr;
  2782. char *match_least = palloc(strlen(n->val.val.str)+2);
  2783. char *match_most = palloc(strlen(n->val.val.str)+2);
  2784. int pos, match_pos=0;
  2785. bool found_special = false;
  2787. /* Cannot optimize if unquoted | { } is present in pattern */
  2788. for (pos = 1; n->val.val.str[pos]; pos++)
  2789. {
  2790. if (n->val.val.str[pos] == '|' ||
  2791.     n->val.val.str[pos] == '{' ||
  2792.     n->val.val.str[pos] == '}')
  2793. {
  2794. found_special = true;
  2795. break;
  2796. }
  2797.       if (n->val.val.str[pos] == '\')
  2798. {
  2799. pos++;
  2800. if (n->val.val.str[pos] == '')
  2801. break;
  2802. }
  2803. }
  2805. if (!found_special)
  2806. {
  2807. /* note start at pos 1 to skip leading ^ */
  2808. for (pos = 1; n->val.val.str[pos]; pos++)
  2809. {
  2810. if (n->val.val.str[pos] == '.' ||
  2811. n->val.val.str[pos] == '?' ||
  2812. n->val.val.str[pos] == '*' ||
  2813. n->val.val.str[pos] == '[' ||
  2814. n->val.val.str[pos] == '$' ||
  2815. (strcmp(opname,"~*") == 0 && isalpha(n->val.val.str[pos])))
  2816.       break;
  2817.       if (n->val.val.str[pos] == '\')
  2818. {
  2819. pos++;
  2820. if (n->val.val.str[pos] == '')
  2821. break;
  2822. }
  2823. match_least[match_pos] = n->val.val.str[pos];
  2824. match_most[match_pos++] = n->val.val.str[pos];
  2825. }
  2827. if (match_pos != 0)
  2828. {
  2829. A_Const *least = makeNode(A_Const);
  2830. A_Const *most = makeNode(A_Const);
  2832. /* make strings to be used in index use */
  2833. match_least[match_pos] = '';
  2834. match_most[match_pos] = '377';
  2835. match_most[match_pos+1] = '';
  2836. least->val.type = T_String;
  2837. least->val.val.str = match_least;
  2838. most->val.type = T_String;
  2839. most->val.val.str = match_most;
  2840. #ifdef USE_LOCALE
  2841. result = makeA_Expr(AND, NULL,
  2842. makeA_Expr(OP, "~", lexpr, rexpr),
  2843. makeA_Expr(OP, ">=", lexpr, (Node *)least));
  2844. #else
  2845. result = makeA_Expr(AND, NULL,
  2846. makeA_Expr(OP, "~", lexpr, rexpr),
  2847. makeA_Expr(AND, NULL,
  2848. makeA_Expr(OP, ">=", lexpr, (Node *)least),
  2849. makeA_Expr(OP, "<=", lexpr, (Node *)most)));
  2850. #endif
  2851. }
  2852. }
  2853. }
  2854. }
  2855. else if (strcmp(opname,"~~") == 0)
  2856. {
  2857. if (nodeTag(rexpr) == T_A_Const &&
  2858.    ((A_Const *)rexpr)->val.type == T_String)
  2859. {
  2860. A_Const *n = (A_Const *)rexpr;
  2861. char *match_least = palloc(strlen(n->val.val.str)+2);
  2862. char *match_most = palloc(strlen(n->val.val.str)+2);
  2863. int pos, match_pos=0;
  2865. for (pos = 0; n->val.val.str[pos]; pos++)
  2866. {
  2867. /* % and _ are wildcard characters in LIKE */
  2868. if (n->val.val.str[pos] == '%' ||
  2869. n->val.val.str[pos] == '_')
  2870. break;
  2871. /* Backslash quotes the next character */
  2872. if (n->val.val.str[pos] == '\')
  2873. {
  2874. pos++;
  2875. if (n->val.val.str[pos] == '')
  2876. break;
  2877. }
  2878. /*
  2879.  * NOTE: this code used to think that %% meant a literal %,
  2880.  * but textlike() itself does not think that, and the SQL92
  2881.  * spec doesn't say any such thing either.
  2882.  */
  2883. match_least[match_pos] = n->val.val.str[pos];
  2884. match_most[match_pos++] = n->val.val.str[pos];
  2885. }
  2887. if (match_pos != 0)
  2888. {
  2889. A_Const *least = makeNode(A_Const);
  2890. A_Const *most = makeNode(A_Const);
  2892. /* make strings to be used in index use */
  2893. match_least[match_pos] = '';
  2894. match_most[match_pos] = '377';
  2895. match_most[match_pos+1] = '';
  2896. least->val.type = T_String;
  2897. least->val.val.str = match_least;
  2898. most->val.type = T_String;
  2899. most->val.val.str = match_most;
  2900. #ifdef USE_LOCALE
  2901. result = makeA_Expr(AND, NULL,
  2902. makeA_Expr(OP, "~~", lexpr, rexpr),
  2903. makeA_Expr(OP, ">=", lexpr, (Node *)least));
  2904. #else
  2905. result = makeA_Expr(AND, NULL,
  2906. makeA_Expr(OP, "~~", lexpr, rexpr),
  2907. makeA_Expr(AND, NULL,
  2908. makeA_Expr(OP, ">=", lexpr, (Node *)least),
  2909. makeA_Expr(OP, "<=", lexpr, (Node *)most)));
  2910. #endif
  2911. }
  2912. }
  2913. }
  2915. if (result == NULL)
  2916. result = makeA_Expr(OP, opname, lexpr, rexpr);
  2917. return result;
  2918. } /* makeIndexable() */
  2921. /* xlateSqlFunc()
  2922.  * Convert alternate type names to internal Postgres types.
  2923.  * Do not convert "float", since that is handled elsewhere
  2924.  *  for FLOAT(p) syntax.
  2925.  */
  2926. static char *
  2927. xlateSqlFunc(char *name)
  2928. {
  2929. if (!strcasecmp(name,"character_length")
  2930.  || !strcasecmp(name,"char_length"))
  2931. return "length";
  2932. else
  2933. return name;
  2934. } /* xlateSqlFunc() */
  2936. /* xlateSqlType()
  2937.  * Convert alternate type names to internal Postgres types.
  2938.  */
  2939. static char *
  2940. xlateSqlType(char *name)
  2941. {
  2942. if (!strcasecmp(name,"int")
  2943.  || !strcasecmp(name,"integer"))
  2944. return "int4";
  2945. else if (!strcasecmp(name, "smallint"))
  2946. return "int2";
  2947. else if (!strcasecmp(name, "real")
  2948.  || !strcasecmp(name, "float"))
  2949. return "float8";
  2950. else if (!strcasecmp(name, "interval"))
  2951. return "timespan";
  2952. else if (!strcasecmp(name, "boolean"))
  2953. return "bool";
  2954. else
  2955. return name;
  2956. } /* xlateSqlType() */
  2959. void parser_init(Oid *typev, int nargs)
  2960. {
  2961. QueryIsRule = FALSE;
  2962. saved_relname[0]= '';
  2963. saved_In_Expr = NULL;
  2965. param_type_init(typev, nargs);
  2966. }
  2969. /* FlattenStringList()
  2970.  * Traverse list of string nodes and convert to a single string.
  2971.  * Used for reconstructing string form of complex expressions.
  2972.  *
  2973.  * Allocate at least one byte for terminator.
  2974.  */
  2975. static char *
  2976. FlattenStringList(List *list)
  2977. {
  2978. List *l;
  2979. Value *v;
  2980. char *s;
  2981. char *sp;
  2982. int nlist, len = 0;
  2984. nlist = length(list);
  2985. l = list;
  2986. while(l != NIL) {
  2987. v = (Value *)lfirst(l);
  2988. sp = v->val.str;
  2989. l = lnext(l);
  2990. len += strlen(sp);
  2991. };
  2992. len += nlist;
  2994. s = (char*) palloc(len+1);
  2995. *s = '';
  2997. l = list;
  2998. while(l != NIL) {
  2999. v = (Value *)lfirst(l);
  3000. sp = v->val.str;
  3001. l = lnext(l);
  3002. strcat(s,sp);
  3003. if (l != NIL) strcat(s," ");
  3004. };
  3005. *(s+len) = '';
  3007. return s;
  3008. } /* FlattenStringList() */
  3011. /* makeConstantList()
  3012.  * Convert constant value node into string node.
  3013.  */
  3014. static List *
  3015. makeConstantList( A_Const *n)
  3016. {
  3017. List *result = NIL;
  3018. char *typval = NULL;
  3019. char *defval = NULL;
  3021. if (nodeTag(n) != T_A_Const) {
  3022. elog(ERROR,"Cannot handle non-constant parameter");
  3024. } else if (n->val.type == T_Float) {
  3025. defval = (char*) palloc(20+1);
  3026. sprintf( defval, "%g", n->val.val.dval);
  3027. result = lcons( makeString(defval), NIL);
  3029. } else if (n->val.type == T_Integer) {
  3030. defval = (char*) palloc(20+1);
  3031. sprintf( defval, "%ld", n->val.val.ival);
  3032. result = lcons( makeString(defval), NIL);
  3034. } else if (n->val.type == T_String) {
  3035. defval = (char*) palloc(strlen( ((A_Const *) n)->val.val.str) + 3);
  3036. strcpy( defval, "'");
  3037. strcat( defval, ((A_Const *) n)->val.val.str);
  3038. strcat( defval, "'");
  3039. if (n->typename != NULL)
  3040. {
  3041. typval = (char*) palloc(strlen( n->typename->name) + 1);
  3042. strcpy(typval, n->typename->name);
  3043. result = lappend( lcons( makeString(typval), NIL), makeString(defval));
  3044. }
  3045. else
  3046. {
  3047. result = lcons( makeString(defval), NIL);
  3048. }
  3050. } else {
  3051. elog(ERROR,"Internal error in makeConstantList(): cannot encode node");
  3052. };
  3054. return result;
  3055. } /* makeConstantList() */
  3058. /* fmtId()
  3059.  * Check input string for non-lowercase/non-numeric characters.
  3060.  * Returns either input string or input surrounded by double quotes.
  3061.  */
  3062. static char *
  3063. fmtId(char *rawid)
  3064. {
  3065. static char *cp;
  3067. for (cp = rawid; *cp != ''; cp++)
  3068. if (! (islower(*cp) || isdigit(*cp) || (*cp == '_'))) break;
  3070. if (*cp != '') {
  3071. cp = palloc(strlen(rawid)+3);
  3072. strcpy(cp,""");
  3073. strcat(cp,rawid);
  3074. strcat(cp,""");
  3075. } else {
  3076. cp = rawid;
  3077. };
  3079. return cp;
  3080. }
  3082. /*
  3083.  * param_type_init()
  3084.  *
  3085.  * keep enough information around fill out the type of param nodes
  3086.  * used in postquel functions
  3087.  */
  3088. static void
  3089. param_type_init(Oid *typev, int nargs)
  3090. {
  3091. pfunc_num_args = nargs;
  3092. param_type_info = typev;
  3093. }
  3095. Oid param_type(int t)
  3096. {
  3097. if ((t > pfunc_num_args) || (t == 0))
  3098. return InvalidOid;
  3099. return param_type_info[t - 1];
  3100. }
  3102. /*
  3103.  * The optimizer doesn't like '-' 4 for index use.  It only checks for
  3104.  * Var '=' Const.  It wants an integer of -4, so we try to merge the
  3105.  * minus into the constant.
  3106.  */
  3107. static Node *doNegate(Node *n)
  3108. {
  3109. if (IsA(n, A_Const))
  3110. {
  3111. A_Const *con = (A_Const *)n;
  3113. if (con->val.type == T_Integer)
  3114. {
  3115. con->val.val.ival = -con->val.val.ival;
  3116. return n;
  3117. }
  3118. if (con->val.type == T_Float)
  3119. {
  3120. con->val.val.dval = -con->val.val.dval;
  3121. return n;
  3122. }
  3123. }
  3125. return makeA_Expr(OP, "-", NULL, n);
  3126. }