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

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

数据库系统

开发平台：

Unix_Linux

pgtypes.c：源码内容
  2. /* Module:          pgtypes.c
  3.  *
  4.  * Description:     This module contains routines for getting information
  5.  *                  about the supported Postgres data types.  Only the function
  6.  *                  pgtype_to_sqltype() returns an unknown condition.  All other
  7.  *                  functions return a suitable default so that even data types that
  8.  *                  are not directly supported can be used (it is handled as char data).
  9.  *
  10.  * Classes:         n/a
  11.  *
  12.  * API functions:   none
  13.  *
  14.  * Comments:        See "notice.txt" for copyright and license information.
  15.  *
  16.  */
  18. #ifdef HAVE_CONFIG_H
  19. #include "config.h"
  20. #endif
  22. #include "psqlodbc.h"
  23. #include "dlg_specific.h"
  24. #include "pgtypes.h"
  25. #include "statement.h"
  26. #include "connection.h"
  27. #include "qresult.h"
  29. #ifndef WIN32
  30. #include "iodbc.h"
  31. #include "isql.h"
  32. #include "isqlext.h"
  33. #else
  34. #include <windows.h>
  35. #include <sql.h>
  36. #include <sqlext.h>
  37. #endif
  40. extern GLOBAL_VALUES globals;
  42. Int4 getCharPrecision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as);
  45. /* these are the types we support.  all of the pgtype_ functions should */
  46. /* return values for each one of these.                                 */
  47. /* Even types not directly supported are handled as character types
  48.    so all types should work (points, etc.) */
  50. /* ALL THESE TYPES ARE NO LONGER REPORTED in SQLGetTypeInfo.  Instead, all
  51.    the SQL TYPES are reported and mapped to a corresponding Postgres Type 
  52. */
  53. /*
  54. Int4 pgtypes_defined[]  = { 
  55. PG_TYPE_CHAR,
  56. PG_TYPE_CHAR2,
  57. PG_TYPE_CHAR4,
  58.     PG_TYPE_CHAR8,
  59. PG_TYPE_CHAR16,
  60.     PG_TYPE_NAME,
  61.     PG_TYPE_VARCHAR,
  62.     PG_TYPE_BPCHAR,
  63. PG_TYPE_DATE,
  64. PG_TYPE_TIME,
  65. PG_TYPE_DATETIME,
  66. PG_TYPE_ABSTIME,
  67. PG_TYPE_TIMESTAMP,
  68.     PG_TYPE_TEXT,
  69.     PG_TYPE_INT2,
  70.     PG_TYPE_INT4,
  71.     PG_TYPE_FLOAT4,
  72.     PG_TYPE_FLOAT8,
  73.     PG_TYPE_OID,
  74. PG_TYPE_MONEY,
  75. PG_TYPE_BOOL,
  76. PG_TYPE_BYTEA,
  77. PG_TYPE_LO,
  78.     0 };
  79. */
  82. /* These are NOW the SQL Types reported in SQLGetTypeInfo.  */
  83. Int2 sqlTypes [] = {
  84. SQL_BIGINT,
  85. /* SQL_BINARY, -- Commented out because VarBinary is more correct. */
  86. SQL_BIT,
  87. SQL_CHAR,
  88. SQL_DATE,
  89. SQL_DECIMAL,
  90. SQL_DOUBLE,
  91. SQL_FLOAT,
  92. SQL_INTEGER,
  93. SQL_LONGVARBINARY,
  94. SQL_LONGVARCHAR,
  95. SQL_NUMERIC,
  96. SQL_REAL,
  97. SQL_SMALLINT,
  98. SQL_TIME,
  99. SQL_TIMESTAMP,
  100. SQL_TINYINT,
  101. SQL_VARBINARY,
  102. SQL_VARCHAR,
  103. 0
  104. };
  106. Int4 sqltype_to_pgtype(SWORD fSqlType)
  107. {
  108. Int4 pgType;
  110. switch(fSqlType) {
  112. case SQL_BINARY:
  113. pgType = PG_TYPE_BYTEA;
  114. break;
  116. case SQL_CHAR:
  117. pgType = PG_TYPE_BPCHAR;
  118. break;
  120. case SQL_BIT:
  121. pgType = globals.bools_as_char ? PG_TYPE_CHAR : PG_TYPE_BOOL;
  122. break;
  124. case SQL_DATE:
  125. pgType = PG_TYPE_DATE;
  126. break;
  128. case SQL_DOUBLE:
  129. case SQL_FLOAT:
  130. pgType = PG_TYPE_FLOAT8;
  131. break;
  133. case SQL_INTEGER:
  134. case SQL_BIGINT:
  135. case SQL_NUMERIC:
  136. case SQL_DECIMAL:
  137. pgType = PG_TYPE_INT4;
  138. break;
  140. case SQL_LONGVARBINARY:
  141. pgType = PG_TYPE_LO;
  142. break;
  144. case SQL_LONGVARCHAR:
  145. pgType = globals.text_as_longvarchar ? PG_TYPE_TEXT : PG_TYPE_VARCHAR;
  146. break;
  148. case SQL_REAL:
  149. pgType = PG_TYPE_FLOAT4;
  150. break;
  152. case SQL_SMALLINT:
  153. case SQL_TINYINT:
  154. pgType = PG_TYPE_INT2;
  155. break;
  157. case SQL_TIME:
  158. pgType = PG_TYPE_TIME;
  159. break;
  161. case SQL_TIMESTAMP:
  162. pgType = PG_TYPE_DATETIME;
  163. break;
  165. case SQL_VARBINARY:
  166. pgType = PG_TYPE_BYTEA;
  167. break;
  169. case SQL_VARCHAR:
  170. pgType = PG_TYPE_VARCHAR;
  171. break;
  173. default:
  174. break;
  175. }
  177. return pgType;
  178. }
  180. /* There are two ways of calling this function:  
  181. 1. When going through the supported PG types (SQLGetTypeInfo)
  182. 2. When taking any type id (SQLColumns, SQLGetData)
  184. The first type will always work because all the types defined are returned here.
  185. The second type will return a default based on global parameter when it does not 
  186. know.   This allows for supporting
  187. types that are unknown.  All other pg routines in here return a suitable default.
  188. */
  189. Int2 pgtype_to_sqltype(StatementClass *stmt, Int4 type)
  190. {
  191. switch(type) {
  192. case PG_TYPE_CHAR:
  193. case PG_TYPE_CHAR2:
  194. case PG_TYPE_CHAR4:
  195. case PG_TYPE_CHAR8:
  196. case PG_TYPE_CHAR16:
  197. case PG_TYPE_NAME:   return SQL_CHAR;        
  199. case PG_TYPE_BPCHAR: return SQL_CHAR;
  201. case PG_TYPE_VARCHAR: return SQL_VARCHAR;
  203. case PG_TYPE_TEXT: return globals.text_as_longvarchar ? SQL_LONGVARCHAR : SQL_VARCHAR;
  205. case PG_TYPE_BYTEA: return SQL_VARBINARY;
  206. case PG_TYPE_LO: return SQL_LONGVARBINARY;
  208. case PG_TYPE_INT2:          return SQL_SMALLINT;
  210. case PG_TYPE_OID:
  211. case PG_TYPE_XID:
  212. case PG_TYPE_INT4:          return SQL_INTEGER;
  214. case PG_TYPE_FLOAT4:        return SQL_REAL;
  215. case PG_TYPE_FLOAT8:        return SQL_FLOAT;
  216. case PG_TYPE_DATE: return SQL_DATE;
  217. case PG_TYPE_TIME: return SQL_TIME;
  218. case PG_TYPE_ABSTIME:
  219. case PG_TYPE_DATETIME:
  220. case PG_TYPE_TIMESTAMP: return SQL_TIMESTAMP;
  221. case PG_TYPE_MONEY: return SQL_FLOAT;
  222. case PG_TYPE_BOOL: return globals.bools_as_char ? SQL_CHAR : SQL_BIT;
  224. default:                
  226. /* first, check to see if 'type' is in list.  If not, look up with query.
  227. Add oid, name to list.  If its already in list, just return.
  228. */
  229. if (type == stmt->hdbc->lobj_type) /* hack until permanent type is available */
  230. return SQL_LONGVARBINARY;
  232. return globals.unknowns_as_longvarchar ? SQL_LONGVARCHAR : SQL_VARCHAR;
  233. }
  234. }
  236. Int2 pgtype_to_ctype(StatementClass *stmt, Int4 type)
  237. {
  238. switch(type) {
  239. case PG_TYPE_INT2:          return SQL_C_SSHORT;
  240. case PG_TYPE_OID:
  241. case PG_TYPE_XID:
  242. case PG_TYPE_INT4:          return SQL_C_SLONG;
  243. case PG_TYPE_FLOAT4:        return SQL_C_FLOAT;
  244. case PG_TYPE_FLOAT8:        return SQL_C_DOUBLE;
  245. case PG_TYPE_DATE: return SQL_C_DATE;
  246. case PG_TYPE_TIME: return SQL_C_TIME;
  247. case PG_TYPE_ABSTIME:
  248. case PG_TYPE_DATETIME:
  249. case PG_TYPE_TIMESTAMP: return SQL_C_TIMESTAMP;
  250. case PG_TYPE_MONEY: return SQL_C_FLOAT;
  251. case PG_TYPE_BOOL: return globals.bools_as_char ? SQL_C_CHAR : SQL_C_BIT;
  253. case PG_TYPE_BYTEA: return SQL_C_BINARY;
  254. case PG_TYPE_LO: return SQL_C_BINARY;
  256. default:                    
  258. if (type == stmt->hdbc->lobj_type) /* hack until permanent type is available */
  259. return SQL_C_BINARY;
  261. return SQL_C_CHAR;
  262. }
  263. }
  265. char *pgtype_to_name(StatementClass *stmt, Int4 type)
  266. {
  267. switch(type) {
  268. case PG_TYPE_CHAR:          return "char";
  269. case PG_TYPE_CHAR2: return "char2";
  270. case PG_TYPE_CHAR4: return "char4";
  271. case PG_TYPE_CHAR8:         return "char8";
  272. case PG_TYPE_CHAR16: return "char16";
  273. case PG_TYPE_VARCHAR:       return "varchar";
  274. case PG_TYPE_BPCHAR:        return "char";
  275. case PG_TYPE_TEXT:          return "text";
  276. case PG_TYPE_NAME:          return "name";
  277. case PG_TYPE_INT2:          return "int2";
  278. case PG_TYPE_OID:           return "oid";
  279. case PG_TYPE_INT4:          return "int4";
  280. case PG_TYPE_FLOAT4:        return "float4";
  281. case PG_TYPE_FLOAT8:        return "float8";
  282. case PG_TYPE_DATE: return "date";
  283. case PG_TYPE_TIME: return "time";
  284. case PG_TYPE_ABSTIME: return "abstime";
  285. case PG_TYPE_DATETIME: return "datetime";
  286. case PG_TYPE_TIMESTAMP: return "timestamp";
  287. case PG_TYPE_MONEY: return "money";
  288. case PG_TYPE_BOOL: return "bool";
  289. case PG_TYPE_BYTEA: return "bytea";
  291. case PG_TYPE_LO: return PG_TYPE_LO_NAME;
  293. default:                    
  294. if (type == stmt->hdbc->lobj_type) /* hack until permanent type is available */
  295. return PG_TYPE_LO_NAME;
  297. /* "unknown" can actually be used in alter table because it is a real PG type! */
  298. return "unknown";
  299. }    
  300. }
  302. Int4
  303. getCharPrecision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
  304. {
  305. int p = -1, maxsize;
  306. QResultClass *result;
  307. ColumnInfoClass *flds;
  309. mylog("getCharPrecision: type=%d, col=%d, unknown = %dn", type,col,handle_unknown_size_as);
  311. /* Assign Maximum size based on parameters */
  312. switch(type) {
  313. case PG_TYPE_TEXT:
  314. if (globals.text_as_longvarchar)
  315. maxsize = globals.max_longvarchar_size;
  316. else
  317. maxsize = globals.max_varchar_size;
  318. break;
  320. case PG_TYPE_VARCHAR:
  321. case PG_TYPE_BPCHAR:
  322. maxsize = globals.max_varchar_size;
  323. break;
  325. default:
  326. if (globals.unknowns_as_longvarchar)
  327. maxsize = globals.max_longvarchar_size;
  328. else
  329. maxsize = globals.max_varchar_size;
  330. break;
  331. }
  333. /* Static Precision (i.e., the Maximum Precision of the datatype)
  334. This has nothing to do with a result set.
  335. */
  336. if (col < 0)
  337. return maxsize;
  339. result = SC_get_Result(stmt);
  341. /* Manual Result Sets -- use assigned column width (i.e., from set_tuplefield_string) */
  342. if (stmt->manual_result) {
  343. flds = result->fields;
  344. if (flds)
  345. return flds->adtsize[col];
  346. else
  347. return maxsize;
  348. }
  350. /* Size is unknown -- handle according to parameter */
  351. if (QR_get_atttypmod(result, col) > -1)
  352. return QR_get_atttypmod(result, col);
  354. if (type == PG_TYPE_BPCHAR || handle_unknown_size_as == UNKNOWNS_AS_LONGEST) {
  355. p = QR_get_display_size(result, col);
  356. mylog("getCharPrecision: LONGEST: p = %dn", p);
  357. }
  359. if (p < 0 && handle_unknown_size_as == UNKNOWNS_AS_MAX)
  360. return maxsize;
  361. else
  362. return p;
  363. }
  365. /* For PG_TYPE_VARCHAR, PG_TYPE_BPCHAR, SQLColumns will 
  366. override this length with the atttypmod length from pg_attribute .
  368. If col >= 0, then will attempt to get the info from the result set.
  369. This is used for functions SQLDescribeCol and SQLColAttributes.
  370. */
  371. Int4 pgtype_precision(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
  372. {
  374. switch(type) {
  376. case PG_TYPE_CHAR: return 1;
  377. case PG_TYPE_CHAR2: return 2;
  378. case PG_TYPE_CHAR4: return 4;
  379. case PG_TYPE_CHAR8:        return 8;
  380. case PG_TYPE_CHAR16:        return 16;
  382. case PG_TYPE_NAME: return NAME_FIELD_SIZE;
  384. case PG_TYPE_INT2:          return 5;
  386. case PG_TYPE_OID:
  387. case PG_TYPE_XID:
  388. case PG_TYPE_INT4:          return 10;
  390. case PG_TYPE_FLOAT4:        
  391. case PG_TYPE_MONEY: return 7;
  393. case PG_TYPE_FLOAT8:        return 15;
  395. case PG_TYPE_DATE: return 10;
  396. case PG_TYPE_TIME: return 8;
  398. case PG_TYPE_ABSTIME:
  399. case PG_TYPE_DATETIME:
  400. case PG_TYPE_TIMESTAMP: return 19;
  402. case PG_TYPE_BOOL: return 1;
  404. case PG_TYPE_LO: return SQL_NO_TOTAL;
  406. default:
  408. if (type == stmt->hdbc->lobj_type) /* hack until permanent type is available */
  409. return SQL_NO_TOTAL;
  411. /* Handle Character types and unknown types */
  412. return getCharPrecision(stmt, type, col, handle_unknown_size_as);
  413.     }
  414. }
  416. Int4 pgtype_display_size(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
  417. {
  418. switch(type) {
  419. case PG_TYPE_INT2: return 6;
  421. case PG_TYPE_OID:
  422. case PG_TYPE_XID: return 10;
  424. case PG_TYPE_INT4: return 11;
  426. case PG_TYPE_MONEY: return 15; /* ($9,999,999.99) */
  428. case PG_TYPE_FLOAT4: return 13;
  430. case PG_TYPE_FLOAT8: return 22;
  432. /* Character types use regular precision */
  433. default:
  434. return pgtype_precision(stmt, type, col, handle_unknown_size_as);
  435. }
  436. }
  438. /* For PG_TYPE_VARCHAR, PG_TYPE_BPCHAR, SQLColumns will 
  439. override this length with the atttypmod length from pg_attribute 
  440. */
  441. Int4 pgtype_length(StatementClass *stmt, Int4 type, int col, int handle_unknown_size_as)
  442. {
  443. switch(type) {
  445. case PG_TYPE_INT2:          return 2;
  447. case PG_TYPE_OID:
  448. case PG_TYPE_XID:
  449. case PG_TYPE_INT4:          return 4;
  451. case PG_TYPE_FLOAT4:
  452. case PG_TYPE_MONEY: return 4;
  454. case PG_TYPE_FLOAT8:        return 8;
  456. case PG_TYPE_DATE:
  457. case PG_TYPE_TIME: return 6;
  459. case PG_TYPE_ABSTIME:
  460. case PG_TYPE_DATETIME:
  461. case PG_TYPE_TIMESTAMP: return 16;
  464. /* Character types use the default precision */
  465. default:
  466. return pgtype_precision(stmt, type, col, handle_unknown_size_as);
  467.     }
  468. }
  470. Int2 pgtype_scale(StatementClass *stmt, Int4 type)
  471. {
  472. switch(type) {
  474. case PG_TYPE_INT2:
  475. case PG_TYPE_OID:
  476. case PG_TYPE_XID:
  477. case PG_TYPE_INT4:
  478. case PG_TYPE_FLOAT4:
  479. case PG_TYPE_FLOAT8:
  480. case PG_TYPE_MONEY:
  481. case PG_TYPE_BOOL:
  483. /* Number of digits to the right of the decimal point in "yyyy-mm=dd hh:mm:ss[.f...]" */
  484. case PG_TYPE_ABSTIME:
  485. case PG_TYPE_DATETIME:
  486. case PG_TYPE_TIMESTAMP: return 0;
  488. default: return -1;
  489. }
  490. }
  493. Int2 pgtype_radix(StatementClass *stmt, Int4 type)
  494. {
  495.     switch(type) {
  496.     case PG_TYPE_INT2:
  497.     case PG_TYPE_OID:
  498.     case PG_TYPE_INT4:
  499.     case PG_TYPE_FLOAT4:
  500. case PG_TYPE_MONEY:
  501.     case PG_TYPE_FLOAT8:        return 10;
  503.     default:                    return -1;
  504.     }
  505. }
  507. Int2 pgtype_nullable(StatementClass *stmt, Int4 type)
  508. {
  509. return SQL_NULLABLE; /* everything should be nullable */
  510. }
  512. Int2 pgtype_auto_increment(StatementClass *stmt, Int4 type)
  513. {
  514. switch(type) {
  516. case PG_TYPE_INT2:         
  517. case PG_TYPE_OID:
  518. case PG_TYPE_XID:
  519. case PG_TYPE_INT4:         
  520. case PG_TYPE_FLOAT4:       
  521. case PG_TYPE_MONEY:
  522. case PG_TYPE_BOOL:
  523. case PG_TYPE_FLOAT8:
  525. case PG_TYPE_DATE:
  526. case PG_TYPE_TIME:
  527. case PG_TYPE_ABSTIME:
  528. case PG_TYPE_DATETIME:
  529. case PG_TYPE_TIMESTAMP: return FALSE;
  531. default: return -1;
  532. }    
  533. }
  535. Int2 pgtype_case_sensitive(StatementClass *stmt, Int4 type)
  536. {
  537.     switch(type) {
  538.     case PG_TYPE_CHAR:          
  540. case PG_TYPE_CHAR2:
  541. case PG_TYPE_CHAR4:
  542.     case PG_TYPE_CHAR8:         
  543. case PG_TYPE_CHAR16:
  545.     case PG_TYPE_VARCHAR:       
  546.     case PG_TYPE_BPCHAR:
  547.     case PG_TYPE_TEXT:
  548.     case PG_TYPE_NAME:          return TRUE;
  550.     default:                    return FALSE;
  551.     }
  552. }
  554. Int2 pgtype_money(StatementClass *stmt, Int4 type)
  555. {
  556. switch(type) {
  557. case PG_TYPE_MONEY: return TRUE;
  558. default: return FALSE;
  559. }    
  560. }
  562. Int2 pgtype_searchable(StatementClass *stmt, Int4 type)
  563. {
  564. switch(type) {
  565. case PG_TYPE_CHAR:          
  566. case PG_TYPE_CHAR2:
  567. case PG_TYPE_CHAR4:
  568. case PG_TYPE_CHAR8:
  569. case PG_TYPE_CHAR16:
  571. case PG_TYPE_VARCHAR:       
  572. case PG_TYPE_BPCHAR:
  573. case PG_TYPE_TEXT:
  574. case PG_TYPE_NAME:          return SQL_SEARCHABLE;
  576. default: return SQL_ALL_EXCEPT_LIKE;
  577. }    
  578. }
  580. Int2 pgtype_unsigned(StatementClass *stmt, Int4 type)
  581. {
  582. switch(type) {
  583. case PG_TYPE_OID:
  584. case PG_TYPE_XID: return TRUE;
  586. case PG_TYPE_INT2:
  587. case PG_TYPE_INT4:
  588. case PG_TYPE_FLOAT4:
  589. case PG_TYPE_FLOAT8:
  590. case PG_TYPE_MONEY: return FALSE;
  592. default: return -1;
  593. }
  594. }
  596. char *pgtype_literal_prefix(StatementClass *stmt, Int4 type)
  597. {
  598. switch(type) {
  600. case PG_TYPE_INT2:
  601. case PG_TYPE_OID:
  602. case PG_TYPE_XID:
  603. case PG_TYPE_INT4:
  604. case PG_TYPE_FLOAT4:
  605. case PG_TYPE_FLOAT8:        
  606. case PG_TYPE_MONEY: return NULL;
  608. default: return "'";
  609. }
  610. }
  612. char *pgtype_literal_suffix(StatementClass *stmt, Int4 type)
  613. {
  614. switch(type) {
  616. case PG_TYPE_INT2:
  617. case PG_TYPE_OID:
  618. case PG_TYPE_XID:
  619. case PG_TYPE_INT4:
  620. case PG_TYPE_FLOAT4:
  621. case PG_TYPE_FLOAT8:        
  622. case PG_TYPE_MONEY: return NULL;
  624. default: return "'";
  625. }
  626. }
  628. char *pgtype_create_params(StatementClass *stmt, Int4 type)
  629. {
  630. switch(type) {
  631. case PG_TYPE_CHAR:
  632. case PG_TYPE_VARCHAR: return "max. length";
  633. default: return NULL;
  634. }
  635. }
  638. Int2 sqltype_to_default_ctype(Int2 sqltype)
  639. {
  640.     // from the table on page 623 of ODBC 2.0 Programmer's Reference
  641.     // (Appendix D)
  642.     switch(sqltype) {
  643.     case SQL_CHAR: 
  644.     case SQL_VARCHAR:
  645.     case SQL_LONGVARCHAR:
  646.     case SQL_DECIMAL:
  647.     case SQL_NUMERIC:
  648.     case SQL_BIGINT:
  649. return SQL_C_CHAR;
  651.     case SQL_BIT:
  652. return SQL_C_BIT;
  654.     case SQL_TINYINT:
  655. return SQL_C_STINYINT;
  657.     case SQL_SMALLINT:
  658. return SQL_C_SSHORT;
  660.     case SQL_INTEGER:
  661. return SQL_C_SLONG;
  663.     case SQL_REAL:
  664. return SQL_C_FLOAT;
  666.     case SQL_FLOAT:
  667.     case SQL_DOUBLE:
  668. return SQL_C_DOUBLE;
  670.     case SQL_BINARY:
  671.     case SQL_VARBINARY:
  672.     case SQL_LONGVARBINARY:
  673. return SQL_C_BINARY;
  675.     case SQL_DATE:
  676. return SQL_C_DATE;
  678.     case SQL_TIME:
  679. return SQL_C_TIME;
  681.     case SQL_TIMESTAMP:
  682. return SQL_C_TIMESTAMP;
  684.     default: /* should never happen */
  685. return SQL_C_CHAR;
  686.     }
  687. }