convert.c 48.3 KB
Newer Older
1
/*-------
2
 * Module:               convert.c
3
 *
4 5 6 7 8 9
 * Description:    This module contains routines related to
 *				   converting parameters and columns into requested data types.
 *				   Parameters are converted from their SQL_C data types into
 *				   the appropriate postgres type.  Columns are converted from
 *				   their postgres type (SQL type) into the appropriate SQL_C
 *				   data type.
10
 *
11
 * Classes:		   n/a
12 13 14
 *
 * API functions:  none
 *
15
 * Comments:	   See "notice.txt" for copyright and license information.
16
 *-------
17
 */
Hiroshi Inoue's avatar
Hiroshi Inoue committed
18
/* Multibyte support  Eiji Tokuya	2001-03-15	*/
19

Byron Nikolaidis's avatar
Byron Nikolaidis committed
20
#ifdef HAVE_CONFIG_H
21
#include "config.h"
Byron Nikolaidis's avatar
Byron Nikolaidis committed
22 23
#endif

24 25
#include <stdio.h>
#include <string.h>
26
#include <ctype.h>
Byron Nikolaidis's avatar
Byron Nikolaidis committed
27

28 29
#include "psqlodbc.h"

Hiroshi Inoue's avatar
Hiroshi Inoue committed
30 31 32 33
#ifdef MULTIBYTE
#include "multibyte.h"
#endif

34
#ifndef WIN32
Byron Nikolaidis's avatar
Byron Nikolaidis committed
35 36 37 38
#include "iodbc.h"
#include "isql.h"
#include "isqlext.h"
#else
39
#include <windows.h>
40
#include <sql.h>
41
#include <sqlext.h>
Byron Nikolaidis's avatar
Byron Nikolaidis committed
42 43
#endif

44
#include <time.h>
45
#include <math.h>
46
#include <stdlib.h>
47 48
#include "convert.h"
#include "statement.h"
49
#include "qresult.h"
50 51
#include "bind.h"
#include "pgtypes.h"
52 53 54
#include "lobj.h"
#include "connection.h"

55 56
#ifndef WIN32
#ifndef HAVE_STRICMP
Byron Nikolaidis's avatar
Byron Nikolaidis committed
57 58 59 60 61
#define stricmp(s1,s2) strcasecmp(s1,s2)
#define strnicmp(s1,s2,n) strncasecmp(s1,s2,n)
#endif
#ifndef SCHAR
typedef signed char SCHAR;
62

Byron Nikolaidis's avatar
Byron Nikolaidis committed
63 64 65
#endif
#endif

66 67
extern GLOBAL_VALUES globals;

68 69 70 71
/*
 *	How to map ODBC scalar functions {fn func(args)} to Postgres.
 *	This is just a simple substitution.  List augmented from:
 *	http://www.merant.com/datadirect/download/docs/odbc16/Odbcref/rappc.htm
72
 *	- thomas 2000-04-03
73
 */
74 75 76 77
char	   *mapFuncs[][2] = {
/*	{ "ASCII",		 "ascii"	  }, */
	{"CHAR", "chr"},
	{"CONCAT", "textcat"},
78
/*	{ "DIFFERENCE",  "difference" }, */
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
/*	{ "INSERT",		 "insert"	  }, */
	{"LCASE", "lower"},
	{"LEFT", "ltrunc"},
	{"LOCATE", "strpos"},
	{"LENGTH", "char_length"},
/*	{ "LTRIM",		 "ltrim"	  }, */
	{"RIGHT", "rtrunc"},
/*	{ "REPEAT",		 "repeat"	  }, */
/*	{ "REPLACE",	 "replace"	  }, */
/*	{ "RTRIM",		 "rtrim"	  }, */
/*	{ "SOUNDEX",	 "soundex"	  }, */
	{"SUBSTRING", "substr"},
	{"UCASE", "upper"},

/*	{ "ABS",		 "abs"		  }, */
/*	{ "ACOS",		 "acos"		  }, */
/*	{ "ASIN",		 "asin"		  }, */
/*	{ "ATAN",		 "atan"		  }, */
/*	{ "ATAN2",		 "atan2"	  }, */
	{"CEILING", "ceil"},
/*	{ "COS",		 "cos"		  }, */
/*	{ "COT",		 "cot"		  }, */
/*	{ "DEGREES",	 "degrees"	  }, */
/*	{ "EXP",		 "exp"		  }, */
/*	{ "FLOOR",		 "floor"	  }, */
	{"LOG", "ln"},
	{"LOG10", "log"},
/*	{ "MOD",		 "mod"		  }, */
/*	{ "PI",			 "pi"		  }, */
	{"POWER", "pow"},
/*	{ "RADIANS",	 "radians"	  }, */
	{"RAND", "random"},
/*	{ "ROUND",		 "round"	  }, */
/*	{ "SIGN",		 "sign"		  }, */
/*	{ "SIN",		 "sin"		  }, */
/*	{ "SQRT",		 "sqrt"		  }, */
/*	{ "TAN",		 "tan"		  }, */
	{"TRUNCATE", "trunc"},

/*	{ "CURDATE",	 "curdate"	  }, */
/*	{ "CURTIME",	 "curtime"	  }, */
/*	{ "DAYNAME",	 "dayname"	  }, */
121
/*	{ "DAYOFMONTH",  "dayofmonth" }, */
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
/*	{ "DAYOFWEEK",	 "dayofweek"  }, */
/*	{ "DAYOFYEAR",	 "dayofyear"  }, */
/*	{ "HOUR",		 "hour"		  }, */
/*	{ "MINUTE",		 "minute"	  }, */
/*	{ "MONTH",		 "month"	  }, */
/*	{ "MONTHNAME",	 "monthname"  }, */
/*	{ "NOW",		 "now"		  }, */
/*	{ "QUARTER",	 "quarter"	  }, */
/*	{ "SECOND",		 "second"	  }, */
/*	{ "WEEK",		 "week"		  }, */
/*	{ "YEAR",		 "year"		  }, */

/*	{ "DATABASE",	 "database"   }, */
	{"IFNULL", "coalesce"},
	{"USER", "odbc_user"},
	{0, 0}
138 139
};

140
char	   *mapFunction(char *func);
141 142
unsigned int conv_from_octal(unsigned char *s);
unsigned int conv_from_hex(unsigned char *s);
143
char	   *conv_to_octal(unsigned char val);
144

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
/*---------
 *			A Guide for date/time/timestamp conversions
 *
 *			field_type		fCType				Output
 *			----------		------				----------
 *			PG_TYPE_DATE	SQL_C_DEFAULT		SQL_C_DATE
 *			PG_TYPE_DATE	SQL_C_DATE			SQL_C_DATE
 *			PG_TYPE_DATE	SQL_C_TIMESTAMP		SQL_C_TIMESTAMP		(time = 0 (midnight))
 *			PG_TYPE_TIME	SQL_C_DEFAULT		SQL_C_TIME
 *			PG_TYPE_TIME	SQL_C_TIME			SQL_C_TIME
 *			PG_TYPE_TIME	SQL_C_TIMESTAMP		SQL_C_TIMESTAMP		(date = current date)
 *			PG_TYPE_ABSTIME SQL_C_DEFAULT		SQL_C_TIMESTAMP
 *			PG_TYPE_ABSTIME SQL_C_DATE			SQL_C_DATE			(time is truncated)
 *			PG_TYPE_ABSTIME SQL_C_TIME			SQL_C_TIME			(date is truncated)
 *			PG_TYPE_ABSTIME SQL_C_TIMESTAMP		SQL_C_TIMESTAMP
 *---------
 */
162 163 164 165 166



/*	This is called by SQLFetch() */
int
Bruce Momjian's avatar
Bruce Momjian committed
167
copy_and_convert_field_bindinfo(StatementClass *stmt, Int4 field_type, void *value, int col)
168
{
169
	BindInfoClass *bic = &(stmt->bindings[col]);
170

171 172
	return copy_and_convert_field(stmt, field_type, value, (Int2) bic->returntype, (PTR) bic->buffer,
							 (SDWORD) bic->buflen, (SDWORD *) bic->used);
173 174
}

175

176 177
/*	This is called by SQLGetData() */
int
178
copy_and_convert_field(StatementClass *stmt, Int4 field_type, void *value, Int2 fCType,
Bruce Momjian's avatar
Bruce Momjian committed
179
					   PTR rgbValue, SDWORD cbValueMax, SDWORD *pcbValue)
180
{
181 182
	Int4		len = 0,
				copy_len = 0;
183
	SIMPLE_TIME st;
184 185 186 187 188 189 190 191 192
	time_t		t = time(NULL);
	struct tm  *tim;
	int			pcbValueOffset,
				rgbValueOffset;
	char	   *rgbValueBindRow,
			   *ptr;
	int			bind_row = stmt->bind_row;
	int			bind_size = stmt->options.bind_size;
	int			result = COPY_OK;
193 194 195
	BOOL		changed;
	static		char *tempBuf= NULL;
	static		unsigned int tempBuflen = 0;
196

197 198
	if (!tempBuf)
		tempBuflen = 0;
199 200 201 202 203
	/*---------
	 *	rgbValueOffset is *ONLY* for character and binary data.
	 *	pcbValueOffset is for computing any pcbValue location
	 *---------
	 */
204

205
	if (bind_size > 0)
206
		pcbValueOffset = rgbValueOffset = (bind_size * bind_row);
207 208
	else
	{
209 210
		pcbValueOffset = bind_row * sizeof(SDWORD);
		rgbValueOffset = bind_row * cbValueMax;
211

212
	}
213 214 215

	memset(&st, 0, sizeof(SIMPLE_TIME));

216
	/* Initialize current date */
217 218 219 220 221
	tim = localtime(&t);
	st.m = tim->tm_mon + 1;
	st.d = tim->tm_mday;
	st.y = tim->tm_year + 1900;

222
	mylog("copy_and_convert: field_type = %d, fctype = %d, value = '%s', cbValueMax=%d\n", field_type, fCType, (value == NULL) ? "<NULL>" : value, cbValueMax);
223

224 225
	if (!value)
	{
226

227
		/*
228 229
		 * handle a null just by returning SQL_NULL_DATA in pcbValue, and
		 * doing nothing to the buffer.
230
		 */
231
		if (pcbValue)
232
			*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = SQL_NULL_DATA;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
233 234 235
		return COPY_OK;
	}

236 237 238 239 240 241 242 243 244
	if (stmt->hdbc->DataSourceToDriver != NULL)
	{
		int			length = strlen(value);

		stmt->hdbc->DataSourceToDriver(stmt->hdbc->translation_option,
									   SQL_CHAR,
									   value, length,
									   value, length, NULL,
									   NULL, 0, NULL);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
245 246
	}

247
	/*
248
	 * First convert any specific postgres types into more useable data.
249
	 *
250 251
	 * NOTE: Conversions from PG char/varchar of a date/time/timestamp value
	 * to SQL_C_DATE,SQL_C_TIME, SQL_C_TIMESTAMP not supported
252
	 */
253 254
	switch (field_type)
	{
255 256 257 258 259

			/*
			 * $$$ need to add parsing for date/time/timestamp strings in
			 * PG_TYPE_CHAR,VARCHAR $$$
			 */
260 261 262
		case PG_TYPE_DATE:
			sscanf(value, "%4d-%2d-%2d", &st.y, &st.m, &st.d);
			break;
263

264 265 266
		case PG_TYPE_TIME:
			sscanf(value, "%2d:%2d:%2d", &st.hh, &st.mm, &st.ss);
			break;
267

268 269 270 271 272 273
		case PG_TYPE_ABSTIME:
		case PG_TYPE_DATETIME:
		case PG_TYPE_TIMESTAMP:
			if (strnicmp(value, "invalid", 7) != 0)
				sscanf(value, "%4d-%2d-%2d %2d:%2d:%2d", &st.y, &st.m, &st.d, &st.hh, &st.mm, &st.ss);
			else
274
			{
275

276
				/*
277 278
				 * The timestamp is invalid so set something conspicuous,
				 * like the epoch
279
				 */
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
				t = 0;
				tim = localtime(&t);
				st.m = tim->tm_mon + 1;
				st.d = tim->tm_mday;
				st.y = tim->tm_year + 1900;
				st.hh = tim->tm_hour;
				st.mm = tim->tm_min;
				st.ss = tim->tm_sec;
			}
			break;

		case PG_TYPE_BOOL:
			{					/* change T/F to 1/0 */
				char	   *s = (char *) value;

				if (s[0] == 'T' || s[0] == 't')
					s[0] = '1';
				else
					s[0] = '0';
			}
			break;

302
			/* This is for internal use by SQLStatistics() */
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
		case PG_TYPE_INT2VECTOR:
			{
				int			nval,
							i;
				char	   *vp;

				/* this is an array of eight integers */
				short	   *short_array = (short *) ((char *) rgbValue + rgbValueOffset);

				len = 32;
				vp = value;
				nval = 0;
				mylog("index=(");
				for (i = 0; i < 16; i++)
				{
					if (sscanf(vp, "%hd", &short_array[i]) != 1)
						break;

					mylog(" %d", short_array[i]);
					nval++;

					/* skip the current token */
					while ((*vp != '\0') && (!isspace((unsigned char) *vp)))
						vp++;
					/* and skip the space to the next token */
					while ((*vp != '\0') && (isspace((unsigned char) *vp)))
						vp++;
					if (*vp == '\0')
						break;
				}
				mylog(") nval = %d\n", nval);

				for (i = nval; i < 16; i++)
					short_array[i] = 0;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
337

338
#if 0
339 340 341 342 343 344 345 346 347
				sscanf(value, "%hd %hd %hd %hd %hd %hd %hd %hd",
					   &short_array[0],
					   &short_array[1],
					   &short_array[2],
					   &short_array[3],
					   &short_array[4],
					   &short_array[5],
					   &short_array[6],
					   &short_array[7]);
348
#endif
Byron Nikolaidis's avatar
Byron Nikolaidis committed
349

350 351 352
				/* There is no corresponding fCType for this. */
				if (pcbValue)
					*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = len;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
353

354 355 356
				return COPY_OK; /* dont go any further or the data will be
								 * trashed */
			}
Byron Nikolaidis's avatar
Byron Nikolaidis committed
357

358 359 360 361 362
			/*
			 * This is a large object OID, which is used to store
			 * LONGVARBINARY objects.
			 */
		case PG_TYPE_LO:
Byron Nikolaidis's avatar
Byron Nikolaidis committed
363

364
			return convert_lo(stmt, value, fCType, ((char *) rgbValue + rgbValueOffset), cbValueMax, (SDWORD *) ((char *) pcbValue + pcbValueOffset));
Byron Nikolaidis's avatar
Byron Nikolaidis committed
365

366
		default:
Byron Nikolaidis's avatar
Byron Nikolaidis committed
367

368 369 370
			if (field_type == stmt->hdbc->lobj_type)	/* hack until permanent
														 * type available */
				return convert_lo(stmt, value, fCType, ((char *) rgbValue + rgbValueOffset), cbValueMax, (SDWORD *) ((char *) pcbValue + pcbValueOffset));
Byron Nikolaidis's avatar
Byron Nikolaidis committed
371 372
	}

373 374 375
	/* Change default into something useable */
	if (fCType == SQL_C_DEFAULT)
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
376 377 378 379 380
		fCType = pgtype_to_ctype(stmt, field_type);

		mylog("copy_and_convert, SQL_C_DEFAULT: fCType = %d\n", fCType);
	}

381 382
	rgbValueBindRow = (char *) rgbValue + rgbValueOffset;

383 384 385
	if (fCType == SQL_C_CHAR)
	{
		/* Special character formatting as required */
386

387 388 389 390 391 392 393 394 395 396 397
		/*
		 * These really should return error if cbValueMax is not big
		 * enough.
		 */
		switch (field_type)
		{
			case PG_TYPE_DATE:
				len = 10;
				if (cbValueMax > len)
					sprintf(rgbValueBindRow, "%.4d-%.2d-%.2d", st.y, st.m, st.d);
				break;
398

399 400 401 402 403
			case PG_TYPE_TIME:
				len = 8;
				if (cbValueMax > len)
					sprintf(rgbValueBindRow, "%.2d:%.2d:%.2d", st.hh, st.mm, st.ss);
				break;
404

405 406 407 408 409 410 411 412
			case PG_TYPE_ABSTIME:
			case PG_TYPE_DATETIME:
			case PG_TYPE_TIMESTAMP:
				len = 19;
				if (cbValueMax > len)
					sprintf(rgbValueBindRow, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
							st.y, st.m, st.d, st.hh, st.mm, st.ss);
				break;
413

414 415 416 417 418 419 420 421
			case PG_TYPE_BOOL:
				len = 1;
				if (cbValueMax > len)
				{
					strcpy(rgbValueBindRow, value);
					mylog("PG_TYPE_BOOL: rgbValueBindRow = '%s'\n", rgbValueBindRow);
				}
				break;
422

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
				/*
				 * Currently, data is SILENTLY TRUNCATED for BYTEA and
				 * character data types if there is not enough room in
				 * cbValueMax because the driver can't handle multiple
				 * calls to SQLGetData for these, yet.	Most likely, the
				 * buffer passed in will be big enough to handle the
				 * maximum limit of postgres, anyway.
				 *
				 * LongVarBinary types are handled correctly above, observing
				 * truncation and all that stuff since there is
				 * essentially no limit on the large object used to store
				 * those.
				 */
			case PG_TYPE_BYTEA:/* convert binary data to hex strings
								 * (i.e, 255 = "FF") */
				len = convert_pgbinary_to_char(value, rgbValueBindRow, cbValueMax);

				/***** THIS IS NOT PROPERLY IMPLEMENTED *****/
				break;
442

443
			default:
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
				if (stmt->current_col >= 0 && stmt->bindings[stmt->current_col].data_left == -2)
					stmt->bindings[stmt->current_col].data_left = (cbValueMax > 0) ? 0 : -1; /* This seems to be needed for ADO ? */
				if (stmt->current_col < 0 || stmt->bindings[stmt->current_col].data_left < 0)
				{
					/* convert linefeeds to carriage-return/linefeed */
					len = convert_linefeeds(value, NULL, 0, &changed);
					if (cbValueMax == 0) /* just returns length info */
					{
						result = COPY_RESULT_TRUNCATED;
						break;
					}
					if (changed || len >= cbValueMax)
					{
						if (len >= (int) tempBuflen)
						{
							tempBuf = realloc(tempBuf, len + 1);
							tempBuflen = len + 1;
						}
						convert_linefeeds(value, tempBuf, tempBuflen, &changed);
						ptr = tempBuf;
					}
					else
					{
						if (tempBuf)
						{
							free(tempBuf);
							tempBuf = NULL;
						}
						ptr = value;
					}
				}
				else
					ptr = tempBuf;
477 478 479 480 481 482

				mylog("DEFAULT: len = %d, ptr = '%s'\n", len, ptr);

				if (stmt->current_col >= 0)
				{
					if (stmt->bindings[stmt->current_col].data_left == 0)
483 484 485 486 487 488 489 490
					{
						if (tempBuf)
						{
							free(tempBuf);
							tempBuf = NULL;
						}
						/* The following seems to be needed for ADO ? */
						stmt->bindings[stmt->current_col].data_left = -2;
491
						return COPY_NO_DATA_FOUND;
492
					}
493 494
					else if (stmt->bindings[stmt->current_col].data_left > 0)
					{
495
						ptr += strlen(ptr) - stmt->bindings[stmt->current_col].data_left;
496 497 498
						len = stmt->bindings[stmt->current_col].data_left;
					}
					else
499
						stmt->bindings[stmt->current_col].data_left = len;
500 501
				}

502 503 504
				if (cbValueMax > 0)
				{
					copy_len = (len >= cbValueMax) ? cbValueMax - 1 : len;
505

506
					/* Copy the data */
507 508
					memcpy(rgbValueBindRow, ptr, copy_len);
					rgbValueBindRow[copy_len] = '\0';
509

510 511 512
					/* Adjust data_left for next time */
					if (stmt->current_col >= 0)
						stmt->bindings[stmt->current_col].data_left -= copy_len;
513 514
				}

515 516 517 518
				/*
				 * Finally, check for truncation so that proper status can
				 * be returned
				 */
519
				if (cbValueMax > 0 && len >= cbValueMax)
520
					result = COPY_RESULT_TRUNCATED;
521 522 523 524 525 526 527 528
				else
				{
					if (tempBuf)
					{
						free(tempBuf);
						tempBuf = NULL;
					}
				}
529 530


531 532
				mylog("    SQL_C_CHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
				break;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
533
		}
534 535


536 537 538
	}
	else
	{
539

540 541 542 543 544
		/*
		 * for SQL_C_CHAR, it's probably ok to leave currency symbols in.
		 * But to convert to numeric types, it is necessary to get rid of
		 * those.
		 */
Byron Nikolaidis's avatar
Byron Nikolaidis committed
545 546 547
		if (field_type == PG_TYPE_MONEY)
			convert_money(value);

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
		switch (fCType)
		{
			case SQL_C_DATE:
				len = 6;
				{
					DATE_STRUCT *ds;

					if (bind_size > 0)
						ds = (DATE_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
					else
						ds = (DATE_STRUCT *) rgbValue + bind_row;
					ds->year = st.y;
					ds->month = st.m;
					ds->day = st.d;
				}
				break;
564

565 566 567 568 569 570 571 572 573 574 575 576 577 578
			case SQL_C_TIME:
				len = 6;
				{
					TIME_STRUCT *ts;

					if (bind_size > 0)
						ts = (TIME_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
					else
						ts = (TIME_STRUCT *) rgbValue + bind_row;
					ts->hour = st.hh;
					ts->minute = st.mm;
					ts->second = st.ss;
				}
				break;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
579

580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
			case SQL_C_TIMESTAMP:
				len = 16;
				{
					TIMESTAMP_STRUCT *ts;

					if (bind_size > 0)
						ts = (TIMESTAMP_STRUCT *) ((char *) rgbValue + (bind_row * bind_size));
					else
						ts = (TIMESTAMP_STRUCT *) rgbValue + bind_row;
					ts->year = st.y;
					ts->month = st.m;
					ts->day = st.d;
					ts->hour = st.hh;
					ts->minute = st.mm;
					ts->second = st.ss;
					ts->fraction = 0;
				}
				break;
598

599 600 601 602 603 604
			case SQL_C_BIT:
				len = 1;
				if (bind_size > 0)
					*(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
				else
					*((UCHAR *) rgbValue + bind_row) = atoi(value);
605

606 607 608 609 610
				/*
				 * mylog("SQL_C_BIT: val = %d, cb = %d, rgb=%d\n",
				 * atoi(value), cbValueMax, *((UCHAR *)rgbValue));
				 */
				break;
611

612 613 614 615 616 617 618 619
			case SQL_C_STINYINT:
			case SQL_C_TINYINT:
				len = 1;
				if (bind_size > 0)
					*(SCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
				else
					*((SCHAR *) rgbValue + bind_row) = atoi(value);
				break;
620

621 622 623 624 625 626 627
			case SQL_C_UTINYINT:
				len = 1;
				if (bind_size > 0)
					*(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
				else
					*((UCHAR *) rgbValue + bind_row) = atoi(value);
				break;
628

629 630 631 632 633 634 635
			case SQL_C_FLOAT:
				len = 4;
				if (bind_size > 0)
					*(SFLOAT *) ((char *) rgbValue + (bind_row * bind_size)) = (float) atof(value);
				else
					*((SFLOAT *) rgbValue + bind_row) = (float) atof(value);
				break;
636

637 638 639 640 641 642 643
			case SQL_C_DOUBLE:
				len = 8;
				if (bind_size > 0)
					*(SDOUBLE *) ((char *) rgbValue + (bind_row * bind_size)) = atof(value);
				else
					*((SDOUBLE *) rgbValue + bind_row) = atof(value);
				break;
644

645 646 647 648 649 650 651 652
			case SQL_C_SSHORT:
			case SQL_C_SHORT:
				len = 2;
				if (bind_size > 0)
					*(SWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
				else
					*((SWORD *) rgbValue + bind_row) = atoi(value);
				break;
653

654 655 656 657 658 659 660
			case SQL_C_USHORT:
				len = 2;
				if (bind_size > 0)
					*(UWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(value);
				else
					*((UWORD *) rgbValue + bind_row) = atoi(value);
				break;
661

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
			case SQL_C_SLONG:
			case SQL_C_LONG:
				len = 4;
				if (bind_size > 0)
					*(SDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(value);
				else
					*((SDWORD *) rgbValue + bind_row) = atol(value);
				break;

			case SQL_C_ULONG:
				len = 4;
				if (bind_size > 0)
					*(UDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(value);
				else
					*((UDWORD *) rgbValue + bind_row) = atol(value);
				break;
678

679
			case SQL_C_BINARY:
680

681 682
				/* truncate if necessary */
				/* convert octal escapes to bytes */
683

684 685 686 687 688 689
				if (len = strlen(value), len >= (int) tempBuflen)
				{
					tempBuf = realloc(tempBuf, len + 1);
					tempBuflen = len + 1;
				}
				len = convert_from_pgbinary(value, tempBuf, tempBuflen);
690
				ptr = tempBuf;
691

692 693 694 695
				if (stmt->current_col >= 0)
				{
					/* No more data left for this column */
					if (stmt->bindings[stmt->current_col].data_left == 0)
696 697 698
					{
						free(tempBuf);
						tempBuf = NULL;
699
						return COPY_NO_DATA_FOUND;
700
					}
701

702 703 704 705 706 707 708 709 710
					/*
					 * Second (or more) call to SQLGetData so move the
					 * pointer
					 */
					else if (stmt->bindings[stmt->current_col].data_left > 0)
					{
						ptr += len - stmt->bindings[stmt->current_col].data_left;
						len = stmt->bindings[stmt->current_col].data_left;
					}
711

712 713 714
					/* First call to SQLGetData so initialize data_left */
					else
						stmt->bindings[stmt->current_col].data_left = len;
715

716
				}
717

718 719 720
				if (cbValueMax > 0)
				{
					copy_len = (len > cbValueMax) ? cbValueMax : len;
721

722 723
					/* Copy the data */
					memcpy(rgbValueBindRow, ptr, copy_len);
724

725 726 727
					/* Adjust data_left for next time */
					if (stmt->current_col >= 0)
						stmt->bindings[stmt->current_col].data_left -= copy_len;
728
				}
729

730 731 732 733 734 735
				/*
				 * Finally, check for truncation so that proper status can
				 * be returned
				 */
				if (len > cbValueMax)
					result = COPY_RESULT_TRUNCATED;
736

737 738 739 740 741
				if (tempBuf)
				{
					free(tempBuf);
					tempBuf = NULL;
				}
742 743 744 745 746
				mylog("SQL_C_BINARY: len = %d, copy_len = %d\n", len, copy_len);
				break;

			default:
				return COPY_UNSUPPORTED_TYPE;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
747 748
		}
	}
749

750 751 752
	/* store the length of what was copied, if there's a place for it */
	if (pcbValue)
		*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = len;
753

754
	return result;
755

756 757
}

758

759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/*--------------------------------------------------------------------
 *	Functions/Macros to get rid of query size limit.
 *
 *	I always used the follwoing macros to convert from
 *	old_statement to new_statement.	 Please improve it
 *	if you have a better way.	Hiroshi 2001/05/22
 *--------------------------------------------------------------------
 */
#define	INIT_MIN_ALLOC	4096
static int enlarge_statement(StatementClass *stmt, unsigned int newsize)
{
	unsigned int	newalsize = INIT_MIN_ALLOC;
	static char *func = "enlarge_statement";

	if (stmt->stmt_size_limit > 0 && stmt->stmt_size_limit < (int) newsize)
	{
		stmt->errormsg = "Query buffer overflow in copy_statement_with_parameters";
		stmt->errornumber = STMT_EXEC_ERROR;
		SC_log_error(func, "", stmt);
		return -1;
	}
	while (newalsize <= newsize)
		newalsize *= 2;
	if (!(stmt->stmt_with_params = realloc(stmt->stmt_with_params, newalsize)))
	{
		stmt->errormsg = "Query buffer allocate error in copy_statement_with_parameters";
		stmt->errornumber = STMT_EXEC_ERROR;
		SC_log_error(func, "", stmt);
		return 0;
	}
	return newalsize;
}

/*----------
 *	Enlarge stmt_with_params if necessary.
 *----------
 */
#define	ENLARGE_NEWSTATEMENT(newpos) \
	if (newpos >= new_stsize) \
	{ \
		if ((new_stsize = enlarge_statement(stmt, newpos)) <= 0) \
			return SQL_ERROR; \
		new_statement = stmt->stmt_with_params; \
	}
/*----------
 *	Initialize stmt_with_params, new_statement etc.
 *----------
 */
#define	CVT_INIT(size) \
{ \
	if (stmt->stmt_with_params) \
		free(stmt->stmt_with_params); \
	if (stmt->stmt_size_limit > 0) \
		new_stsize = stmt->stmt_size_limit; \
	else \
	{ \
		new_stsize = INIT_MIN_ALLOC; \
		while (new_stsize <= size) \
			new_stsize *= 2; \
	} \
	new_statement = malloc(new_stsize); \
	stmt->stmt_with_params = new_statement; \
	npos = 0; \
	new_statement[0] = '\0'; \
}
/*----------
 *	Terminate the stmt_with_params string with NULL.
 *----------
 */
#define	CVT_TERMINATE { new_statement[npos] = '\0'; }

/*----------
 *	Append a data.
 *----------
 */
#define	CVT_APPEND_DATA(s, len) \
{ \
	unsigned int	newpos = npos + len; \
	ENLARGE_NEWSTATEMENT(newpos) \
	memcpy(&new_statement[npos], s, len); \
	npos = newpos; \
	new_statement[npos] = '\0'; \
}
/*----------
 *	Append a string.
 *----------
 */
#define	CVT_APPEND_STR(s) \
{ \
	unsigned int len = strlen(s); \
	CVT_APPEND_DATA(s, len); \
}
/*----------
 *	Append a char.	
 *----------
 */
#define	CVT_APPEND_CHAR(c) \
{ \
	ENLARGE_NEWSTATEMENT(npos + 1); \
	new_statement[npos++] = c; \
}
/*----------
 *	Append a binary data.
 *	Newly reqeuired size may be overestimated currently. 
 *----------
 */
#define	CVT_APPEND_BINARY(buf, used) \
{ \
	unsigned int	newlimit = npos + 5 * used; \
	ENLARGE_NEWSTATEMENT(newlimit); \
	npos += convert_to_pgbinary(buf, &new_statement[npos], used); \
}
/*----------
 *
 *----------
 */
#define	CVT_SPECIAL_CHARS(buf, used) \
{ \
	int	cnvlen = convert_special_chars(buf, NULL, used); \
	unsigned int	newlimit = npos + cnvlen; \
\
	ENLARGE_NEWSTATEMENT(newlimit); \
	convert_special_chars(buf, &new_statement[npos], used); \
	npos += cnvlen; \
}

/*----------
 *	Check if the statement is	
 *	SELECT ... INTO table FROM .....
 *	This isn't really a strict check but ...
 *---------- 
 */
static BOOL
into_table_from(const char *stmt)
{
	if (strnicmp(stmt, "into", 4))
		return FALSE;
	stmt += 4;
	if (!isspace((unsigned char) *stmt))
		return FALSE;
	while (isspace((unsigned char) *(++stmt)));
	switch (*stmt)
	{
		case '\0':
		case ',':
		case '\'':
			return FALSE;
		case '\"': /* double quoted table name ? */
			do
			{
				do
				{
					 while (*(++stmt) != '\"' && *stmt);
				}
				while (*stmt && *(++stmt) == '\"');
				while (*stmt && !isspace((unsigned char) *stmt) && *stmt != '\"') stmt++;
			}
			while (*stmt == '\"');
			break;
		default:
			while (!isspace((unsigned char) *(++stmt)));
			break;
	}
	if (! *stmt)
		return FALSE;
	while (isspace((unsigned char) *(++stmt)));
	if (strnicmp(stmt, "from", 4))
		return FALSE;
	return isspace((unsigned char) stmt[4]);
}

930 931 932
/*
 *	This function inserts parameters into an SQL statements.
 *	It will also modify a SELECT statement for use with declare/fetch cursors.
933
 *	This function does a dynamic memory allocation to get rid of query siz elimit!
934
 */
935
int
Bruce Momjian's avatar
Bruce Momjian committed
936
copy_statement_with_parameters(StatementClass *stmt)
937
{
938 939 940 941 942 943
	static char *func = "copy_statement_with_parameters";
	unsigned int opos,
				npos,
				oldstmtlen;
	char		param_string[128],
				tmp[256],
944
				cbuf[PG_NUMERIC_MAX_PRECISION * 2]; /* seems big enough to handle the data in this function */
945 946 947
	int			param_number;
	Int2		param_ctype,
				param_sqltype;
948
	char	   *old_statement = stmt->statement, oldchar;
949
	char	   *new_statement = stmt->stmt_with_params;
950
	unsigned int	new_stsize = 0;
951 952 953 954 955 956
	SIMPLE_TIME st;
	time_t		t = time(NULL);
	struct tm  *tim;
	SDWORD		used;
	char	   *buffer,
			   *buf;
957
	BOOL		in_quote = FALSE, in_dquote = FALSE, in_escape = FALSE;
958 959 960
	Oid			lobj_oid;
	int			lobj_fd,
				retval;
961 962
	BOOL	check_select_into = FALSE; /* select into check */
	unsigned int	declare_pos;
963 964 965 966


	if (!old_statement)
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
967
		SC_log_error(func, "No statement string", stmt);
968
		return SQL_ERROR;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
969
	}
970

971 972
	memset(&st, 0, sizeof(SIMPLE_TIME));

973
	/* Initialize current date */
974 975 976 977 978
	tim = localtime(&t);
	st.m = tim->tm_mon + 1;
	st.d = tim->tm_mday;
	st.y = tim->tm_year + 1900;

979 980
	/* If the application hasn't set a cursor name, then generate one */
	if (stmt->cursor_name[0] == '\0')
981
		sprintf(stmt->cursor_name, "SQL_CUR%p", stmt);
982

983 984
	oldstmtlen = strlen(old_statement);
	CVT_INIT(oldstmtlen);
985 986 987
	/* For selects, prepend a declare cursor to the statement */
	if (stmt->statement_type == STMT_TYPE_SELECT && globals.use_declarefetch)
	{
988
		sprintf(new_statement, "declare %s cursor for ", stmt->cursor_name);
989
		npos = strlen(new_statement);
990 991
		check_select_into = TRUE;
		declare_pos = npos;
992 993
	}

994
	param_number = -1;
995

Hiroshi Inoue's avatar
Hiroshi Inoue committed
996
#ifdef MULTIBYTE
997
	multibyte_init();
Hiroshi Inoue's avatar
Hiroshi Inoue committed
998
#endif
999

1000 1001
	for (opos = 0; opos < oldstmtlen; opos++)
	{
1002
		oldchar = old_statement[opos];
1003
#ifdef MULTIBYTE
1004
		if (multibyte_char_check(oldchar) != 0)
1005
		{
1006
			CVT_APPEND_CHAR(oldchar);
1007 1008 1009 1010 1011 1012 1013
			continue;
		}
		/*
		 *	From here we are guaranteed to handle a
		 *	1-byte character.
		 */
#endif
1014

1015
		if (in_escape) /* escape check */
1016 1017
		{
			in_escape = FALSE;
1018
			CVT_APPEND_CHAR(oldchar);
1019 1020 1021 1022
			continue;
		}	
		else if (in_quote || in_dquote) /* quote/double quote check */
		{
1023 1024 1025
			if (oldchar == '\\')
				in_escape = TRUE;
			else if (oldchar == '\'' && in_quote)
1026
				in_quote = FALSE;
1027
			else if (oldchar == '\"' && in_dquote)
1028
				in_dquote = FALSE;
1029
			CVT_APPEND_CHAR(oldchar);
1030 1031 1032 1033
			continue;	
		}
		/*
		 *	From here we are guranteed to be in neither
1034
		 *	an escape, a quote nor a double quote.
1035
		 */
1036 1037 1038 1039
		/* Squeeze carriage-return/linefeed pairs to linefeed only */
		else if (oldchar == '\r' && opos + 1 < oldstmtlen &&
			old_statement[opos + 1] == '\n')
			continue;
1040 1041 1042 1043
		/*
		 * Handle literals (date, time, timestamp) and ODBC scalar
		 * functions
		 */
1044
		else if (oldchar == '{')
1045 1046 1047 1048
		{
			char	   *esc;
			char	   *begin = &old_statement[opos + 1];

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1049
#ifdef MULTIBYTE
1050
			char	   *end = multibyte_strchr(begin, '}');
1051

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1052
#else
1053
			char	   *end = strchr(begin, '}');
1054

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1055
#endif
1056

1057
			if (!end)
1058
				continue;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
			/* procedure calls */
			if (stmt->statement_type == STMT_TYPE_PROCCALL)
			{
				while (isspace((unsigned char) old_statement[++opos]));
				if (old_statement[opos] == '?')
				{
					param_number++;
					while (isspace((unsigned char) old_statement[++opos]));
					if (old_statement[opos] != '=')
					{
						opos--;
						continue;
					}
					while (isspace((unsigned char) old_statement[++opos]));
				}
				if (strnicmp(&old_statement[opos], "call", 4))
				{
					opos--;
					continue;
				}
				opos += (4 - 1);
				CVT_APPEND_STR("SELECT");
				continue; 
			}
1083 1084 1085
			*end = '\0';

			esc = convert_escape(begin);
1086 1087
			if (esc)
			{
1088
				CVT_APPEND_STR(esc);
1089
			}
1090 1091 1092
			else
			{					/* it's not a valid literal so just copy */
				*end = '}';
1093
				CVT_APPEND_CHAR(oldchar);
1094 1095
				continue;
			}
1096

1097
			opos += end - begin + 1;
1098 1099 1100
			*end = '}';
			continue;
		}
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1101 1102 1103
		/* End of a procedure call */
		else if (oldchar == '}' && stmt->statement_type == STMT_TYPE_PROCCALL)
			continue;
1104

1105 1106 1107 1108 1109
		/*
		 * Can you have parameter markers inside of quotes?  I dont think
		 * so. All the queries I've seen expect the driver to put quotes
		 * if needed.
		 */
1110
		else if (oldchar == '?')
1111 1112 1113
			;					/* ok */
		else
		{
1114
			if (oldchar == '\'')
1115
				in_quote = TRUE;
1116
			else if (oldchar == '\\')
1117
				in_escape = TRUE;
1118
			else if (oldchar == '\"')
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
				in_dquote = TRUE;
			else if (check_select_into && /* select into check */
    				 opos > 0 &&
    				 isspace((unsigned char) old_statement[opos - 1]) &&
    				 into_table_from(&old_statement[opos]))
			{
				stmt->statement_type = STMT_TYPE_CREATE;
				memmove(new_statement, new_statement + declare_pos, npos - declare_pos);
				npos -= declare_pos;
			}
1129
			CVT_APPEND_CHAR(oldchar);
1130 1131 1132
			continue;
		}

1133 1134 1135
		/*
		 * Its a '?' parameter alright
		 */
1136 1137
		param_number++;

1138
		if (param_number >= stmt->parameters_allocated)
1139 1140 1141
		{
			if (stmt->pre_executing)
			{
1142
				CVT_APPEND_STR("NULL");
1143 1144 1145 1146 1147
				stmt->inaccurate_result = TRUE;
				continue;
			}
			else
			{
1148
				CVT_APPEND_CHAR('?');
1149 1150 1151
				continue;
			}
		}
1152

1153 1154 1155
		/* Assign correct buffers based on data at exec param or not */
		if (stmt->parameters[param_number].data_at_exec)
		{
1156 1157 1158
			used = stmt->parameters[param_number].EXEC_used ? *stmt->parameters[param_number].EXEC_used : SQL_NTS;
			buffer = stmt->parameters[param_number].EXEC_buffer;
		}
1159 1160
		else
		{
1161 1162 1163 1164
			used = stmt->parameters[param_number].used ? *stmt->parameters[param_number].used : SQL_NTS;
			buffer = stmt->parameters[param_number].buffer;
		}

1165 1166 1167
		/* Handle NULL parameter data */
		if (used == SQL_NULL_DATA)
		{
1168
			CVT_APPEND_STR("NULL");
1169 1170 1171
			continue;
		}

1172 1173 1174 1175 1176 1177
		/*
		 * If no buffer, and it's not null, then what the hell is it? Just
		 * leave it alone then.
		 */
		if (!buffer)
		{
1178 1179
			if (stmt->pre_executing)
			{
1180
				CVT_APPEND_STR("NULL");
1181 1182 1183 1184 1185
				stmt->inaccurate_result = TRUE;
				continue;
			}
			else
			{
1186
				CVT_APPEND_CHAR('?');
1187 1188
				continue;
			}
1189
		}
1190 1191 1192

		param_ctype = stmt->parameters[param_number].CType;
		param_sqltype = stmt->parameters[param_number].SQLType;
1193

1194
		mylog("copy_statement_with_params: from(fcType)=%d, to(fSqlType)=%d\n", param_ctype, param_sqltype);
1195

1196
		/* replace DEFAULT with something we can use */
1197
		if (param_ctype == SQL_C_DEFAULT)
1198 1199 1200 1201 1202 1203
			param_ctype = sqltype_to_default_ctype(param_sqltype);

		buf = NULL;
		param_string[0] = '\0';
		cbuf[0] = '\0';

1204 1205 1206 1207 1208 1209 1210
		/* Convert input C type to a neutral format */
		switch (param_ctype)
		{
			case SQL_C_BINARY:
			case SQL_C_CHAR:
				buf = buffer;
				break;
1211

1212
			case SQL_C_DOUBLE:
1213
				sprintf(param_string, "%.15g",
1214 1215
						*((SDOUBLE *) buffer));
				break;
1216

1217
			case SQL_C_FLOAT:
1218
				sprintf(param_string, "%.6g",
1219 1220
						*((SFLOAT *) buffer));
				break;
1221

1222 1223 1224 1225 1226
			case SQL_C_SLONG:
			case SQL_C_LONG:
				sprintf(param_string, "%ld",
						*((SDWORD *) buffer));
				break;
1227

1228 1229 1230 1231 1232
			case SQL_C_SSHORT:
			case SQL_C_SHORT:
				sprintf(param_string, "%d",
						*((SWORD *) buffer));
				break;
1233

1234 1235 1236 1237 1238
			case SQL_C_STINYINT:
			case SQL_C_TINYINT:
				sprintf(param_string, "%d",
						*((SCHAR *) buffer));
				break;
1239

1240 1241 1242 1243
			case SQL_C_ULONG:
				sprintf(param_string, "%lu",
						*((UDWORD *) buffer));
				break;
1244

1245 1246 1247 1248
			case SQL_C_USHORT:
				sprintf(param_string, "%u",
						*((UWORD *) buffer));
				break;
1249

1250 1251 1252 1253
			case SQL_C_UTINYINT:
				sprintf(param_string, "%u",
						*((UCHAR *) buffer));
				break;
1254

1255 1256 1257
			case SQL_C_BIT:
				{
					int			i = *((UCHAR *) buffer);
1258

1259 1260 1261
					sprintf(param_string, "%d", i ? 1 : 0);
					break;
				}
1262

1263 1264 1265
			case SQL_C_DATE:
				{
					DATE_STRUCT *ds = (DATE_STRUCT *) buffer;
1266

1267 1268 1269
					st.m = ds->month;
					st.d = ds->day;
					st.y = ds->year;
1270

1271 1272
					break;
				}
1273

1274 1275 1276
			case SQL_C_TIME:
				{
					TIME_STRUCT *ts = (TIME_STRUCT *) buffer;
1277

1278 1279 1280
					st.hh = ts->hour;
					st.mm = ts->minute;
					st.ss = ts->second;
1281

1282 1283
					break;
				}
1284

1285 1286 1287
			case SQL_C_TIMESTAMP:
				{
					TIMESTAMP_STRUCT *tss = (TIMESTAMP_STRUCT *) buffer;
1288

1289 1290 1291 1292 1293 1294
					st.m = tss->month;
					st.d = tss->day;
					st.y = tss->year;
					st.hh = tss->hour;
					st.mm = tss->minute;
					st.ss = tss->second;
1295

1296
					mylog("m=%d,d=%d,y=%d,hh=%d,mm=%d,ss=%d\n", st.m, st.d, st.y, st.hh, st.mm, st.ss);
1297

1298
					break;
1299

1300 1301 1302 1303 1304
				}
			default:
				/* error */
				stmt->errormsg = "Unrecognized C_parameter type in copy_statement_with_parameters";
				stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
1305
				CVT_TERMINATE	/* just in case */
1306 1307 1308
				SC_log_error(func, "", stmt);
				return SQL_ERROR;
		}
1309

1310 1311 1312 1313
		/*
		 * Now that the input data is in a neutral format, convert it to
		 * the desired output format (sqltype)
		 */
1314

1315 1316 1317 1318 1319
		switch (param_sqltype)
		{
			case SQL_CHAR:
			case SQL_VARCHAR:
			case SQL_LONGVARCHAR:
1320

1321
				CVT_APPEND_CHAR('\'');	/* Open Quote */
1322

1323 1324 1325
				/* it was a SQL_C_CHAR */
				if (buf)
				{
1326
					CVT_SPECIAL_CHARS(buf, used);
1327
				}
1328

1329 1330 1331
				/* it was a numeric type */
				else if (param_string[0] != '\0')
				{
1332
					CVT_APPEND_STR(param_string);
1333
				}
1334

1335 1336 1337 1338 1339
				/* it was date,time,timestamp -- use m,d,y,hh,mm,ss */
				else
				{
					sprintf(tmp, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
							st.y, st.m, st.d, st.hh, st.mm, st.ss);
1340

1341
					CVT_APPEND_STR(tmp);
1342
				}
1343

1344
				CVT_APPEND_CHAR('\'');	/* Close Quote */
1345

1346
				break;
1347

1348 1349 1350 1351 1352 1353
			case SQL_DATE:
				if (buf)
				{				/* copy char data to time */
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1354

1355
				sprintf(tmp, "'%.4d-%.2d-%.2d'", st.y, st.m, st.d);
1356

1357
				CVT_APPEND_STR(tmp);
1358
				break;
1359

1360 1361 1362 1363 1364 1365
			case SQL_TIME:
				if (buf)
				{				/* copy char data to time */
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1366

1367
				sprintf(tmp, "'%.2d:%.2d:%.2d'", st.hh, st.mm, st.ss);
1368

1369
				CVT_APPEND_STR(tmp);
1370
				break;
1371

1372
			case SQL_TIMESTAMP:
1373

1374 1375 1376 1377 1378
				if (buf)
				{
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1379

1380 1381
				sprintf(tmp, "'%.4d-%.2d-%.2d %.2d:%.2d:%.2d'",
						st.y, st.m, st.d, st.hh, st.mm, st.ss);
1382

1383
				CVT_APPEND_STR(tmp);
1384

1385
				break;
1386

1387 1388 1389
			case SQL_BINARY:
			case SQL_VARBINARY:/* non-ascii characters should be
								 * converted to octal */
1390
				CVT_APPEND_CHAR('\'');	/* Open Quote */
1391

1392
				mylog("SQL_VARBINARY: about to call convert_to_pgbinary, used = %d\n", used);
1393

1394
				CVT_APPEND_BINARY(buf, used);
1395

1396
				CVT_APPEND_CHAR('\'');	/* Close Quote */
1397

1398
				break;
1399

1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
			case SQL_LONGVARBINARY:

				if (stmt->parameters[param_number].data_at_exec)
					lobj_oid = stmt->parameters[param_number].lobj_oid;
				else
				{
					/* begin transaction if needed */
					if (!CC_is_in_trans(stmt->hdbc))
					{
						QResultClass *res;
						char		ok;

						res = CC_send_query(stmt->hdbc, "BEGIN", NULL);
						if (!res)
						{
							stmt->errormsg = "Could not begin (in-line) a transaction";
							stmt->errornumber = STMT_EXEC_ERROR;
							SC_log_error(func, "", stmt);
							return SQL_ERROR;
						}
						ok = QR_command_successful(res);
						QR_Destructor(res);
						if (!ok)
						{
							stmt->errormsg = "Could not begin (in-line) a transaction";
							stmt->errornumber = STMT_EXEC_ERROR;
							SC_log_error(func, "", stmt);
							return SQL_ERROR;
						}
1429

1430 1431
						CC_set_in_trans(stmt->hdbc);
					}
1432

1433 1434 1435 1436
					/* store the oid */
					lobj_oid = lo_creat(stmt->hdbc, INV_READ | INV_WRITE);
					if (lobj_oid == 0)
					{
1437
						stmt->errornumber = STMT_EXEC_ERROR;
1438
						stmt->errormsg = "Couldnt create (in-line) large object.";
1439 1440 1441
						SC_log_error(func, "", stmt);
						return SQL_ERROR;
					}
1442 1443 1444 1445 1446

					/* store the fd */
					lobj_fd = lo_open(stmt->hdbc, lobj_oid, INV_WRITE);
					if (lobj_fd < 0)
					{
1447
						stmt->errornumber = STMT_EXEC_ERROR;
1448
						stmt->errormsg = "Couldnt open (in-line) large object for writing.";
1449 1450 1451 1452
						SC_log_error(func, "", stmt);
						return SQL_ERROR;
					}

1453
					retval = lo_write(stmt->hdbc, lobj_fd, buffer, used);
1454

1455
					lo_close(stmt->hdbc, lobj_fd);
1456

1457 1458 1459 1460 1461
					/* commit transaction if needed */
					if (!globals.use_declarefetch && CC_is_in_autocommit(stmt->hdbc))
					{
						QResultClass *res;
						char		ok;
1462

1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
						res = CC_send_query(stmt->hdbc, "COMMIT", NULL);
						if (!res)
						{
							stmt->errormsg = "Could not commit (in-line) a transaction";
							stmt->errornumber = STMT_EXEC_ERROR;
							SC_log_error(func, "", stmt);
							return SQL_ERROR;
						}
						ok = QR_command_successful(res);
						QR_Destructor(res);
						if (!ok)
						{
							stmt->errormsg = "Could not commit (in-line) a transaction";
							stmt->errornumber = STMT_EXEC_ERROR;
							SC_log_error(func, "", stmt);
							return SQL_ERROR;
						}
1480

1481 1482 1483
						CC_set_no_trans(stmt->hdbc);
					}
				}
1484

1485 1486 1487 1488 1489 1490
				/*
				 * the oid of the large object -- just put that in for the
				 * parameter marker -- the data has already been sent to
				 * the large object
				 */
				sprintf(param_string, "'%d'", lobj_oid);
1491
				CVT_APPEND_STR(param_string);
1492

1493 1494 1495 1496 1497 1498 1499
				break;

				/*
				 * because of no conversion operator for bool and int4,
				 * SQL_BIT
				 */
				/* must be quoted (0 or 1 is ok to use inside the quotes) */
1500

1501 1502 1503 1504
			case SQL_REAL:
				if (buf)
					my_strcpy(param_string, sizeof(param_string), buf, used);
				sprintf(tmp, "'%s'::float4", param_string);
1505
				CVT_APPEND_STR(tmp);
1506 1507 1508 1509 1510 1511
				break;
			case SQL_FLOAT:
			case SQL_DOUBLE:
				if (buf)
					my_strcpy(param_string, sizeof(param_string), buf, used);
				sprintf(tmp, "'%s'::float8", param_string);
1512
				CVT_APPEND_STR(tmp);
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
				break;
			case SQL_NUMERIC:
				if (buf)
				{
					cbuf[0] = '\'';
					my_strcpy(cbuf + 1, sizeof(cbuf) - 12, buf, used);	/* 12 = 1('\'') +
																		 * strlen("'::numeric")
																		 * + 1('\0') */
					strcat(cbuf, "'::numeric");
				}
				else
					sprintf(cbuf, "'%s'::numeric", param_string);
1525
				CVT_APPEND_STR(cbuf);
1526 1527 1528
				break;
			default:			/* a numeric type or SQL_BIT */
				if (param_sqltype == SQL_BIT)
1529
					CVT_APPEND_CHAR('\'');		/* Open Quote */
1530 1531 1532

				if (buf)
				{
1533
					CVT_APPEND_DATA(buf, used);
1534 1535 1536
				}
				else
				{
1537
					CVT_APPEND_STR(param_string);
1538 1539 1540
				}

				if (param_sqltype == SQL_BIT)
1541
					CVT_APPEND_CHAR('\'');		/* Close Quote */
1542 1543

				break;
1544
		}
1545
	}							/* end, for */
1546

1547
	/* make sure new_statement is always null-terminated */
1548
	CVT_TERMINATE
1549

1550 1551 1552 1553 1554 1555 1556 1557 1558
	if (stmt->hdbc->DriverToDataSource != NULL)
	{
		int			length = strlen(new_statement);

		stmt->hdbc->DriverToDataSource(stmt->hdbc->translation_option,
									   SQL_CHAR,
									   new_statement, length,
									   new_statement, length, NULL,
									   NULL, 0, NULL);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1559 1560
	}

1561 1562 1563
	return SQL_SUCCESS;
}

1564

1565 1566 1567
char *
mapFunction(char *func)
{
1568
	int			i;
1569 1570

	for (i = 0; mapFuncs[i][0]; i++)
1571
		if (!stricmp(mapFuncs[i][0], func))
1572 1573 1574 1575
			return mapFuncs[i][1];

	return NULL;
}
1576

1577 1578 1579 1580

/*
 * convert_escape()
 *
1581 1582
 * This function returns a pointer to static memory!
 */
1583 1584 1585
char *
convert_escape(char *value)
{
1586 1587
	static char escape[1024];
	char		key[33];
1588

1589
	/* Separate off the key, skipping leading and trailing whitespace */
1590 1591
	while ((*value != '\0') && isspace((unsigned char) *value))
		value++;
1592
	sscanf(value, "%32s", key);
1593 1594 1595 1596
	while ((*value != '\0') && (!isspace((unsigned char) *value)))
		value++;
	while ((*value != '\0') && isspace((unsigned char) *value))
		value++;
1597

1598
	mylog("convert_escape: key='%s', val='%s'\n", key, value);
1599

1600 1601
	if ((strcmp(key, "d") == 0) ||
		(strcmp(key, "t") == 0) ||
1602 1603
		(strcmp(key, "oj") == 0) ||		/* {oj syntax support for 7.1
										 * servers */
1604 1605
		(strcmp(key, "ts") == 0))
	{
1606
		/* Literal; return the escape part as-is */
1607
		strncpy(escape, value, sizeof(escape) - 1);
1608
	}
1609 1610
	else if (strcmp(key, "fn") == 0)
	{
1611

1612 1613 1614
		/*
		 * Function invocation Separate off the func name, skipping
		 * trailing whitespace.
1615
		 */
1616 1617 1618
		char	   *funcEnd = value;
		char		svchar;
		char	   *mapFunc;
1619 1620

		while ((*funcEnd != '\0') && (*funcEnd != '(') &&
1621
			   (!isspace((unsigned char) *funcEnd)))
1622
			funcEnd++;
1623 1624 1625 1626
		svchar = *funcEnd;
		*funcEnd = '\0';
		sscanf(value, "%32s", key);
		*funcEnd = svchar;
1627 1628
		while ((*funcEnd != '\0') && isspace((unsigned char) *funcEnd))
			funcEnd++;
1629

1630 1631 1632
		/*
		 * We expect left parenthesis here, else return fn body as-is
		 * since it is one of those "function constants".
1633
		 */
1634 1635 1636
		if (*funcEnd != '(')
		{
			strncpy(escape, value, sizeof(escape) - 1);
1637
			return escape;
1638
		}
1639
		mapFunc = mapFunction(key);
1640 1641 1642 1643

		/*
		 * We could have mapFunction() return key if not in table... -
		 * thomas 2000-04-03
1644
		 */
1645 1646
		if (mapFunc == NULL)
		{
1647
			/* If unrecognized function name, return fn body as-is */
1648
			strncpy(escape, value, sizeof(escape) - 1);
1649 1650 1651 1652
			return escape;
		}
		/* copy mapped name and remaining input string */
		strcpy(escape, mapFunc);
1653
		strncat(escape, funcEnd, sizeof(escape) - 1 - strlen(mapFunc));
1654
	}
1655 1656
	else
	{
1657
		/* Bogus key, leave untranslated */
1658 1659 1660 1661 1662 1663 1664 1665 1666 1667
		return NULL;
	}

	return escape;
}


char *
convert_money(char *s)
{
1668 1669
	size_t		i = 0,
				out = 0;
1670

1671 1672
	for (i = 0; i < strlen(s); i++)
	{
1673
		if (s[i] == '$' || s[i] == ',' || s[i] == ')')
1674
			;					/* skip these characters */
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
		else if (s[i] == '(')
			s[out++] = '-';
		else
			s[out++] = s[i];
	}
	s[out] = '\0';
	return s;
}


1685 1686 1687 1688
/*
 *	This function parses a character string for date/time info and fills in SIMPLE_TIME
 *	It does not zero out SIMPLE_TIME in case it is desired to initialize it with a value
 */
1689
char
Bruce Momjian's avatar
Bruce Momjian committed
1690
parse_datetime(char *buf, SIMPLE_TIME *st)
1691
{
1692 1693 1694 1695 1696 1697 1698 1699
	int			y,
				m,
				d,
				hh,
				mm,
				ss;
	int			nf;

1700 1701
	y = m = d = hh = mm = ss = 0;

1702 1703
	if (buf[4] == '-')			/* year first */
		nf = sscanf(buf, "%4d-%2d-%2d %2d:%2d:%2d", &y, &m, &d, &hh, &mm, &ss);
1704
	else
1705
		nf = sscanf(buf, "%2d-%2d-%4d %2d:%2d:%2d", &m, &d, &y, &hh, &mm, &ss);
1706

1707 1708
	if (nf == 5 || nf == 6)
	{
1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
		st->y = y;
		st->m = m;
		st->d = d;
		st->hh = hh;
		st->mm = mm;
		st->ss = ss;

		return TRUE;
	}

1719
	if (buf[4] == '-')			/* year first */
1720 1721 1722 1723
		nf = sscanf(buf, "%4d-%2d-%2d", &y, &m, &d);
	else
		nf = sscanf(buf, "%2d-%2d-%4d", &m, &d, &y);

1724 1725
	if (nf == 3)
	{
1726 1727 1728 1729 1730 1731 1732 1733
		st->y = y;
		st->m = m;
		st->d = d;

		return TRUE;
	}

	nf = sscanf(buf, "%2d:%2d:%2d", &hh, &mm, &ss);
1734 1735
	if (nf == 2 || nf == 3)
	{
1736 1737 1738 1739 1740 1741 1742 1743 1744
		st->hh = hh;
		st->mm = mm;
		st->ss = ss;

		return TRUE;
	}

	return FALSE;
}
1745

1746

1747
/*	Change linefeed to carriage-return/linefeed */
1748
int
1749
convert_linefeeds(const char *si, char *dst, size_t max, BOOL *changed)
1750
{
1751 1752
	size_t		i = 0,
				out = 0;
1753

1754 1755 1756 1757
	if (max == 0)
		max = 0xffffffff;
	*changed = FALSE;
	for (i = 0; si[i] && out < max - 1; i++)
1758 1759 1760 1761 1762 1763
	{
		if (si[i] == '\n')
		{
			/* Only add the carriage-return if needed */
			if (i > 0 && si[i - 1] == '\r')
			{
1764 1765 1766 1767
				if (dst)
					dst[out++] = si[i];
				else
					out++;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1768 1769
				continue;
			}
1770
			*changed = TRUE;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1771

1772 1773 1774 1775 1776 1777 1778
			if (dst)
			{
				dst[out++] = '\r';
				dst[out++] = '\n';
			}
			else
				out += 2;
1779 1780
		}
		else
1781 1782 1783 1784 1785 1786
		{
			if (dst)
				dst[out++] = si[i];
			else
				out++;
		}
1787
	}
1788 1789
	if (dst)
		dst[out] = '\0';
1790
	return out;
1791 1792
}

1793 1794 1795 1796 1797

/*
 *	Change carriage-return/linefeed to just linefeed
 *	Plus, escape any special characters.
 */
1798
int
1799 1800
convert_special_chars(char *si, char *dst, int used)
{
1801 1802 1803
	size_t		i = 0,
				out = 0,
				max;
1804
	char	   *p = NULL;
1805 1806 1807 1808 1809 1810


	if (used == SQL_NTS)
		max = strlen(si);
	else
		max = used;
1811 1812 1813 1814 1815
	if (dst)
	{
		p = dst;
		p[0] = '\0';
	}
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1816 1817 1818
#ifdef MULTIBYTE
	multibyte_init();
#endif
1819

1820 1821
	for (i = 0; i < max; i++)
	{
1822
		if (si[i] == '\r' && si[i + 1] == '\n')
1823
			continue;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1824 1825 1826
#ifdef MULTIBYTE
		else if (multibyte_char_check(si[i]) == 0 && (si[i] == '\'' || si[i] == '\\'))
#else
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1827
		else if (si[i] == '\'' || si[i] == '\\')
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1828
#endif
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
		{
			if (p)
				p[out++] = '\\';
			else
				out++;
		}
		if (p)
			p[out++] = si[i];
		else
			out++;
1839
	}
1840 1841 1842
	if (p)
		p[out] = '\0';
	return out;
1843 1844
}

1845

1846 1847 1848 1849
/*	!!! Need to implement this function !!!  */
int
convert_pgbinary_to_char(char *value, char *rgbValue, int cbValueMax)
{
1850 1851 1852
	mylog("convert_pgbinary_to_char: value = '%s'\n", value);

	strncpy_null(rgbValue, value, cbValueMax);
1853 1854 1855
	return 0;
}

1856

1857 1858 1859
unsigned int
conv_from_octal(unsigned char *s)
{
1860 1861
	int			i,
				y = 0;
1862

1863 1864
	for (i = 1; i <= 3; i++)
		y += (s[i] - 48) * (int) pow(8, 3 - i);
1865 1866

	return y;
1867

1868 1869
}

1870

Byron Nikolaidis's avatar
Byron Nikolaidis committed
1871 1872 1873
unsigned int
conv_from_hex(unsigned char *s)
{
1874 1875 1876
	int			i,
				y = 0,
				val;
1877

1878 1879 1880 1881 1882 1883 1884 1885
	for (i = 1; i <= 2; i++)
	{
		if (s[i] >= 'a' && s[i] <= 'f')
			val = s[i] - 'a' + 10;
		else if (s[i] >= 'A' && s[i] <= 'F')
			val = s[i] - 'A' + 10;
		else
			val = s[i] - '0';
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1886

1887
		y += val * (int) pow(16, 2 - i);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1888 1889 1890 1891 1892
	}

	return y;
}

1893

1894
/*	convert octal escapes to bytes */
1895 1896 1897
int
convert_from_pgbinary(unsigned char *value, unsigned char *rgbValue, int cbValueMax)
{
1898
	size_t		i, ilen = strlen(value);
1899
	int			o = 0;
1900

1901

1902
	for (i = 0; i < ilen;)
1903 1904 1905
	{
		if (value[i] == '\\')
		{
1906 1907 1908
			rgbValue[o] = conv_from_octal(&value[i]);
			i += 4;
		}
1909
		else
1910 1911 1912 1913
			rgbValue[o] = value[i++];
		mylog("convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]);
		o++;
	}
1914

1915
	rgbValue[o] = '\0';			/* extra protection */
1916

1917 1918 1919 1920 1921 1922 1923
	return o;
}


char *
conv_to_octal(unsigned char val)
{
1924 1925
	int			i;
	static char x[6];
1926 1927 1928 1929 1930

	x[0] = '\\';
	x[1] = '\\';
	x[5] = '\0';

1931 1932
	for (i = 4; i > 1; i--)
	{
1933 1934 1935 1936 1937 1938 1939
		x[i] = (val & 7) + 48;
		val >>= 3;
	}

	return x;
}

1940

1941
/*	convert non-ascii bytes to octal escape sequences */
1942 1943 1944
int
convert_to_pgbinary(unsigned char *in, char *out, int len)
{
1945 1946
	int			i,
				o = 0;
1947

1948 1949
	for (i = 0; i < len; i++)
	{
1950
		mylog("convert_to_pgbinary: in[%d] = %d, %c\n", i, in[i], in[i]);
1951
		if (isalnum(in[i]) || in[i] == ' ')
1952
			out[o++] = in[i];
1953 1954 1955
		else
		{
			strcpy(&out[o], conv_to_octal(in[i]));
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
			o += 5;
		}
	}

	mylog("convert_to_pgbinary: returning %d, out='%.*s'\n", o, o, out);

	return o;
}


Byron Nikolaidis's avatar
Byron Nikolaidis committed
1966 1967 1968
void
encode(char *in, char *out)
{
1969
	unsigned int i, ilen = strlen(in),
1970
				o = 0;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1971

1972
	for (i = 0; i < ilen; i++)
1973 1974 1975
	{
		if (in[i] == '+')
		{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1976 1977 1978
			sprintf(&out[o], "%%2B");
			o += 3;
		}
1979
		else if (isspace((unsigned char) in[i]))
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1980
			out[o++] = '+';
1981 1982
		else if (!isalnum((unsigned char) in[i]))
		{
1983
			sprintf(&out[o], "%%%02x", (unsigned char) in[i]);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995
			o += 3;
		}
		else
			out[o++] = in[i];
	}
	out[o++] = '\0';
}


void
decode(char *in, char *out)
{
1996
	unsigned int i, ilen = strlen(in),
1997
				o = 0;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1998

1999
	for (i = 0; i < ilen; i++)
2000
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2001 2002
		if (in[i] == '+')
			out[o++] = ' ';
2003 2004
		else if (in[i] == '%')
		{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2005
			sprintf(&out[o++], "%c", conv_from_hex(&in[i]));
2006
			i += 2;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2007 2008 2009 2010 2011 2012 2013 2014
		}
		else
			out[o++] = in[i];
	}
	out[o++] = '\0';
}


2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
/*-------
 *	1. get oid (from 'value')
 *	2. open the large object
 *	3. read from the large object (handle multiple GetData)
 *	4. close when read less than requested?  -OR-
 *		lseek/read each time
 *		handle case where application receives truncated and
 *		decides not to continue reading.
 *
 *	CURRENTLY, ONLY LONGVARBINARY is handled, since that is the only
 *	data type currently mapped to a PG_TYPE_LO.  But, if any other types
 *	are desired to map to a large object (PG_TYPE_LO), then that would
 *	need to be handled here.  For example, LONGVARCHAR could possibly be
 *	mapped to PG_TYPE_LO someday, instead of PG_TYPE_TEXT as it is now.
 *-------
 */
2031
int
2032
convert_lo(StatementClass *stmt, void *value, Int2 fCType, PTR rgbValue,
Bruce Momjian's avatar
Bruce Momjian committed
2033
		   SDWORD cbValueMax, SDWORD *pcbValue)
2034
{
2035 2036 2037 2038
	Oid			oid;
	int			retval,
				result,
				left = -1;
Tom Lane's avatar
Tom Lane committed
2039
	BindInfoClass *bindInfo = NULL;
2040 2041


2042
	/* If using SQLGetData, then current_col will be set */
2043 2044
	if (stmt->current_col >= 0)
	{
2045 2046 2047
		bindInfo = &stmt->bindings[stmt->current_col];
		left = bindInfo->data_left;
	}
2048

2049 2050 2051 2052
	/*
	 * if this is the first call for this column, open the large object
	 * for reading
	 */
2053

2054 2055
	if (!bindInfo || bindInfo->data_left == -1)
	{
2056
		/* begin transaction if needed */
2057 2058
		if (!CC_is_in_trans(stmt->hdbc))
		{
2059
			QResultClass *res;
2060
			char		ok;
2061 2062

			res = CC_send_query(stmt->hdbc, "BEGIN", NULL);
2063 2064
			if (!res)
			{
2065 2066 2067 2068 2069 2070
				stmt->errormsg = "Could not begin (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}
			ok = QR_command_successful(res);
			QR_Destructor(res);
2071 2072
			if (!ok)
			{
2073 2074 2075 2076 2077 2078 2079 2080
				stmt->errormsg = "Could not begin (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

			CC_set_in_trans(stmt->hdbc);
		}

2081 2082
		oid = atoi(value);
		stmt->lobj_fd = lo_open(stmt->hdbc, oid, INV_READ);
2083 2084
		if (stmt->lobj_fd < 0)
		{
2085
			stmt->errornumber = STMT_EXEC_ERROR;
2086
			stmt->errormsg = "Couldnt open large object for reading.";
2087 2088
			return COPY_GENERAL_ERROR;
		}
2089

2090
		/* Get the size */
2091
		retval = lo_lseek(stmt->hdbc, stmt->lobj_fd, 0L, SEEK_END);
2092 2093
		if (retval >= 0)
		{
2094 2095 2096 2097
			left = lo_tell(stmt->hdbc, stmt->lobj_fd);
			if (bindInfo)
				bindInfo->data_left = left;

2098
			/* return to beginning */
2099 2100 2101 2102
			lo_lseek(stmt->hdbc, stmt->lobj_fd, 0L, SEEK_SET);
		}
	}

2103
	if (left == 0)
2104
		return COPY_NO_DATA_FOUND;
2105

2106 2107
	if (stmt->lobj_fd < 0)
	{
2108 2109 2110 2111
		stmt->errornumber = STMT_EXEC_ERROR;
		stmt->errormsg = "Large object FD undefined for multiple read.";
		return COPY_GENERAL_ERROR;
	}
2112

2113
	retval = lo_read(stmt->hdbc, stmt->lobj_fd, (char *) rgbValue, cbValueMax);
2114 2115
	if (retval < 0)
	{
2116
		lo_close(stmt->hdbc, stmt->lobj_fd);
2117 2118

		/* commit transaction if needed */
2119 2120
		if (!globals.use_declarefetch && CC_is_in_autocommit(stmt->hdbc))
		{
2121
			QResultClass *res;
2122
			char		ok;
2123 2124

			res = CC_send_query(stmt->hdbc, "COMMIT", NULL);
2125 2126
			if (!res)
			{
2127 2128 2129 2130 2131 2132
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}
			ok = QR_command_successful(res);
			QR_Destructor(res);
2133 2134
			if (!ok)
			{
2135 2136 2137 2138 2139 2140 2141 2142
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

			CC_set_no_trans(stmt->hdbc);
		}

2143 2144 2145 2146 2147 2148 2149
		stmt->lobj_fd = -1;

		stmt->errornumber = STMT_EXEC_ERROR;
		stmt->errormsg = "Error reading from large object.";
		return COPY_GENERAL_ERROR;
	}

2150 2151 2152 2153 2154 2155 2156
	if (retval < left)
		result = COPY_RESULT_TRUNCATED;
	else
		result = COPY_OK;

	if (pcbValue)
		*pcbValue = left < 0 ? SQL_NO_TOTAL : left;
2157

2158
	if (bindInfo && bindInfo->data_left > 0)
2159
		bindInfo->data_left -= retval;
2160

2161 2162
	if (!bindInfo || bindInfo->data_left == 0)
	{
2163
		lo_close(stmt->hdbc, stmt->lobj_fd);
2164 2165

		/* commit transaction if needed */
2166 2167
		if (!globals.use_declarefetch && CC_is_in_autocommit(stmt->hdbc))
		{
2168
			QResultClass *res;
2169
			char		ok;
2170 2171

			res = CC_send_query(stmt->hdbc, "COMMIT", NULL);
2172 2173
			if (!res)
			{
2174 2175 2176 2177 2178 2179
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}
			ok = QR_command_successful(res);
			QR_Destructor(res);
2180 2181
			if (!ok)
			{
2182 2183 2184 2185 2186 2187 2188 2189
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

			CC_set_no_trans(stmt->hdbc);
		}

2190
		stmt->lobj_fd = -1;		/* prevent further reading */
2191
	}
2192 2193

	return result;
2194
}