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

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

数据库系统

开发平台：

Unix_Linux

parse_expr.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * parse_expr.c
  4.  *   handle expressions in parser
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.50.2.1 1999/09/13 04:21:21 thomas Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  18. #include "postgres.h"
  19. #include "catalog/pg_type.h"
  20. #include "nodes/makefuncs.h"
  21. #include "nodes/nodes.h"
  22. #include "nodes/params.h"
  23. #include "nodes/relation.h"
  24. #include "parse.h"
  25. #include "parser/analyze.h"
  26. #include "parser/gramparse.h"
  27. #include "parser/parse_expr.h"
  28. #include "parser/parse_func.h"
  29. #include "parser/parse_node.h"
  30. #include "parser/parse_relation.h"
  31. #include "parser/parse_target.h"
  32. #include "parser/parse_coerce.h"
  33. #include "utils/builtins.h"
  35. static Node *parser_typecast(Value *expr, TypeName *typename, int32 atttypmod);
  36. static Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
  38. /*
  39.  * transformExpr -
  40.  *   analyze and transform expressions. Type checking and type casting is
  41.  *   done here. The optimizer and the executor cannot handle the original
  42.  *   (raw) expressions collected by the parse tree. Hence the transformation
  43.  *   here.
  44.  */
  45. Node *
  46. transformExpr(ParseState *pstate, Node *expr, int precedence)
  47. {
  48. Node    *result = NULL;
  50. if (expr == NULL)
  51. return NULL;
  53. switch (nodeTag(expr))
  54. {
  55. case T_Attr:
  56. {
  57. Attr    *att = (Attr *) expr;
  58. Node    *temp;
  60. /* what if att.attrs == "*"? */
  61. temp = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,
  62.    precedence);
  63. if (att->indirection != NIL)
  64. {
  65. List    *idx = att->indirection;
  67. while (idx != NIL)
  68. {
  69. A_Indices  *ai = (A_Indices *) lfirst(idx);
  70. Node    *lexpr = NULL,
  71.    *uexpr;
  73. uexpr = transformExpr(pstate, ai->uidx, precedence); /* must exists */
  74. if (exprType(uexpr) != INT4OID)
  75. elog(ERROR, "array index expressions must be int4's");
  76. if (ai->lidx != NULL)
  77. {
  78. lexpr = transformExpr(pstate, ai->lidx, precedence);
  79. if (exprType(lexpr) != INT4OID)
  80. elog(ERROR, "array index expressions must be int4's");
  81. }
  82. ai->lidx = lexpr;
  83. ai->uidx = uexpr;
  85. /*
  86.  * note we reuse the list of indices, make sure we
  87.  * don't free them! Otherwise, make a new list
  88.  * here
  89.  */
  90. idx = lnext(idx);
  91. }
  92. result = (Node *) make_array_ref(temp, att->indirection);
  93. }
  94. else
  95. result = temp;
  96. break;
  97. }
  98. case T_A_Const:
  99. {
  100. A_Const    *con = (A_Const *) expr;
  101. Value    *val = &con->val;
  103. if (con->typename != NULL)
  104. result = parser_typecast(val, con->typename, -1);
  105. else
  106. result = (Node *) make_const(val);
  107. break;
  108. }
  109. case T_ParamNo:
  110. {
  111. ParamNo    *pno = (ParamNo *) expr;
  112. Oid toid;
  113. int paramno;
  114. Param    *param;
  116. paramno = pno->number;
  117. toid = param_type(paramno);
  118. if (!OidIsValid(toid))
  119. elog(ERROR, "Parameter '$%d' is out of range", paramno);
  120. param = makeNode(Param);
  121. param->paramkind = PARAM_NUM;
  122. param->paramid = (AttrNumber) paramno;
  123. param->paramname = "<unnamed>";
  124. param->paramtype = (Oid) toid;
  125. param->param_tlist = (List *) NULL;
  127. if (pno->indirection != NIL)
  128. {
  129. List    *idx = pno->indirection;
  131. while (idx != NIL)
  132. {
  133. A_Indices  *ai = (A_Indices *) lfirst(idx);
  134. Node    *lexpr = NULL,
  135.    *uexpr;
  137. uexpr = transformExpr(pstate, ai->uidx, precedence); /* must exists */
  138. if (exprType(uexpr) != INT4OID)
  139. elog(ERROR, "array index expressions must be int4's");
  140. if (ai->lidx != NULL)
  141. {
  142. lexpr = transformExpr(pstate, ai->lidx, precedence);
  143. if (exprType(lexpr) != INT4OID)
  144. elog(ERROR, "array index expressions must be int4's");
  145. }
  146. ai->lidx = lexpr;
  147. ai->uidx = uexpr;
  149. /*
  150.  * note we reuse the list of indices, make sure we
  151.  * don't free them! Otherwise, make a new list
  152.  * here
  153.  */
  154. idx = lnext(idx);
  155. }
  156. result = (Node *) make_array_ref((Node *) param, pno->indirection);
  157. }
  158. else
  159. result = (Node *) param;
  160. break;
  161. }
  162. case T_A_Expr:
  163. {
  164. A_Expr    *a = (A_Expr *) expr;
  166. switch (a->oper)
  167. {
  168. case OP:
  169. {
  170. Node    *lexpr = transformExpr(pstate, a->lexpr, precedence);
  171. Node    *rexpr = transformExpr(pstate, a->rexpr, precedence);
  173. result = (Node *) make_op(a->opname, lexpr, rexpr);
  174. }
  175. break;
  176. case ISNULL:
  177. {
  178. Node    *lexpr = transformExpr(pstate, a->lexpr, precedence);
  180. result = ParseFuncOrColumn(pstate,
  181.   "nullvalue", lcons(lexpr, NIL),
  182.    &pstate->p_last_resno,
  183.    precedence);
  184. }
  185. break;
  186. case NOTNULL:
  187. {
  188. Node    *lexpr = transformExpr(pstate, a->lexpr, precedence);
  190. result = ParseFuncOrColumn(pstate,
  191.    "nonnullvalue", lcons(lexpr, NIL),
  192.    &pstate->p_last_resno,
  193.    precedence);
  194. }
  195. break;
  196. case AND:
  197. {
  198. Expr    *expr = makeNode(Expr);
  199. Node    *lexpr = transformExpr(pstate, a->lexpr, precedence);
  200. Node    *rexpr = transformExpr(pstate, a->rexpr, precedence);
  202. if (exprType(lexpr) != BOOLOID)
  203. elog(ERROR, "left-hand side of AND is type '%s', not bool",
  204.  typeidTypeName(exprType(lexpr)));
  206. if (exprType(rexpr) != BOOLOID)
  207. elog(ERROR, "right-hand side of AND is type '%s', not bool",
  208.  typeidTypeName(exprType(rexpr)));
  210. expr->typeOid = BOOLOID;
  211. expr->opType = AND_EXPR;
  212. expr->args = makeList(lexpr, rexpr, -1);
  213. result = (Node *) expr;
  214. }
  215. break;
  216. case OR:
  217. {
  218. Expr    *expr = makeNode(Expr);
  219. Node    *lexpr = transformExpr(pstate, a->lexpr, precedence);
  220. Node    *rexpr = transformExpr(pstate, a->rexpr, precedence);
  222. if (exprType(lexpr) != BOOLOID)
  223. elog(ERROR, "left-hand side of OR is type '%s', not bool",
  224.  typeidTypeName(exprType(lexpr)));
  225. if (exprType(rexpr) != BOOLOID)
  226. elog(ERROR, "right-hand side of OR is type '%s', not bool",
  227.  typeidTypeName(exprType(rexpr)));
  228. expr->typeOid = BOOLOID;
  229. expr->opType = OR_EXPR;
  230. expr->args = makeList(lexpr, rexpr, -1);
  231. result = (Node *) expr;
  232. }
  233. break;
  234. case NOT:
  235. {
  236. Expr    *expr = makeNode(Expr);
  237. Node    *rexpr = transformExpr(pstate, a->rexpr, precedence);
  239. if (exprType(rexpr) != BOOLOID)
  240. elog(ERROR, "argument to NOT is type '%s', not bool",
  241.  typeidTypeName(exprType(rexpr)));
  242. expr->typeOid = BOOLOID;
  243. expr->opType = NOT_EXPR;
  244. expr->args = makeList(rexpr, -1);
  245. result = (Node *) expr;
  246. }
  247. break;
  248. }
  249. break;
  250. }
  251. case T_Ident:
  252. {
  254. /*
  255.  * look for a column name or a relation name (the default
  256.  * behavior)
  257.  */
  258. result = transformIdent(pstate, expr, precedence);
  259. break;
  260. }
  261. case T_FuncCall:
  262. {
  263. FuncCall   *fn = (FuncCall *) expr;
  264. List    *args;
  266. /* transform the list of arguments */
  267. foreach(args, fn->args)
  268. lfirst(args) = transformExpr(pstate, (Node *) lfirst(args), precedence);
  269. result = ParseFuncOrColumn(pstate,
  270.    fn->funcname,
  271.    fn->args,
  272.    &pstate->p_last_resno,
  273.    precedence);
  274. break;
  275. }
  276. case T_SubLink:
  277. {
  278. SubLink    *sublink = (SubLink *) expr;
  279. List    *qtrees;
  280. Query    *qtree;
  282. pstate->p_hasSubLinks = true;
  283. qtrees = parse_analyze(lcons(sublink->subselect, NIL), pstate);
  284. if (length(qtrees) != 1)
  285. elog(ERROR, "parser: bad query in subselect");
  286. qtree = (Query *) lfirst(qtrees);
  287. if (qtree->commandType != CMD_SELECT ||
  288. qtree->resultRelation != 0)
  289. elog(ERROR, "parser: bad query in subselect");
  290. sublink->subselect = (Node *) qtree;
  292. if (sublink->subLinkType != EXISTS_SUBLINK)
  293. {
  294. char    *op = lfirst(sublink->oper);
  295. List    *left_list = sublink->lefthand;
  296. List    *right_list = qtree->targetList;
  297. List    *elist;
  299. foreach(elist, left_list)
  300. lfirst(elist) = transformExpr(pstate, lfirst(elist),
  301.   precedence);
  303. if (length(left_list) > 1 &&
  304. strcmp(op, "=") != 0 && strcmp(op, "<>") != 0)
  305. elog(ERROR, "parser: '%s' is not relational operator",
  306.  op);
  308. sublink->oper = NIL;
  310. /* Scan subquery's targetlist to find values that will be
  311.  * matched against lefthand values.  We need to ignore
  312.  * resjunk targets, so doing the outer iteration over
  313.  * right_list is easier than doing it over left_list.
  314.  */
  315. while (right_list != NIL)
  316. {
  317. TargetEntry *tent = (TargetEntry *) lfirst(right_list);
  318. Node    *lexpr;
  319. Expr    *op_expr;
  321. if (! tent->resdom->resjunk)
  322. {
  323. if (left_list == NIL)
  324. elog(ERROR, "parser: Subselect has too many fields.");
  325. lexpr = lfirst(left_list);
  326. left_list = lnext(left_list);
  327. op_expr = make_op(op, lexpr, tent->expr);
  328. if (op_expr->typeOid != BOOLOID &&
  329. sublink->subLinkType != EXPR_SUBLINK)
  330. elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
  331. sublink->oper = lappend(sublink->oper, op_expr);
  332. }
  333. right_list = lnext(right_list);
  334. }
  335. if (left_list != NIL)
  336. elog(ERROR, "parser: Subselect has too few fields.");
  337. }
  338. else
  339. sublink->oper = NIL;
  340. result = (Node *) expr;
  341. break;
  342. }
  344. case T_CaseExpr:
  345. {
  346. CaseExpr   *c = (CaseExpr *) expr;
  347. CaseWhen   *w;
  348. List    *args;
  349. Oid ptype;
  350. CATEGORY pcategory;
  352. /* transform the list of arguments */
  353. foreach(args, c->args)
  354. {
  355. w = lfirst(args);
  356. if (c->arg != NULL)
  357. {
  358. /* shorthand form was specified, so expand... */
  359. A_Expr    *a = makeNode(A_Expr);
  361. a->oper = OP;
  362. a->opname = "=";
  363. a->lexpr = c->arg;
  364. a->rexpr = w->expr;
  365. w->expr = (Node *) a;
  366. }
  367. lfirst(args) = transformExpr(pstate, (Node *) w, precedence);
  368. }
  370. /*
  371.  * It's not shorthand anymore, so drop the implicit
  372.  * argument. This is necessary to keep the executor from
  373.  * seeing an untransformed expression...
  374.  */
  375. c->arg = NULL;
  377. /* transform the default clause */
  378. if (c->defresult == NULL)
  379. {
  380. A_Const    *n = makeNode(A_Const);
  382. n->val.type = T_Null;
  383. c->defresult = (Node *) n;
  384. }
  385. c->defresult = transformExpr(pstate, (Node *) c->defresult, precedence);
  387. /* now check types across result clauses... */
  388. c->casetype = exprType(c->defresult);
  389. ptype = c->casetype;
  390. pcategory = TypeCategory(ptype);
  391. foreach(args, c->args)
  392. {
  393. Oid wtype;
  395. w = lfirst(args);
  396. wtype = exprType(w->result);
  397. /* move on to next one if no new information... */
  398. if (wtype && (wtype != UNKNOWNOID)
  399. && (wtype != ptype))
  400. {
  401. /* so far, only nulls so take anything... */
  402. if (!ptype)
  403. {
  404. ptype = wtype;
  405. pcategory = TypeCategory(ptype);
  406. }
  408. /*
  409.  * both types in different categories? then not
  410.  * much hope...
  411.  */
  412. else if ((TypeCategory(wtype) != pcategory)
  413.  || ((TypeCategory(wtype) == USER_TYPE)
  414. && (TypeCategory(c->casetype) == USER_TYPE)))
  415. {
  416. elog(ERROR, "CASE/WHEN types '%s' and '%s' not matched",
  417.  typeidTypeName(c->casetype), typeidTypeName(wtype));
  418. }
  420. /*
  421.  * new one is preferred and can convert? then take
  422.  * it...
  423.  */
  424. else if (IsPreferredType(pcategory, wtype)
  425.  && can_coerce_type(1, &ptype, &wtype))
  426. {
  427. ptype = wtype;
  428. pcategory = TypeCategory(ptype);
  429. }
  430. }
  431. }
  433. /* Convert default result clause, if necessary */
  434. if (c->casetype != ptype)
  435. {
  436. if (!c->casetype)
  437. {
  439. /*
  440.  * default clause is NULL, so assign preferred
  441.  * type from WHEN clauses...
  442.  */
  443. c->casetype = ptype;
  444. }
  445. else if (can_coerce_type(1, &c->casetype, &ptype))
  446. {
  447. c->defresult = coerce_type(pstate, c->defresult,
  448.  c->casetype, ptype, -1);
  449. c->casetype = ptype;
  450. }
  451. else
  452. {
  453. elog(ERROR, "CASE/ELSE unable to convert to type %s",
  454.  typeidTypeName(ptype));
  455. }
  456. }
  458. /* Convert when clauses, if not null and if necessary */
  459. foreach(args, c->args)
  460. {
  461. Oid wtype;
  463. w = lfirst(args);
  464. wtype = exprType(w->result);
  466. /*
  467.  * only bother with conversion if not NULL and
  468.  * different type...
  469.  */
  470. if (wtype && (wtype != UNKNOWNOID)
  471. && (wtype != ptype))
  472. {
  473. if (can_coerce_type(1, &wtype, &ptype))
  474. {
  475. w->result = coerce_type(pstate, w->result, wtype,
  476. ptype, -1);
  477. }
  478. else
  479. {
  480. elog(ERROR, "CASE/WHEN unable to convert to type %s",
  481.  typeidTypeName(ptype));
  482. }
  483. }
  484. }
  486. result = expr;
  487. break;
  488. }
  490. case T_CaseWhen:
  491. {
  492. CaseWhen   *w = (CaseWhen *) expr;
  494. w->expr = transformExpr(pstate, (Node *) w->expr, precedence);
  495. if (exprType(w->expr) != BOOLOID)
  496. elog(ERROR, "WHEN clause must have a boolean result");
  498. /*
  499.  * result is NULL for NULLIF() construct - thomas
  500.  * 1998-11-11
  501.  */
  502. if (w->result == NULL)
  503. {
  504. A_Const    *n = makeNode(A_Const);
  506. n->val.type = T_Null;
  507. w->result = (Node *) n;
  508. }
  509. w->result = transformExpr(pstate, (Node *) w->result, precedence);
  510. result = expr;
  511. break;
  512. }
  514. /* Some nodes do _not_ come from the original parse tree,
  515.  * but result from parser transformation in this phase.
  516.  * At least one construct (BETWEEN/AND) puts the same nodes
  517.  * into two branches of the parse tree; hence, some nodes
  518.  * are transformed twice.
  519.  * Another way it can happen is that coercion of an operator or
  520.  * function argument to the required type (via coerce_type())
  521.  * can apply transformExpr to an already-transformed subexpression.
  522.  * An example here is "SELECT count(*) + 1.0 FROM table".
  523.  * Thus, we can see node types in this routine that do not appear in the
  524.  * original parse tree.  Assume they are already transformed, and just
  525.  * pass them through.
  526.  * Do any other node types need to be accepted?  For now we are taking
  527.  * a conservative approach, and only accepting node types that are
  528.  * demonstrably necessary to accept.
  529.  */
  530. case T_Expr:
  531. case T_Var:
  532. case T_Const:
  533. case T_Param:
  534. case T_Aggref:
  535. case T_ArrayRef:
  536. {
  537. result = (Node *) expr;
  538. break;
  539. }
  540. default:
  541. /* should not reach here */
  542. elog(ERROR, "transformExpr: does not know how to transform node %d",
  543.  nodeTag(expr));
  544. break;
  545. }
  547. return result;
  548. }
  550. static Node *
  551. transformIdent(ParseState *pstate, Node *expr, int precedence)
  552. {
  553. Ident    *ident = (Ident *) expr;
  554. RangeTblEntry *rte;
  555. Node    *column_result,
  556.    *relation_result,
  557.    *result;
  559. column_result = relation_result = result = 0;
  560. /* try to find the ident as a column */
  561. if ((rte = colnameRangeTableEntry(pstate, ident->name)) != NULL)
  562. {
  563. Attr    *att = makeNode(Attr);
  565. /* we add the relation name for them */
  566. att->relname = rte->refname;
  567. att->attrs = lcons(makeString(ident->name), NIL);
  568. column_result = (Node *) ParseNestedFuncOrColumn(pstate, att,
  569.   &pstate->p_last_resno, precedence);
  570. }
  572. /* try to find the ident as a relation */
  573. if (refnameRangeTableEntry(pstate, ident->name) != NULL)
  574. {
  575. ident->isRel = TRUE;
  576. relation_result = (Node *) ident;
  577. }
  579. /* choose the right result based on the precedence */
  580. if (precedence == EXPR_COLUMN_FIRST)
  581. {
  582. if (column_result)
  583. result = column_result;
  584. else
  585. result = relation_result;
  586. }
  587. else
  588. {
  589. if (relation_result)
  590. result = relation_result;
  591. else
  592. result = column_result;
  593. }
  595. if (result == NULL)
  596. elog(ERROR, "attribute '%s' not found", ident->name);
  598. return result;
  599. }
  601. /*
  602.  * exprType -
  603.  *   returns the Oid of the type of the expression. (Used for typechecking.)
  604.  */
  605. Oid
  606. exprType(Node *expr)
  607. {
  608. Oid type = (Oid) 0;
  610. if (!expr)
  611. return type;
  613. switch (nodeTag(expr))
  614. {
  615. case T_Func:
  616. type = ((Func *) expr)->functype;
  617. break;
  618. case T_Iter:
  619. type = ((Iter *) expr)->itertype;
  620. break;
  621. case T_Var:
  622. type = ((Var *) expr)->vartype;
  623. break;
  624. case T_Expr:
  625. type = ((Expr *) expr)->typeOid;
  626. break;
  627. case T_Const:
  628. type = ((Const *) expr)->consttype;
  629. break;
  630. case T_ArrayRef:
  631. type = ((ArrayRef *) expr)->refelemtype;
  632. break;
  633. case T_Aggref:
  634. type = ((Aggref *) expr)->aggtype;
  635. break;
  636. case T_Param:
  637. type = ((Param *) expr)->paramtype;
  638. break;
  639. case T_SubLink:
  640. {
  641. SubLink    *sublink = (SubLink *) expr;
  643. if (sublink->subLinkType == EXPR_SUBLINK)
  644. {
  645. /* return the result type of the combining operator */
  646. Expr    *op_expr = (Expr *) lfirst(sublink->oper);
  648. type = op_expr->typeOid;
  649. }
  650. else
  651. {
  652. /* for all other sublink types, result is boolean */
  653. type = BOOLOID;
  654. }
  655. }
  656. break;
  657. case T_CaseExpr:
  658. type = ((CaseExpr *) expr)->casetype;
  659. break;
  660. case T_CaseWhen:
  661. type = exprType(((CaseWhen *) expr)->result);
  662. break;
  663. case T_Ident:
  664. /* is this right? */
  665. type = UNKNOWNOID;
  666. break;
  667. default:
  668. elog(ERROR, "exprType: don't know how to get type for %d node",
  669.  nodeTag(expr));
  670. break;
  671. }
  672. return type;
  673. }
  675. static Node *
  676. parser_typecast(Value *expr, TypeName *typename, int32 atttypmod)
  677. {
  678. /* check for passing non-ints */
  679. Const    *adt;
  680. Datum lcp;
  681. Type tp;
  682. char type_string[NAMEDATALEN];
  683. int32 len;
  684. char    *cp = NULL;
  685. char    *const_string = NULL;
  686. bool string_palloced = false;
  688. switch (nodeTag(expr))
  689. {
  690. case T_String:
  691. const_string = DatumGetPointer(expr->val.str);
  692. break;
  693. case T_Integer:
  694. string_palloced = true;
  695. const_string = int4out(expr->val.ival);
  696. break;
  697. case T_Float:
  698. string_palloced = true;
  699. const_string = float8out(&expr->val.dval);
  700. break;
  701. default:
  702. elog(ERROR,
  703.  "parser_typecast: cannot cast this expression to type '%s'",
  704.  typename->name);
  705. }
  707. if (typename->arrayBounds != NIL)
  708. {
  709. sprintf(type_string, "_%s", typename->name);
  710. tp = (Type) typenameType(type_string);
  711. }
  712. else
  713. tp = (Type) typenameType(typename->name);
  715. len = typeLen(tp);
  717. cp = stringTypeString(tp, const_string, atttypmod);
  719. if (!typeByVal(tp))
  720. lcp = PointerGetDatum(cp);
  721. else
  722. {
  723. switch (len)
  724. {
  725. case 1:
  726. lcp = Int8GetDatum(cp);
  727. break;
  728. case 2:
  729. lcp = Int16GetDatum(cp);
  730. break;
  731. case 4:
  732. lcp = Int32GetDatum(cp);
  733. break;
  734. default:
  735. lcp = PointerGetDatum(cp);
  736. break;
  737. }
  738. }
  740. adt = makeConst(typeTypeId(tp),
  741. len,
  742. (Datum) lcp,
  743. false,
  744. typeByVal(tp),
  745. false, /* not a set */
  746. true /* is cast */ );
  748. if (string_palloced)
  749. pfree(const_string);
  751. return (Node *) adt;
  752. }
  755. /* parser_typecast2()
  756.  * Convert (only) constants to specified type.
  757.  */
  758. Node *
  759. parser_typecast2(Node *expr, Oid exprType, Type tp, int32 atttypmod)
  760. {
  761. /* check for passing non-ints */
  762. Const    *adt;
  763. Datum lcp;
  764. int32 len = typeLen(tp);
  765. char    *cp = NULL;
  767. char    *const_string = NULL;
  768. bool string_palloced = false;
  770. Assert(IsA(expr, Const));
  772. switch (exprType)
  773. {
  774. case 0: /* NULL */
  775. break;
  776. case INT4OID: /* int4 */
  777. const_string = (char *) palloc(256);
  778. string_palloced = true;
  779. sprintf(const_string, "%d",
  780. (int) ((Const *) expr)->constvalue);
  781. break;
  782. case NAMEOID: /* name */
  783. const_string = (char *) palloc(256);
  784. string_palloced = true;
  785. sprintf(const_string, "%s",
  786. (char *) ((Const *) expr)->constvalue);
  787. break;
  788. case CHAROID: /* char */
  789. const_string = (char *) palloc(256);
  790. string_palloced = true;
  791. sprintf(const_string, "%c",
  792. (char) ((Const *) expr)->constvalue);
  793. break;
  794. case FLOAT4OID: /* float4 */
  795. {
  796. float32 floatVal = DatumGetFloat32(((Const *) expr)->constvalue);
  798. const_string = (char *) palloc(256);
  799. string_palloced = true;
  800. sprintf(const_string, "%f", *floatVal);
  801. break;
  802. }
  803. case FLOAT8OID: /* float8 */
  804. {
  805. float64 floatVal = DatumGetFloat64(((Const *) expr)->constvalue);
  807. const_string = (char *) palloc(256);
  808. string_palloced = true;
  809. sprintf(const_string, "%f", *floatVal);
  810. break;
  811. }
  812. case CASHOID: /* money */
  813. const_string = (char *) palloc(256);
  814. string_palloced = true;
  815. sprintf(const_string, "%ld",
  816. (long) ((Const *) expr)->constvalue);
  817. break;
  818. case TEXTOID: /* text */
  819. const_string = DatumGetPointer(((Const *) expr)->constvalue);
  820. const_string = (char *) textout((struct varlena *) const_string);
  821. break;
  822. case UNKNOWNOID: /* unknown */
  823. const_string = DatumGetPointer(((Const *) expr)->constvalue);
  824. const_string = (char *) textout((struct varlena *) const_string);
  825. break;
  826. default:
  827. elog(ERROR, "unknown type %u", exprType);
  828. }
  830. if (!exprType)
  831. {
  832. adt = makeConst(typeTypeId(tp),
  833. (Size) 0,
  834. (Datum) NULL,
  835. true, /* isnull */
  836. false, /* was omitted */
  837. false, /* not a set */
  838. true /* is cast */ );
  839. return (Node *) adt;
  840. }
  842. cp = stringTypeString(tp, const_string, atttypmod);
  844. if (!typeByVal(tp))
  845. lcp = PointerGetDatum(cp);
  846. else
  847. {
  848. switch (len)
  849. {
  850. case 1:
  851. lcp = Int8GetDatum(cp);
  852. break;
  853. case 2:
  854. lcp = Int16GetDatum(cp);
  855. break;
  856. case 4:
  857. lcp = Int32GetDatum(cp);
  858. break;
  859. default:
  860. lcp = PointerGetDatum(cp);
  861. break;
  862. }
  863. }
  865. adt = makeConst(typeTypeId(tp),
  866. (Size) len,
  867. (Datum) lcp,
  868. false,
  869. typeByVal(tp),
  870. false, /* not a set */
  871. true /* is cast */ );
  873. /*
  874.  * printf("adt %s : %u %d %dn",CString(expr),typeTypeId(tp) ,
  875.  * len,cp);
  876.  */
  877. if (string_palloced)
  878. pfree(const_string);
  880. return (Node *) adt;
  881. }