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

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

数据库系统

开发平台：

Unix_Linux

convert.c：源码内容
  2. /* Module:         convert.c
  3.  *
  4.  * Description:    This module contains routines related to 
  5.  *                 converting parameters and columns into requested data types.
  6.  *                 Parameters are converted from their SQL_C data types into
  7.  *                 the appropriate postgres type.  Columns are converted from
  8.  *                 their postgres type (SQL type) into the appropriate SQL_C 
  9.  *                 data type.
  10.  *
  11.  * Classes:        n/a
  12.  *
  13.  * API functions:  none
  14.  *
  15.  * Comments:       See "notice.txt" for copyright and license information.
  16.  *
  17.  */
  19. #ifdef HAVE_CONFIG_H
  20. #include "config.h"
  21. #endif
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include <ctype.h>
  27. #include "psqlodbc.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
  39. #include <time.h>
  40. #include <math.h>
  41. #include "convert.h"
  42. #include "statement.h"
  43. #include "bind.h"
  44. #include "pgtypes.h"
  45. #include "lobj.h"
  46. #include "connection.h"
  48. #ifndef WIN32
  49. #ifndef HAVE_STRICMP
  50. #define stricmp(s1,s2) strcasecmp(s1,s2)
  51. #define strnicmp(s1,s2,n) strncasecmp(s1,s2,n)
  52. #endif
  53. #ifndef SCHAR
  54. typedef signed char SCHAR;
  55. #endif
  56. #endif
  58. extern GLOBAL_VALUES globals;
  60. /* How to map ODBC scalar functions {fn func(args)} to Postgres */
  61. /* This is just a simple substitution */
  62. char *mapFuncs[][2] = {   
  63. { "CONCAT",      "textcat" },
  64. { "LCASE",       "lower"   },
  65. { "LOCATE",      "strpos"  },
  66. { "LENGTH",      "textlen" },
  67. { "LTRIM",       "ltrim"   },
  68. { "RTRIM",       "rtrim"   },
  69. { "SUBSTRING",   "substr"  },
  70. { "UCASE",       "upper"   },
  71. { "NOW",         "now"     },
  72. {    0,             0      }
  73. };
  75. char *mapFunction(char *func);
  76. unsigned int conv_from_octal(unsigned char *s);
  77. unsigned int conv_from_hex(unsigned char *s);
  78. char *conv_to_octal(unsigned char val);
  80. /******** A Guide for date/time/timestamp conversions    **************
  82. field_type fCType Output
  83. ---------- ------ ----------
  84. PG_TYPE_DATE SQL_C_DEFAULT SQL_C_DATE
  85. PG_TYPE_DATE SQL_C_DATE SQL_C_DATE
  86. PG_TYPE_DATE SQL_C_TIMESTAMP SQL_C_TIMESTAMP (time = 0 (midnight))
  87. PG_TYPE_TIME SQL_C_DEFAULT SQL_C_TIME
  88. PG_TYPE_TIME SQL_C_TIME SQL_C_TIME
  89. PG_TYPE_TIME SQL_C_TIMESTAMP SQL_C_TIMESTAMP (date = current date)
  90. PG_TYPE_ABSTIME SQL_C_DEFAULT SQL_C_TIMESTAMP
  91. PG_TYPE_ABSTIME SQL_C_DATE SQL_C_DATE (time is truncated)
  92. PG_TYPE_ABSTIME SQL_C_TIME SQL_C_TIME (date is truncated)
  93. PG_TYPE_ABSTIME SQL_C_TIMESTAMP SQL_C_TIMESTAMP
  94. ******************************************************************************/
  97. /* This is called by SQLFetch() */
  98. int
  99. copy_and_convert_field_bindinfo(StatementClass *stmt, Int4 field_type, void *value, int col)
  100. {
  101. BindInfoClass *bic = &(stmt->bindings[col]);
  103. return copy_and_convert_field(stmt, field_type, value, (Int2)bic->returntype, (PTR)bic->buffer,
  104.                                 (SDWORD)bic->buflen, (SDWORD *)bic->used);
  105. }
  107. /* This is called by SQLGetData() */
  108. int
  109. copy_and_convert_field(StatementClass *stmt, Int4 field_type, void *value, Int2 fCType, 
  110.    PTR rgbValue, SDWORD cbValueMax, SDWORD *pcbValue)
  111. {
  112. Int4 len = 0, copy_len = 0;
  113. SIMPLE_TIME st;
  114. time_t t = time(NULL);
  115. struct tm *tim;
  116. int pcbValueOffset, rgbValueOffset;
  117. char *rgbValueBindRow, *ptr;
  118. int bind_row = stmt->bind_row;
  119. int bind_size = stmt->options.bind_size;
  120. int result = COPY_OK;
  121. char tempBuf[TEXT_FIELD_SIZE+5];
  123. /* rgbValueOffset is *ONLY* for character and binary data */
  124. /* pcbValueOffset is for computing any pcbValue location */
  126. if (bind_size > 0) {
  128. pcbValueOffset = rgbValueOffset = (bind_size * bind_row);
  129. }
  130. else {
  132. pcbValueOffset = bind_row * sizeof(SDWORD);
  133. rgbValueOffset = bind_row * cbValueMax;
  135. }
  137. memset(&st, 0, sizeof(SIMPLE_TIME));
  139. /* Initialize current date */
  140. tim = localtime(&t);
  141. st.m = tim->tm_mon + 1;
  142. st.d = tim->tm_mday;
  143. st.y = tim->tm_year + 1900;
  145. mylog("copy_and_convert: field_type = %d, fctype = %d, value = '%s', cbValueMax=%dn", field_type, fCType,  (value==NULL)?"<NULL>":value, cbValueMax);
  147. if ( ! value) {
  148.         /* handle a null just by returning SQL_NULL_DATA in pcbValue, */
  149.         /* and doing nothing to the buffer.                           */
  150.         if(pcbValue) {
  151. *(SDWORD *) ((char *) pcbValue + pcbValueOffset) = SQL_NULL_DATA;
  152.         }
  153. return COPY_OK;
  154. }
  157. if (stmt->hdbc->DataSourceToDriver != NULL) {
  158. int length = strlen (value);
  159. stmt->hdbc->DataSourceToDriver (stmt->hdbc->translation_option,
  160. SQL_CHAR,
  161. value, length,
  162. value, length, NULL,
  163. NULL, 0, NULL);
  164. }
  167. /********************************************************************
  168. First convert any specific postgres types into more
  169. useable data.
  171. NOTE: Conversions from PG char/varchar of a date/time/timestamp 
  172. value to SQL_C_DATE,SQL_C_TIME, SQL_C_TIMESTAMP not supported 
  173. *********************************************************************/
  174. switch(field_type) {
  175. /*  $$$ need to add parsing for date/time/timestamp strings in PG_TYPE_CHAR,VARCHAR $$$ */
  176. case PG_TYPE_DATE:
  177. sscanf(value, "%4d-%2d-%2d", &st.y, &st.m, &st.d);
  178. break;
  180. case PG_TYPE_TIME:
  181. sscanf(value, "%2d:%2d:%2d", &st.hh, &st.mm, &st.ss);
  182. break;
  184. case PG_TYPE_ABSTIME:
  185. case PG_TYPE_DATETIME:
  186. case PG_TYPE_TIMESTAMP:
  187. if (strnicmp(value, "invalid", 7) != 0) {
  188. sscanf(value, "%4d-%2d-%2d %2d:%2d:%2d", &st.y, &st.m, &st.d, &st.hh, &st.mm, &st.ss);
  190. } else { /* The timestamp is invalid so set something conspicuous, like the epoch */
  191. t = 0;
  192. tim = localtime(&t);
  193. st.m = tim->tm_mon + 1;
  194. st.d = tim->tm_mday;
  195. st.y = tim->tm_year + 1900;
  196. st.hh = tim->tm_hour;
  197. st.mm = tim->tm_min;
  198. st.ss = tim->tm_sec;
  199. }
  200. break;
  202. case PG_TYPE_BOOL: { /* change T/F to 1/0 */
  203. char *s = (char *) value;
  204. if (s[0] == 'T' || s[0] == 't') 
  205. s[0] = '1';
  206. else 
  207. s[0] = '0';
  208. }
  209. break;
  211. /* This is for internal use by SQLStatistics() */
  212. case PG_TYPE_INT28: {
  213. // this is an array of eight integers
  214. short *short_array = (short *) ( (char *) rgbValue + rgbValueOffset);
  216. len = 16;
  218. sscanf(value, "%hd %hd %hd %hd %hd %hd %hd %hd",
  219. &short_array[0],
  220. &short_array[1],
  221. &short_array[2],
  222. &short_array[3],
  223. &short_array[4],
  224. &short_array[5],
  225. &short_array[6],
  226. &short_array[7]);
  228. /*  There is no corresponding fCType for this. */
  229. if(pcbValue)
  230. *(SDWORD *) ((char *) pcbValue + pcbValueOffset) = len;
  232. return COPY_OK; /* dont go any further or the data will be trashed */
  233. }
  235. /* This is a large object OID, which is used to store LONGVARBINARY objects. */
  236. case PG_TYPE_LO:
  238. return convert_lo( stmt, value, fCType, ((char *) rgbValue + rgbValueOffset), cbValueMax, (SDWORD *) ((char *) pcbValue + pcbValueOffset));
  240. default:
  242. if (field_type == stmt->hdbc->lobj_type) /* hack until permanent type available */
  243. return convert_lo( stmt, value, fCType, ((char *) rgbValue + rgbValueOffset), cbValueMax, (SDWORD *) ((char *) pcbValue + pcbValueOffset));
  244. }
  246. /*  Change default into something useable */
  247. if (fCType == SQL_C_DEFAULT) {
  248. fCType = pgtype_to_ctype(stmt, field_type);
  250. mylog("copy_and_convert, SQL_C_DEFAULT: fCType = %dn", fCType);
  251. }
  254. rgbValueBindRow = (char *) rgbValue + rgbValueOffset;
  256.     if(fCType == SQL_C_CHAR) {
  259. /* Special character formatting as required */
  260. /* These really should return error if cbValueMax is not big enough. */
  261. switch(field_type) {
  262. case PG_TYPE_DATE:
  263.     len = 10;
  264. if (cbValueMax > len)
  265. sprintf(rgbValueBindRow, "%.4d-%.2d-%.2d", st.y, st.m, st.d);
  266. break;
  268. case PG_TYPE_TIME:
  269. len = 8;
  270. if (cbValueMax > len)
  271. sprintf(rgbValueBindRow, "%.2d:%.2d:%.2d", st.hh, st.mm, st.ss);
  272. break;
  274. case PG_TYPE_ABSTIME:
  275. case PG_TYPE_DATETIME:
  276. case PG_TYPE_TIMESTAMP:
  277. len = 19;
  278. if (cbValueMax > len)
  279. sprintf(rgbValueBindRow, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d", 
  280. st.y, st.m, st.d, st.hh, st.mm, st.ss);
  281. break;
  283. case PG_TYPE_BOOL:
  284. len = 1;
  285. if (cbValueMax > len) {
  286. strcpy(rgbValueBindRow, value);
  287. mylog("PG_TYPE_BOOL: rgbValueBindRow = '%s'n", rgbValueBindRow);
  288. }
  289. break;
  291. /* Currently, data is SILENTLY TRUNCATED for BYTEA and character data
  292. types if there is not enough room in cbValueMax because the driver 
  293. can't handle multiple calls to SQLGetData for these, yet.  Most likely,
  294. the buffer passed in will be big enough to handle the maximum limit of 
  295. postgres, anyway.
  297. LongVarBinary types are handled correctly above, observing truncation
  298. and all that stuff since there is essentially no limit on the large
  299. object used to store those.
  300. */
  301. case PG_TYPE_BYTEA: // convert binary data to hex strings (i.e, 255 = "FF")
  302. len = convert_pgbinary_to_char(value, rgbValueBindRow, cbValueMax);
  304. /***** THIS IS NOT PROPERLY IMPLEMENTED *****/
  305. break;
  307. default:
  308. /* convert linefeeds to carriage-return/linefeed */
  309. len = convert_linefeeds(value, tempBuf, sizeof(tempBuf));
  310. ptr = tempBuf;
  312. mylog("DEFAULT: len = %d, ptr = '%s'n", len, ptr);
  314. if (stmt->current_col >= 0) {
  315. if (stmt->bindings[stmt->current_col].data_left == 0)
  316. return COPY_NO_DATA_FOUND;
  317. else if (stmt->bindings[stmt->current_col].data_left > 0) {
  318. ptr += len - stmt->bindings[stmt->current_col].data_left;
  319. len = stmt->bindings[stmt->current_col].data_left;
  320. }
  321. else
  322. stmt->bindings[stmt->current_col].data_left = strlen(ptr);
  323. }
  325. if (cbValueMax > 0) {
  327. copy_len = (len >= cbValueMax) ? cbValueMax -1 : len;
  329. /* Copy the data */
  330. strncpy_null(rgbValueBindRow, ptr, copy_len + 1);
  332. /* Adjust data_left for next time */
  333. if (stmt->current_col >= 0) {
  334. stmt->bindings[stmt->current_col].data_left -= copy_len;
  335. }
  336. }
  338. /* Finally, check for truncation so that proper status can be returned */
  339. if ( len >= cbValueMax)
  340. result = COPY_RESULT_TRUNCATED;
  343. mylog("    SQL_C_CHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'n", len, cbValueMax, rgbValueBindRow);
  344. break;
  345. }
  348.     } else {
  350. /* for SQL_C_CHAR, its probably ok to leave currency symbols in.  But
  351. to convert to numeric types, it is necessary to get rid of those.
  352. */
  353. if (field_type == PG_TYPE_MONEY)
  354. convert_money(value);
  356. switch(fCType) {
  357. case SQL_C_DATE:
  358. len = 6;
  359. {
  360. DATE_STRUCT *ds;
  362. if (bind_size > 0) {
  363. ds = (DATE_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
  364. } else {
  365. ds = (DATE_STRUCT *) rgbValue + bind_row;
  366. }
  367. ds->year = st.y;
  368. ds->month = st.m;
  369. ds->day = st.d;
  370. }
  371. break;
  373. case SQL_C_TIME:
  374. len = 6;
  375. {
  376. TIME_STRUCT *ts;
  378. if (bind_size > 0) {
  379. ts = (TIME_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
  380. } else {
  381. ts = (TIME_STRUCT *) rgbValue + bind_row;
  382. }
  383. ts->hour = st.hh;
  384. ts->minute = st.mm;
  385. ts->second = st.ss;
  386. }
  387. break;
  389. case SQL_C_TIMESTAMP:
  390. len = 16;
  391. {
  392. TIMESTAMP_STRUCT *ts;
  393. if (bind_size > 0) {
  394. ts = (TIMESTAMP_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
  395. } else {
  396. ts = (TIMESTAMP_STRUCT *) rgbValue + bind_row;
  397. }
  398. ts->year = st.y;
  399. ts->month = st.m;
  400. ts->day = st.d;
  401. ts->hour = st.hh;
  402. ts->minute = st.mm;
  403. ts->second = st.ss;
  404. ts->fraction = 0;
  405. }
  406. break;
  408. case SQL_C_BIT:
  409. len = 1;
  410. if (bind_size > 0) {
  411. *(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
  412. } else {
  413. *((UCHAR *)rgbValue + bind_row) = atoi(value);
  414. }
  415. // mylog("SQL_C_BIT: val = %d, cb = %d, rgb=%dn", atoi(value), cbValueMax, *((UCHAR *)rgbValue));
  416. break;
  418. case SQL_C_STINYINT:
  419. case SQL_C_TINYINT:
  420. len = 1;
  421. if (bind_size > 0) {
  422. *(SCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
  423. } else {
  424. *((SCHAR *) rgbValue + bind_row) = atoi(value);
  425. }
  426. break;
  428. case SQL_C_UTINYINT:
  429. len = 1;
  430. if (bind_size > 0) {
  431. *(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
  432. } else {
  433. *((UCHAR *) rgbValue + bind_row) = atoi(value);
  434. }
  435. break;
  437. case SQL_C_FLOAT:
  438. len = 4;
  439. if (bind_size > 0) {
  440. *(SFLOAT *) ((char *) rgbValue + (bind_row * bind_size)) = (float) atof(value);
  441. } else {
  442. *((SFLOAT *)rgbValue + bind_row) = (float) atof(value);
  443. }
  444. break;
  446. case SQL_C_DOUBLE:
  447. len = 8;
  448. if (bind_size > 0) {
  449. *(SDOUBLE *) ((char *) rgbValue + (bind_row * bind_size)) = atof(value);
  450. } else {
  451. *((SDOUBLE *)rgbValue + bind_row) = atof(value);
  452. }
  453. break;
  455. case SQL_C_SSHORT:
  456. case SQL_C_SHORT:
  457. len = 2;
  458. if (bind_size > 0) {
  459. *(SWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
  460. } else {
  461. *((SWORD *)rgbValue + bind_row) = atoi(value);
  462. }
  463. break;
  465. case SQL_C_USHORT:
  466. len = 2;
  467. if (bind_size > 0) {
  468. *(UWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
  469. } else {
  470. *((UWORD *)rgbValue + bind_row) = atoi(value);
  471. }
  472. break;
  474. case SQL_C_SLONG:
  475. case SQL_C_LONG:
  476. len = 4;
  477. if (bind_size > 0) {
  478. *(SDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(value);
  479. } else {
  480. *((SDWORD *)rgbValue + bind_row) = atol(value);
  481. }
  482. break;
  484. case SQL_C_ULONG:
  485. len = 4;
  486. if (bind_size > 0) {
  487. *(UDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(value);
  488. } else {
  489. *((UDWORD *)rgbValue + bind_row) = atol(value);
  490. }
  491. break;
  493. case SQL_C_BINARY:
  495. // truncate if necessary
  496. // convert octal escapes to bytes
  498. len = convert_from_pgbinary(value, tempBuf, sizeof(tempBuf));
  499. ptr = tempBuf;
  501. if (stmt->current_col >= 0) {
  503. /* No more data left for this column */
  504. if (stmt->bindings[stmt->current_col].data_left == 0)
  505. return COPY_NO_DATA_FOUND;
  507. /* Second (or more) call to SQLGetData so move the pointer */
  508. else if (stmt->bindings[stmt->current_col].data_left > 0) {
  509. ptr += len - stmt->bindings[stmt->current_col].data_left;
  510. len = stmt->bindings[stmt->current_col].data_left;
  511. }
  513. /* First call to SQLGetData so initialize data_left */
  514. else
  515. stmt->bindings[stmt->current_col].data_left = len;
  517. }
  519. if (cbValueMax > 0) {
  520. copy_len = (len > cbValueMax) ? cbValueMax : len;
  522. /* Copy the data */
  523. memcpy(rgbValueBindRow, ptr, copy_len);
  525. /* Adjust data_left for next time */
  526. if (stmt->current_col >= 0) {
  527. stmt->bindings[stmt->current_col].data_left -= copy_len;
  528. }
  529. }
  531. /* Finally, check for truncation so that proper status can be returned */
  532. if ( len > cbValueMax)
  533. result = COPY_RESULT_TRUNCATED;
  535. mylog("SQL_C_BINARY: len = %d, copy_len = %dn", len, copy_len);
  536. break;
  538. default:
  539. return COPY_UNSUPPORTED_TYPE;
  540. }
  541. }
  543.     // store the length of what was copied, if there's a place for it
  544.     if(pcbValue) {
  545.         *(SDWORD *) ((char *)pcbValue + pcbValueOffset) = len;
  546. }
  548. return result;
  550. }
  553. /* This function inserts parameters into an SQL statements.
  554. It will also modify a SELECT statement for use with declare/fetch cursors.
  555. This function no longer does any dynamic memory allocation!
  556. */
  557. int
  558. copy_statement_with_parameters(StatementClass *stmt)
  559. {
  560. static char *func="copy_statement_with_parameters";
  561. unsigned int opos, npos;
  562. char param_string[128], tmp[256], cbuf[TEXT_FIELD_SIZE+5];
  563. int param_number;
  564. Int2 param_ctype, param_sqltype;
  565. char *old_statement = stmt->statement;
  566. char *new_statement = stmt->stmt_with_params;
  567. SIMPLE_TIME st;
  568. time_t t = time(NULL);
  569. struct tm *tim;
  570. SDWORD used;
  571. char *buffer, *buf;
  572. char in_quote = FALSE;
  573. Oid  lobj_oid;
  574. int lobj_fd, retval;
  577. if ( ! old_statement) {
  578. SC_log_error(func, "No statement string", stmt);
  579. return SQL_ERROR;
  580. }
  582. memset(&st, 0, sizeof(SIMPLE_TIME));
  584. /* Initialize current date */
  585. tim = localtime(&t);
  586. st.m = tim->tm_mon + 1;
  587. st.d = tim->tm_mday;
  588. st.y = tim->tm_year + 1900;
  590. /* If the application hasn't set a cursor name, then generate one */
  591. if ( stmt->cursor_name[0] == '')
  592. sprintf(stmt->cursor_name, "SQL_CUR%p", stmt);
  594. // For selects, prepend a declare cursor to the statement
  595. if (stmt->statement_type == STMT_TYPE_SELECT && globals.use_declarefetch) {
  596. sprintf(new_statement, "declare %s cursor for ", stmt->cursor_name);
  597. npos = strlen(new_statement);
  598. }
  599. else {
  600. new_statement[0] = '0';
  601. npos = 0;
  602. }
  604.     param_number = -1;
  606.     for (opos = 0; opos < strlen(old_statement); opos++) {
  608. // Squeeze carriage-returns/linfeed pairs to linefeed only
  609. if (old_statement[opos] == 'r' && opos+1<strlen(old_statement) && old_statement[opos+1] == 'n') {
  610. continue;
  611. }
  613. // Handle literals (date, time, timestamp)
  614. else if (old_statement[opos] == '{') {
  615. char *esc;
  616. char *begin = &old_statement[opos + 1];
  617. char *end = strchr(begin, '}');
  619. if ( ! end)
  620. continue;
  622. *end = '';
  624. esc = convert_escape(begin);
  625. if (esc) {
  626. memcpy(&new_statement[npos], esc, strlen(esc));
  627. npos += strlen(esc);
  628. }
  629. else { /* its not a valid literal so just copy */
  630. *end = '}';
  631. new_statement[npos++] = old_statement[opos];
  632. continue;
  633. }
  635. opos += end - begin + 1;
  637. *end = '}';
  639. continue;
  640. }
  642. /* Can you have parameter markers inside of quotes?  I dont think so.
  643. All the queries I've seen expect the driver to put quotes if needed.
  644. */
  645. else if (old_statement[opos] == '?' && !in_quote)
  646. ; /* ok */
  647. else {
  648. if (old_statement[opos] == ''')
  649. in_quote = (in_quote ? FALSE : TRUE);
  651. new_statement[npos++] = old_statement[opos];
  652. continue;
  653. }
  657. /****************************************************/
  658. /*       Its a '?' parameter alright                */
  659. /****************************************************/
  661. param_number++;
  663.     if (param_number >= stmt->parameters_allocated)
  664. break;
  666. /* Assign correct buffers based on data at exec param or not */
  667. if ( stmt->parameters[param_number].data_at_exec) {
  668. used = stmt->parameters[param_number].EXEC_used ? *stmt->parameters[param_number].EXEC_used : SQL_NTS;
  669. buffer = stmt->parameters[param_number].EXEC_buffer;
  670. }
  671. else {
  672. used = stmt->parameters[param_number].used ? *stmt->parameters[param_number].used : SQL_NTS;
  673. buffer = stmt->parameters[param_number].buffer;
  674. }
  676. /* Handle NULL parameter data */
  677. if (used == SQL_NULL_DATA) {
  678. strcpy(&new_statement[npos], "NULL");
  679. npos += 4;
  680. continue;
  681. }
  683. /* If no buffer, and its not null, then what the hell is it? 
  684. Just leave it alone then.
  685. */
  686. if ( ! buffer) {
  687. new_statement[npos++] = '?';
  688. continue;
  689. }
  691. param_ctype = stmt->parameters[param_number].CType;
  692. param_sqltype = stmt->parameters[param_number].SQLType;
  694. mylog("copy_statement_with_params: from(fcType)=%d, to(fSqlType)=%dn", param_ctype, param_sqltype);
  696. // replace DEFAULT with something we can use
  697. if(param_ctype == SQL_C_DEFAULT)
  698. param_ctype = sqltype_to_default_ctype(param_sqltype);
  700. buf = NULL;
  701. param_string[0] = '';
  702. cbuf[0] = '';
  705. /* Convert input C type to a neutral format */
  706. switch(param_ctype) {
  707. case SQL_C_BINARY:
  708. case SQL_C_CHAR:
  709. buf = buffer;
  710. break;
  712. case SQL_C_DOUBLE:
  713. sprintf(param_string, "%f", 
  714.  *((SDOUBLE *) buffer));
  715. break;
  717. case SQL_C_FLOAT:
  718. sprintf(param_string, "%f", 
  719.  *((SFLOAT *) buffer));
  720. break;
  722. case SQL_C_SLONG:
  723. case SQL_C_LONG:
  724. sprintf(param_string, "%ld",
  725. *((SDWORD *) buffer));
  726. break;
  728. case SQL_C_SSHORT:
  729. case SQL_C_SHORT:
  730. sprintf(param_string, "%d",
  731. *((SWORD *) buffer));
  732. break;
  734. case SQL_C_STINYINT:
  735. case SQL_C_TINYINT:
  736. sprintf(param_string, "%d",
  737. *((SCHAR *) buffer));
  738. break;
  740. case SQL_C_ULONG:
  741. sprintf(param_string, "%lu",
  742. *((UDWORD *) buffer));
  743. break;
  745. case SQL_C_USHORT:
  746. sprintf(param_string, "%u",
  747. *((UWORD *) buffer));
  748. break;
  750. case SQL_C_UTINYINT:
  751. sprintf(param_string, "%u",
  752. *((UCHAR *) buffer));
  753. break;
  755. case SQL_C_BIT: {
  756. int i = *((UCHAR *) buffer);
  758. sprintf(param_string, "%d", i ? 1 : 0);
  759. break;
  760. }
  762. case SQL_C_DATE: {
  763. DATE_STRUCT *ds = (DATE_STRUCT *) buffer;
  764. st.m = ds->month;
  765. st.d = ds->day;
  766. st.y = ds->year;
  768. break;
  769.  }
  771. case SQL_C_TIME: {
  772. TIME_STRUCT *ts = (TIME_STRUCT *) buffer;
  773. st.hh = ts->hour;
  774. st.mm = ts->minute;
  775. st.ss = ts->second;
  777. break;
  778.  }
  780. case SQL_C_TIMESTAMP: {
  781. TIMESTAMP_STRUCT *tss = (TIMESTAMP_STRUCT *) buffer;
  782. st.m = tss->month;
  783. st.d = tss->day;
  784. st.y = tss->year;
  785. st.hh = tss->hour;
  786. st.mm = tss->minute;
  787. st.ss = tss->second;
  789. mylog("m=%d,d=%d,y=%d,hh=%d,mm=%d,ss=%dn", st.m, st.d, st.y, st.hh, st.mm, st.ss);
  791. break;
  793.   }
  794. default:
  795. // error
  796. stmt->errormsg = "Unrecognized C_parameter type in copy_statement_with_parameters";
  797. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  798. new_statement[npos] = '';   // just in case
  799. SC_log_error(func, "", stmt);
  800. return SQL_ERROR;
  801. }
  803. /* Now that the input data is in a neutral format, convert it to
  804. the desired output format (sqltype)
  805. */
  807. switch(param_sqltype) {
  808. case SQL_CHAR:
  809. case SQL_VARCHAR:
  810. case SQL_LONGVARCHAR:
  812. new_statement[npos++] = '''; /*    Open Quote */
  814. /* it was a SQL_C_CHAR */
  815. if (buf) {
  816. convert_special_chars(buf, &new_statement[npos], used);
  817. npos += strlen(&new_statement[npos]);
  818. }
  820. /* it was a numeric type */
  821. else if (param_string[0] != '') {
  822. strcpy(&new_statement[npos], param_string);
  823. npos += strlen(param_string);
  824. }
  826. /* it was date,time,timestamp -- use m,d,y,hh,mm,ss */
  827. else {
  828. sprintf(tmp, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
  829. st.y, st.m, st.d, st.hh, st.mm, st.ss);
  831. strcpy(&new_statement[npos], tmp);
  832. npos += strlen(tmp);
  833. }
  835. new_statement[npos++] = '''; /*    Close Quote */
  837. break;
  839. case SQL_DATE:
  840. if (buf) {  /* copy char data to time */
  841. my_strcpy(cbuf, sizeof(cbuf), buf, used);
  842. parse_datetime(cbuf, &st);
  843. }
  845. sprintf(tmp, "'%.4d-%.2d-%.2d'", st.y, st.m, st.d);
  847. strcpy(&new_statement[npos], tmp);
  848. npos += strlen(tmp);
  849. break;
  851. case SQL_TIME:
  852. if (buf) {  /* copy char data to time */
  853. my_strcpy(cbuf, sizeof(cbuf), buf, used);
  854. parse_datetime(cbuf, &st);
  855. }
  857. sprintf(tmp, "'%.2d:%.2d:%.2d'", st.hh, st.mm, st.ss);
  859. strcpy(&new_statement[npos], tmp);
  860. npos += strlen(tmp);
  861. break;
  863. case SQL_TIMESTAMP:
  865. if (buf) {
  866. my_strcpy(cbuf, sizeof(cbuf), buf, used);
  867. parse_datetime(cbuf, &st);
  868. }
  870. sprintf(tmp, "'%.4d-%.2d-%.2d %.2d:%.2d:%.2d'",
  871. st.y, st.m, st.d, st.hh, st.mm, st.ss);
  873. strcpy(&new_statement[npos], tmp);
  874. npos += strlen(tmp);
  876. break;
  878. case SQL_BINARY:
  879. case SQL_VARBINARY: /* non-ascii characters should be converted to octal */
  880. new_statement[npos++] = '''; /*    Open Quote */
  882. mylog("SQL_VARBINARY: about to call convert_to_pgbinary, used = %dn", used);
  884. npos += convert_to_pgbinary(buf, &new_statement[npos], used);
  886. new_statement[npos++] = '''; /*    Close Quote */
  888. break;
  890. case SQL_LONGVARBINARY:
  892. if ( stmt->parameters[param_number].data_at_exec) {
  894. lobj_oid = stmt->parameters[param_number].lobj_oid;
  896. }
  897. else {
  899. /* store the oid */
  900. lobj_oid = lo_creat(stmt->hdbc, INV_READ | INV_WRITE);
  901. if (lobj_oid == 0) {
  902. stmt->errornumber = STMT_EXEC_ERROR;
  903. stmt->errormsg = "Couldnt create (in-line) large object.";
  904. SC_log_error(func, "", stmt);
  905. return SQL_ERROR;
  906. }
  908. /* store the fd */
  909. lobj_fd = lo_open(stmt->hdbc, lobj_oid, INV_WRITE);
  910. if ( lobj_fd < 0) {
  911. stmt->errornumber = STMT_EXEC_ERROR;
  912. stmt->errormsg = "Couldnt open (in-line) large object for writing.";
  913. SC_log_error(func, "", stmt);
  914. return SQL_ERROR;
  915. }
  917. retval = lo_write(stmt->hdbc, lobj_fd, buffer, used);
  919. lo_close(stmt->hdbc, lobj_fd);
  920. }
  922. /* the oid of the large object -- just put that in for the
  923. parameter marker -- the data has already been sent to the large object
  924. */
  925. sprintf(param_string, "'%d'", lobj_oid);
  926. strcpy(&new_statement[npos], param_string);
  927. npos += strlen(param_string);
  929. break;
  931. // because of no conversion operator for bool and int4, SQL_BIT
  932. // must be quoted (0 or 1 is ok to use inside the quotes)
  934. default: /* a numeric type or SQL_BIT */
  935. if (param_sqltype == SQL_BIT)
  936. new_statement[npos++] = '''; /*    Open Quote */
  938. if (buf) {
  939. my_strcpy(&new_statement[npos], sizeof(stmt->stmt_with_params) - npos, buf, used);
  940. npos += strlen(&new_statement[npos]);
  941. }
  942. else {
  943. strcpy(&new_statement[npos], param_string);
  944. npos += strlen(param_string);
  945. }
  947. if (param_sqltype == SQL_BIT)
  948. new_statement[npos++] = '''; /*    Close Quote */
  950. break;
  952. }
  954. } /* end, for */
  956. // make sure new_statement is always null-terminated
  957. new_statement[npos] = '';
  960. if(stmt->hdbc->DriverToDataSource != NULL) {
  961. int length = strlen (new_statement);
  962. stmt->hdbc->DriverToDataSource (stmt->hdbc->translation_option,
  963. SQL_CHAR,
  964. new_statement, length,
  965. new_statement, length, NULL,
  966. NULL, 0, NULL);
  967. }
  970. return SQL_SUCCESS;
  971. }
  973. char *
  974. mapFunction(char *func)
  975. {
  976. int i;
  978. for (i = 0; mapFuncs[i][0]; i++)
  979. if ( ! stricmp(mapFuncs[i][0], func))
  980. return mapFuncs[i][1];
  982. return NULL;
  983. }
  985. // This function returns a pointer to static memory!
  986. char *
  987. convert_escape(char *value)
  988. {
  989. char key[32], val[256];
  990. static char escape[1024];
  991. char func[32], the_rest[1024];
  992. char *mapFunc;
  994. sscanf(value, "%s %[^r]", key, val);
  996. mylog("convert_escape: key='%s', val='%s'n", key, val);
  998. if ( ! strcmp(key, "d") ||
  999.  ! strcmp(key, "t") ||
  1000.  ! strcmp(key, "ts")) {
  1002. strcpy(escape, val);
  1003. }
  1004. else if ( ! strcmp(key, "fn")) {
  1005. sscanf(val, "%[^(]%[^r]", func, the_rest);
  1006. mapFunc = mapFunction(func);
  1007. if ( ! mapFunc)
  1008. return NULL;
  1009. else {
  1010. strcpy(escape, mapFunc);
  1011. strcat(escape, the_rest);
  1012. }
  1014. }
  1015. else {
  1016. return NULL;
  1017. }
  1019. return escape;
  1021. }
  1024. char *
  1025. convert_money(char *s)
  1026. {
  1027. size_t i = 0, out = 0;
  1029. for (i = 0; i < strlen(s); i++) {
  1030. if (s[i] == '$' || s[i] == ',' || s[i] == ')')
  1031. ; // skip these characters
  1032. else if (s[i] == '(')
  1033. s[out++] = '-';
  1034. else
  1035. s[out++] = s[i];
  1036. }
  1037. s[out] = '';
  1038. return s;
  1039. }
  1043. /* This function parses a character string for date/time info and fills in SIMPLE_TIME */
  1044. /* It does not zero out SIMPLE_TIME in case it is desired to initialize it with a value */
  1045. char
  1046. parse_datetime(char *buf, SIMPLE_TIME *st)
  1047. {
  1048. int y,m,d,hh,mm,ss;
  1049. int nf;
  1051. y = m = d = hh = mm = ss = 0;
  1053. if (buf[4] == '-') /* year first */
  1054. nf = sscanf(buf, "%4d-%2d-%2d %2d:%2d:%2d", &y,&m,&d,&hh,&mm,&ss);
  1055. else
  1056. nf = sscanf(buf, "%2d-%2d-%4d %2d:%2d:%2d", &m,&d,&y,&hh,&mm,&ss);
  1058. if (nf == 5 || nf == 6) {
  1059. st->y = y;
  1060. st->m = m;
  1061. st->d = d;
  1062. st->hh = hh;
  1063. st->mm = mm;
  1064. st->ss = ss;
  1066. return TRUE;
  1067. }
  1069. if (buf[4] == '-') /* year first */
  1070. nf = sscanf(buf, "%4d-%2d-%2d", &y, &m, &d);
  1071. else
  1072. nf = sscanf(buf, "%2d-%2d-%4d", &m, &d, &y);
  1074. if (nf == 3) {
  1075. st->y = y;
  1076. st->m = m;
  1077. st->d = d;
  1079. return TRUE;
  1080. }
  1082. nf = sscanf(buf, "%2d:%2d:%2d", &hh, &mm, &ss);
  1083. if (nf == 2 || nf == 3) {
  1084. st->hh = hh;
  1085. st->mm = mm;
  1086. st->ss = ss;
  1088. return TRUE;
  1089. }
  1091. return FALSE;
  1092. }
  1094. /* Change linefeed to carriage-return/linefeed */
  1095. int
  1096. convert_linefeeds(char *si, char *dst, size_t max)
  1097. {
  1098. size_t i = 0, out = 0;
  1100. for (i = 0; i < strlen(si) && out < max - 1; i++) {
  1101. if (si[i] == 'n') {
  1102. /* Only add the carriage-return if needed */
  1103. if (i > 0 && si[i-1] == 'r') {
  1104. dst[out++] = si[i];
  1105. continue;
  1106. }
  1108. dst[out++] = 'r';
  1109. dst[out++] = 'n';
  1110. }
  1111. else
  1112. dst[out++] = si[i];
  1113. }
  1114. dst[out] = '';
  1115. return out;
  1116. }
  1118. /* Change carriage-return/linefeed to just linefeed 
  1119. Plus, escape any special characters.
  1120. */
  1121. char *
  1122. convert_special_chars(char *si, char *dst, int used)
  1123. {
  1124. size_t i = 0, out = 0, max;
  1125. static char sout[TEXT_FIELD_SIZE+5];
  1126. char *p;
  1128. if (dst)
  1129. p = dst;
  1130. else
  1131. p = sout;
  1133. p[0] = '';
  1135. if (used == SQL_NTS)
  1136. max = strlen(si);
  1137. else
  1138. max = used;
  1140. for (i = 0; i < max; i++) {
  1141. if (si[i] == 'r' && i+1 < strlen(si) && si[i+1] == 'n') 
  1142. continue;
  1143. else if (si[i] == ''' || si[i] == '\')
  1144. p[out++] = '\';
  1146. p[out++] = si[i];
  1147. }
  1148. p[out] = '';
  1149. return p;
  1150. }
  1152. /* !!! Need to implement this function !!!  */
  1153. int
  1154. convert_pgbinary_to_char(char *value, char *rgbValue, int cbValueMax)
  1155. {
  1156. mylog("convert_pgbinary_to_char: value = '%s'n", value);
  1158. strncpy_null(rgbValue, value, cbValueMax);
  1159. return 0;
  1160. }
  1162. unsigned int
  1163. conv_from_octal(unsigned char *s)
  1164. {
  1165. int i, y=0;
  1167. for (i = 1; i <= 3; i++) {
  1168. y += (s[i] - 48) * (int) pow(8, 3-i);
  1169. }
  1171. return y;
  1173. }
  1175. unsigned int
  1176. conv_from_hex(unsigned char *s)
  1177. {
  1178. int i, y=0, val;
  1180. for (i = 1; i <= 2; i++) {
  1182.         if (s[i] >= 'a' && s[i] <= 'f')
  1183.             val = s[i] - 'a' + 10;
  1184.         else if (s[i] >= 'A' && s[i] <= 'F')
  1185.             val = s[i] - 'A' + 10;
  1186.         else
  1187.             val = s[i] - '0';
  1189. y += val * (int) pow(16, 2-i);
  1190. }
  1192. return y;
  1193. }
  1195. // convert octal escapes to bytes
  1196. int
  1197. convert_from_pgbinary(unsigned char *value, unsigned char *rgbValue, int cbValueMax)
  1198. {
  1199. size_t i;
  1200. int o=0;
  1203. for (i = 0; i < strlen(value); ) {
  1204. if (value[i] == '\') {
  1205. rgbValue[o] = conv_from_octal(&value[i]);
  1206. i += 4;
  1207. }
  1208. else {
  1209. rgbValue[o] = value[i++];
  1210. }
  1211. mylog("convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %cn", i, o, rgbValue[o], rgbValue[o]);
  1212. o++;
  1213. }
  1215. rgbValue[o] = ''; // extra protection
  1217. return o;
  1218. }
  1221. char *
  1222. conv_to_octal(unsigned char val)
  1223. {
  1224. int i;
  1225. static char x[6];
  1227. x[0] = '\';
  1228. x[1] = '\';
  1229. x[5] = '';
  1231. for (i = 4; i > 1; i--) {
  1232. x[i] = (val & 7) + 48;
  1233. val >>= 3;
  1234. }
  1236. return x;
  1237. }
  1239. // convert non-ascii bytes to octal escape sequences
  1240. int
  1241. convert_to_pgbinary(unsigned char *in, char *out, int len)
  1242. {
  1243. int i, o=0;
  1246. for (i = 0; i < len; i++) {
  1247. mylog("convert_to_pgbinary: in[%d] = %d, %cn", i, in[i], in[i]);
  1248. if ( isalnum(in[i]) || in[i] == ' ') {
  1249. out[o++] = in[i];
  1250. }
  1251. else {
  1252. strcpy(&out[o], conv_to_octal(in[i])); 
  1253. o += 5;
  1254. }
  1256. }
  1258. mylog("convert_to_pgbinary: returning %d, out='%.*s'n", o, o, out);
  1260. return o;
  1261. }
  1264. void
  1265. encode(char *in, char *out)
  1266. {
  1267. unsigned int i, o = 0;
  1269. for (i = 0; i < strlen(in); i++) {
  1270. if ( in[i] == '+') {
  1271. sprintf(&out[o], "%%2B");
  1272. o += 3;
  1273. }
  1274. else if ( isspace(in[i])) {
  1275. out[o++] = '+';
  1276. }
  1277. else if ( ! isalnum(in[i])) {
  1278. sprintf(&out[o], "%%%02x", in[i]);
  1279. o += 3;
  1280. }
  1281. else
  1282. out[o++] = in[i];
  1283. }
  1284. out[o++] = '';
  1285. }
  1288. void
  1289. decode(char *in, char *out)
  1290. {
  1291. unsigned int i, o = 0;
  1293. for (i = 0; i < strlen(in); i++) { 
  1294. if (in[i] == '+')
  1295. out[o++] = ' ';
  1296. else if (in[i] == '%') {
  1297. sprintf(&out[o++], "%c", conv_from_hex(&in[i]));
  1298. i+=2;
  1299. }
  1300. else
  1301. out[o++] = in[i];
  1302. }
  1303. out[o++] = '';
  1304. }
  1308. /* 1. get oid (from 'value')
  1309. 2. open the large object
  1310. 3. read from the large object (handle multiple GetData)
  1311. 4. close when read less than requested?  -OR-
  1312. lseek/read each time
  1313. handle case where application receives truncated and
  1314. decides not to continue reading.
  1316. CURRENTLY, ONLY LONGVARBINARY is handled, since that is the only
  1317. data type currently mapped to a PG_TYPE_LO.  But, if any other types
  1318. are desired to map to a large object (PG_TYPE_LO), then that would 
  1319. need to be handled here.  For example, LONGVARCHAR could possibly be
  1320. mapped to PG_TYPE_LO someday, instead of PG_TYPE_TEXT as it is now.
  1321. */
  1322. int
  1323. convert_lo(StatementClass *stmt, void *value, Int2 fCType, PTR rgbValue, 
  1324.    SDWORD cbValueMax, SDWORD *pcbValue)
  1325. {
  1326. Oid oid;
  1327. int retval, result, left = -1;
  1328. int bind_row = stmt->bind_row;
  1329. BindInfoClass *bindInfo = NULL;
  1332. /* If using SQLGetData, then current_col will be set */
  1333. if (stmt->current_col >= 0) {
  1334. bindInfo = &stmt->bindings[stmt->current_col];
  1335. left = bindInfo->data_left;
  1336. }
  1338. /* if this is the first call for this column,
  1339. open the large object for reading 
  1340. */
  1342. if ( ! bindInfo || bindInfo->data_left == -1) {
  1343. oid = atoi(value);
  1344. stmt->lobj_fd = lo_open(stmt->hdbc, oid, INV_READ);
  1345. if (stmt->lobj_fd < 0) {
  1346. stmt->errornumber = STMT_EXEC_ERROR;
  1347. stmt->errormsg = "Couldnt open large object for reading.";
  1348. return COPY_GENERAL_ERROR;
  1349. }
  1351. /* Get the size */
  1352. retval = lo_lseek(stmt->hdbc, stmt->lobj_fd, 0L, SEEK_END);
  1353. if (retval >= 0) {
  1355. left = lo_tell(stmt->hdbc, stmt->lobj_fd);
  1356. if (bindInfo)
  1357. bindInfo->data_left = left;
  1359. /* return to beginning */
  1360. lo_lseek(stmt->hdbc, stmt->lobj_fd, 0L, SEEK_SET);
  1361. }
  1362. }
  1364. if (left == 0) {
  1365. return COPY_NO_DATA_FOUND;
  1366. }
  1368. if (stmt->lobj_fd < 0) {
  1369. stmt->errornumber = STMT_EXEC_ERROR;
  1370. stmt->errormsg = "Large object FD undefined for multiple read.";
  1371. return COPY_GENERAL_ERROR;
  1372. }
  1374. retval = lo_read(stmt->hdbc, stmt->lobj_fd, (char *) rgbValue, cbValueMax);
  1375. if (retval < 0) {
  1376. lo_close(stmt->hdbc, stmt->lobj_fd);
  1377. stmt->lobj_fd = -1;
  1379. stmt->errornumber = STMT_EXEC_ERROR;
  1380. stmt->errormsg = "Error reading from large object.";
  1381. return COPY_GENERAL_ERROR;
  1382. }
  1384. if (retval < left)
  1385. result = COPY_RESULT_TRUNCATED;
  1386. else
  1387. result = COPY_OK;
  1389. if (pcbValue)
  1390. *pcbValue = left < 0 ? SQL_NO_TOTAL : left;
  1393. if (bindInfo && bindInfo->data_left > 0) 
  1394. bindInfo->data_left -= retval;
  1397. if (! bindInfo || bindInfo->data_left == 0) {
  1398. lo_close(stmt->hdbc, stmt->lobj_fd);
  1399. stmt->lobj_fd = -1; /* prevent further reading */
  1400. }
  1403. return result;
  1405. }