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

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

数据库系统

开发平台：

Unix_Linux

parse_coerce.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * parse_coerce.c
  4.  * handle type coersions/conversions for 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_coerce.c,v 2.18 1999/06/17 22:21:41 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <string.h>
  15. #include "postgres.h"
  16. #include "utils/builtins.h"
  17. #include "fmgr.h"
  18. #include "nodes/makefuncs.h"
  20. #include "parser/parse_expr.h"
  22. #include "catalog/pg_type.h"
  23. #include "parser/parse_func.h"
  24. #include "parser/parse_type.h"
  25. #include "parser/parse_target.h"
  26. #include "parser/parse_coerce.h"
  27. #include "utils/syscache.h"
  29. Oid DemoteType(Oid inType);
  30. Oid PromoteTypeToNext(Oid inType);
  32. static Oid PreferredType(CATEGORY category, Oid type);
  35. /* coerce_type()
  36.  * Convert a function argument to a different type.
  37.  */
  38. Node *
  39. coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId,
  40. int32 atttypmod)
  41. {
  42. Node    *result = NULL;
  43. Type targetType;
  44. Oid infunc;
  45. Datum val;
  47. if (targetTypeId == InvalidOid)
  48. result = node;
  49. else if (inputTypeId != targetTypeId)
  50. {
  52. /*
  53.  * one of the known-good transparent conversions? then drop
  54.  * through...
  55.  */
  56. if (IS_BINARY_COMPATIBLE(inputTypeId, targetTypeId))
  57. result = node;
  59. /*
  60.  * if not unknown input type, try for explicit conversion using
  61.  * functions...
  62.  */
  63. else if (inputTypeId != UNKNOWNOID)
  64. {
  66. /*
  67.  * We already know there is a function which will do this, so
  68.  * let's use it
  69.  */
  70. FuncCall   *n = makeNode(FuncCall);
  72. n->funcname = typeidTypeName(targetTypeId);
  73. n->args = lcons(node, NIL);
  75. result = transformExpr(pstate, (Node *) n, EXPR_COLUMN_FIRST);
  76. }
  77. else
  78. {
  79. if (nodeTag(node) == T_Const)
  80. {
  81. Const    *con = (Const *) node;
  83. val = (Datum) textout((struct varlena *) con->constvalue);
  84. targetType = typeidType(targetTypeId);
  85. infunc = typeInfunc(targetType);
  86. con = makeNode(Const);
  87. con->consttype = targetTypeId;
  88. con->constlen = typeLen(targetType);
  90. /*
  91.  * Use "-1" for varchar() type. For char(), we need to pad
  92.  * out the type with the proper number of spaces.  This
  93.  * was a major problem for DEFAULT string constants to
  94.  * char() types.
  95.  */
  96. con->constvalue = (Datum) fmgr(infunc,
  97.    val,
  98.    typeTypElem(targetType),
  99.    (targetTypeId != BPCHAROID) ? -1 : atttypmod);
  100. con->constisnull = false;
  101. con->constbyval = typeByVal(targetType);
  102. con->constisset = false;
  103. result = (Node *) con;
  104. }
  105. else
  106. result = node;
  107. }
  108. }
  109. else
  110. result = node;
  112. return result;
  113. }
  116. /* can_coerce_type()
  117.  * Can input_typeids be coerced to func_typeids?
  118.  *
  119.  * There are a few types which are known apriori to be convertible.
  120.  * We will check for those cases first, and then look for possible
  121.  * conversion functions.
  122.  *
  123.  * Notes:
  124.  * This uses the same mechanism as the CAST() SQL construct in gram.y.
  125.  * We should also check the function return type on candidate conversion
  126.  * routines just to be safe but we do not do that yet...
  127.  * We need to have a zero-filled OID array here, otherwise the cache lookup fails.
  128.  * - thomas 1998-03-31
  129.  */
  130. bool
  131. can_coerce_type(int nargs, Oid *input_typeids, Oid *func_typeids)
  132. {
  133. HeapTuple ftup;
  134. int i;
  135. Type tp;
  136. Oid oid_array[MAXFARGS];
  138. /* run through argument list... */
  139. for (i = 0; i < nargs; i++)
  140. {
  141. if (input_typeids[i] != func_typeids[i])
  142. {
  144. /*
  145.  * one of the known-good transparent conversions? then drop
  146.  * through...
  147.  */
  148. if (IS_BINARY_COMPATIBLE(input_typeids[i], func_typeids[i]))
  149. ;
  151. /* don't know what to do for the output type? then quit... */
  152. else if (func_typeids[i] == InvalidOid)
  153. return false;
  154. /* don't know what to do for the input type? then quit... */
  155. else if (input_typeids[i] == InvalidOid)
  156. return false;
  158. /*
  159.  * if not unknown input type, try for explicit conversion
  160.  * using functions...
  161.  */
  162. else if (input_typeids[i] != UNKNOWNOID)
  163. {
  164. MemSet(oid_array, 0, MAXFARGS * sizeof(Oid));
  165. oid_array[0] = input_typeids[i];
  167. /*
  168.  * look for a single-argument function named with the
  169.  * target type name
  170.  */
  171. ftup = SearchSysCacheTuple(PRONAME,
  172. PointerGetDatum(typeidTypeName(func_typeids[i])),
  173.    Int32GetDatum(1),
  174.    PointerGetDatum(oid_array),
  175.    0);
  177. /*
  178.  * should also check the function return type just to be
  179.  * safe...
  180.  */
  181. if (!HeapTupleIsValid(ftup))
  182. return false;
  183. }
  185. tp = typeidType(input_typeids[i]);
  186. if (typeTypeFlag(tp) == 'c')
  187. return false;
  188. }
  189. }
  191. return true;
  192. }
  195. /* TypeCategory()
  196.  * Assign a category to the specified OID.
  197.  */
  198. CATEGORY
  199. TypeCategory(Oid inType)
  200. {
  201. CATEGORY result;
  203. switch (inType)
  204. {
  205. case (BOOLOID):
  206. result = BOOLEAN_TYPE;
  207. break;
  209. case (CHAROID):
  210. case (BPCHAROID):
  211. case (VARCHAROID):
  212. case (TEXTOID):
  213. result = STRING_TYPE;
  214. break;
  216. case (OIDOID):
  217. case (INT2OID):
  218. case (INT4OID):
  219. case (INT8OID):
  220. case (FLOAT4OID):
  221. case (FLOAT8OID):
  222. case (CASHOID):
  223. result = NUMERIC_TYPE;
  224. break;
  226. case (ABSTIMEOID):
  227. case (TIMESTAMPOID):
  228. case (DATETIMEOID):
  229. result = DATETIME_TYPE;
  230. break;
  232. case (RELTIMEOID):
  233. case (TIMESPANOID):
  234. result = TIMESPAN_TYPE;
  235. break;
  237. case (POINTOID):
  238. case (LSEGOID):
  239. case (LINEOID):
  240. case (BOXOID):
  241. case (PATHOID):
  242. case (CIRCLEOID):
  243. case (POLYGONOID):
  244. result = GEOMETRIC_TYPE;
  245. break;
  247. case (INETOID):
  248. case (CIDROID):
  249. result = NETWORK_TYPE;
  250. break;
  252. default:
  253. result = USER_TYPE;
  254. break;
  255. }
  256. return result;
  257. } /* TypeCategory() */
  260. /* IsPreferredType()
  261.  * Check if this type is a preferred type.
  262.  */
  263. bool
  264. IsPreferredType(CATEGORY category, Oid type)
  265. {
  266. return type == PreferredType(category, type);
  267. } /* IsPreferredType() */
  270. /* PreferredType()
  271.  * Return the preferred type OID for the specified category.
  272.  */
  273. static Oid
  274. PreferredType(CATEGORY category, Oid type)
  275. {
  276. Oid result;
  278. switch (category)
  279. {
  280. case (BOOLEAN_TYPE):
  281. result = BOOLOID;
  282. break;
  284. case (STRING_TYPE):
  285. result = TEXTOID;
  286. break;
  288. case (NUMERIC_TYPE):
  289. if (type == OIDOID)
  290. result = OIDOID;
  291. else
  292. result = FLOAT8OID;
  293. break;
  295. case (DATETIME_TYPE):
  296. result = DATETIMEOID;
  297. break;
  299. case (TIMESPAN_TYPE):
  300. result = TIMESPANOID;
  301. break;
  303. case (NETWORK_TYPE):
  304. result = INETOID;
  305. break;
  307. case (GEOMETRIC_TYPE):
  308. case (USER_TYPE):
  309. result = type;
  310. break;
  312. default:
  313. result = UNKNOWNOID;
  314. break;
  315. }
  316. return result;
  317. } /* PreferredType() */
  320. #ifdef NOT_USED
  321. Oid
  322. PromoteTypeToNext(Oid inType)
  323. {
  324. Oid result;
  326. switch (inType)
  327. {
  328. case (CHAROID):
  329. case (BPCHAROID):
  330. result = VARCHAROID;
  331. break;
  333. case (VARCHAROID):
  334. result = TEXTOID;
  335. break;
  337. case (INT2OID):
  338. case (CASHOID):
  339. result = INT4OID;
  340. break;
  342. case (INT4OID):
  343. case (INT8OID):
  344. case (FLOAT4OID):
  345. result = FLOAT8OID;
  346. break;
  348. case (DATEOID):
  349. case (ABSTIMEOID):
  350. case (TIMESTAMPOID):
  351. result = DATETIMEOID;
  352. break;
  354. case (TIMEOID):
  355. case (RELTIMEOID):
  356. result = TIMESPANOID;
  357. break;
  359. case (BOOLOID):
  360. case (TEXTOID):
  361. case (FLOAT8OID):
  362. case (DATETIMEOID):
  363. case (TIMESPANOID):
  364. default:
  365. result = inType;
  366. break;
  367. }
  368. return result;
  369. } /* PromoteTypeToNext() */
  372. Oid
  373. DemoteType(Oid inType)
  374. {
  375. Oid result;
  377. switch (inType)
  378. {
  379. case (FLOAT4OID):
  380. case (FLOAT8OID):
  381. result = INT4OID;
  382. break;
  384. default:
  385. result = inType;
  386. break;
  387. }
  388. return result;
  389. } /* DemoteType() */
  392. Oid
  393. PromoteLesserType(Oid inType1, Oid inType2, Oid *newType1, Oid *newType2)
  394. {
  395. Oid result;
  397. if (inType1 == inType2)
  398. {
  399. result = PromoteTypeToNext(inType1);
  400. inType1 = result;
  401. *arg2 = result;
  402. return result;
  403. }
  405. kind1 = ClassifyType(inType1);
  406. kind2 = ClassifyType(*arg2);
  407. if (kind1 != kind2)
  408. {
  409. *newType1 = inType1;
  410. *newType2 = inType2;
  411. result = InvalidOid;
  412. }
  414. isBuiltIn1 = IS_BUILTIN_TYPE(inType1);
  415. isBuiltIn2 = IS_BUILTIN_TYPE(*arg2);
  417. if (isBuiltIn1 && isBuiltIn2)
  418. {
  419. switch (*arg1)
  420. {
  421. case (CHAROID):
  422. switch (*arg2)
  423. {
  424. case (BPCHAROID):
  425. case (VARCHAROID):
  426. case (TEXTOID):
  428. case (INT2OID):
  429. case (INT4OID):
  430. case (FLOAT4OID):
  431. case (FLOAT8OID):
  432. case (CASHOID):
  434. case (POINTOID):
  435. case (LSEGOID):
  436. case (LINEOID):
  437. case (BOXOID):
  438. case (PATHOID):
  439. case (CIRCLEOID):
  440. case (POLYGONOID):
  442. case (InvalidOid):
  443. case (UNKNOWNOID):
  444. case (BOOLOID):
  445. default:
  446. *arg1 = InvalidOid;
  447. *arg2 = InvalidOid;
  448. result = InvalidOid;
  449. }
  450. }
  451. }
  452. else if (isBuiltIn1 && !isBuiltIn2)
  453. {
  454. if ((promotedType = PromoteBuiltInType(*arg1)) != *arg1)
  455. {
  456. *arg1 = promotedType;
  457. return promotedType;
  458. }
  459. else if (CanCoerceType(*arg1, *arg2))
  460. {
  461. *arg1 = *arg2;
  462. return *arg2;
  463. }
  464. }
  465. else if (!isBuiltIn1 && isBuiltIn2)
  466. {
  467. if ((promotedType = PromoteBuiltInType(*arg2)) != *arg2)
  468. {
  469. *arg2 = promotedType;
  470. return promotedType;
  471. }
  472. else if (CanCoerceType(*arg2, *arg1))
  473. {
  474. *arg2 = *arg1;
  475. return *arg1;
  476. }
  477. }
  480. if (*arg2 == InvalidOid)
  481. return InvalidOid;
  483. switch (*arg1)
  484. {
  485. case (CHAROID):
  486. switch (*arg2)
  487. {
  488. case (BPCHAROID):
  489. case (VARCHAROID):
  490. case (TEXTOID):
  492. case (INT2OID):
  493. case (INT4OID):
  494. case (FLOAT4OID):
  495. case (FLOAT8OID):
  496. case (CASHOID):
  498. case (POINTOID):
  499. case (LSEGOID):
  500. case (LINEOID):
  501. case (BOXOID):
  502. case (PATHOID):
  503. case (CIRCLEOID):
  504. case (POLYGONOID):
  506. case (InvalidOid):
  507. case (UNKNOWNOID):
  508. case (BOOLOID):
  509. default:
  510. *arg1 = InvalidOid;
  511. *arg2 = InvalidOid;
  512. result = InvalidOid;
  513. }
  514. }
  515. }
  517. #endif