convert.c 53 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

20 21
#include "convert.h"

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

Hiroshi Inoue's avatar
Hiroshi Inoue committed
26 27 28 29
#ifdef MULTIBYTE
#include "multibyte.h"
#endif

30
#include <time.h>
31
#include <math.h>
32
#include <stdlib.h>
33
#include "statement.h"
34
#include "qresult.h"
35 36
#include "bind.h"
#include "pgtypes.h"
37 38
#include "lobj.h"
#include "connection.h"
39
#include "pgapifunc.h"
40 41


42 43 44 45
/*
 *	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
46
 *	- thomas 2000-04-03
47
 */
48 49 50 51
char	   *mapFuncs[][2] = {
/*	{ "ASCII",		 "ascii"	  }, */
	{"CHAR", "chr"},
	{"CONCAT", "textcat"},
52
/*	{ "DIFFERENCE",  "difference" }, */
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
/*	{ "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"	  }, */
95
/*	{ "DAYOFMONTH",  "dayofmonth" }, */
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
/*	{ "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}
112 113
};

114 115 116 117
static char   *mapFunction(const char *func);
static unsigned int conv_from_octal(const unsigned char *s);
static unsigned int conv_from_hex(const unsigned char *s);
static char	   *conv_to_octal(unsigned char val);
118

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
/*---------
 *			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
 *---------
 */
136 137 138 139 140



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

145 146
	return copy_and_convert_field(stmt, field_type, value, (Int2) bic->returntype, (PTR) bic->buffer,
							 (SDWORD) bic->buflen, (SDWORD *) bic->used);
147 148
}

149

150 151
/*	This is called by SQLGetData() */
int
152
copy_and_convert_field(StatementClass *stmt, Int4 field_type, void *value, Int2 fCType,
Bruce Momjian's avatar
Bruce Momjian committed
153
					   PTR rgbValue, SDWORD cbValueMax, SDWORD *pcbValue)
154
{
155 156
	Int4		len = 0,
				copy_len = 0;
157
	SIMPLE_TIME st;
158 159 160 161
	time_t		t = time(NULL);
	struct tm  *tim;
	int			pcbValueOffset,
				rgbValueOffset;
162 163
	char	   *rgbValueBindRow;
	const char	*ptr;
164 165 166
	int			bind_row = stmt->bind_row;
	int			bind_size = stmt->options.bind_size;
	int			result = COPY_OK;
167 168 169
	BOOL		changed;
	static		char *tempBuf= NULL;
	static		unsigned int tempBuflen = 0;
170 171 172
	const char *neut_str = value;
	char	midtemp[2][32];
	int	mtemp_cnt = 0;
173

174 175
	if (!tempBuf)
		tempBuflen = 0;
176 177 178 179 180
	/*---------
	 *	rgbValueOffset is *ONLY* for character and binary data.
	 *	pcbValueOffset is for computing any pcbValue location
	 *---------
	 */
181

182
	if (bind_size > 0)
183
		pcbValueOffset = rgbValueOffset = (bind_size * bind_row);
184 185
	else
	{
186 187
		pcbValueOffset = bind_row * sizeof(SDWORD);
		rgbValueOffset = bind_row * cbValueMax;
188

189
	}
190 191 192

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

193
	/* Initialize current date */
194 195 196 197 198
	tim = localtime(&t);
	st.m = tim->tm_mon + 1;
	st.d = tim->tm_mday;
	st.y = tim->tm_year + 1900;

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

201 202
	if (!value)
	{
203

204
		/*
205 206
		 * handle a null just by returning SQL_NULL_DATA in pcbValue, and
		 * doing nothing to the buffer.
207
		 */
208
		if (pcbValue)
209
			*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = SQL_NULL_DATA;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
210 211 212
		return COPY_OK;
	}

213 214 215 216 217 218 219 220 221
	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
222 223
	}

224
	/*
225
	 * First convert any specific postgres types into more useable data.
226
	 *
227 228
	 * NOTE: Conversions from PG char/varchar of a date/time/timestamp value
	 * to SQL_C_DATE,SQL_C_TIME, SQL_C_TIMESTAMP not supported
229
	 */
230 231
	switch (field_type)
	{
232 233 234 235 236

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

241 242 243
		case PG_TYPE_TIME:
			sscanf(value, "%2d:%2d:%2d", &st.hh, &st.mm, &st.ss);
			break;
244

245 246 247 248 249 250
		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
251
			{
252

253
				/*
254 255
				 * The timestamp is invalid so set something conspicuous,
				 * like the epoch
256
				 */
257 258 259 260 261 262 263 264 265 266 267 268
				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:
269 270
			{			/* change T/F to 1/0 */
				char	   *s;
271

272 273
				s = midtemp[mtemp_cnt];
				strcpy(s, (char *) value);
274
				if (s[0] == 'f' || s[0] == 'F' || s[0] == 'n' || s[0] == 'N' || s[0] == '0')
275
					s[0] = '0';
276
				else
277 278 279 280
					s[0] = '1';
				s[1] = '\0';
				neut_str = midtemp[mtemp_cnt];
				mtemp_cnt++;
281

282 283 284
			}
			break;

285
			/* This is for internal use by SQLStatistics() */
286 287 288 289
		case PG_TYPE_INT2VECTOR:
			{
				int			nval,
							i;
290
				const char	*vp;
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319

				/* 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
320

321
#if 0
322 323 324 325 326 327 328 329 330
				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]);
331
#endif
Byron Nikolaidis's avatar
Byron Nikolaidis committed
332

333 334 335
				/* There is no corresponding fCType for this. */
				if (pcbValue)
					*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = len;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
336

337 338 339
				return COPY_OK; /* dont go any further or the data will be
								 * trashed */
			}
Byron Nikolaidis's avatar
Byron Nikolaidis committed
340

341 342 343 344 345
			/*
			 * This is a large object OID, which is used to store
			 * LONGVARBINARY objects.
			 */
		case PG_TYPE_LO:
Byron Nikolaidis's avatar
Byron Nikolaidis committed
346

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

349
		default:
Byron Nikolaidis's avatar
Byron Nikolaidis committed
350

351 352 353
			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
354 355
	}

356 357 358
	/* Change default into something useable */
	if (fCType == SQL_C_DEFAULT)
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
359 360 361 362 363
		fCType = pgtype_to_ctype(stmt, field_type);

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

364 365
	rgbValueBindRow = (char *) rgbValue + rgbValueOffset;

366 367 368
	if (fCType == SQL_C_CHAR)
	{
		/* Special character formatting as required */
369

370 371 372 373 374 375 376 377 378 379 380
		/*
		 * 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;
381

382 383 384 385 386
			case PG_TYPE_TIME:
				len = 8;
				if (cbValueMax > len)
					sprintf(rgbValueBindRow, "%.2d:%.2d:%.2d", st.hh, st.mm, st.ss);
				break;
387

388 389 390 391 392 393 394 395
			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;
396

397 398 399 400
			case PG_TYPE_BOOL:
				len = 1;
				if (cbValueMax > len)
				{
401
					strcpy(rgbValueBindRow, neut_str);
402 403 404
					mylog("PG_TYPE_BOOL: rgbValueBindRow = '%s'\n", rgbValueBindRow);
				}
				break;
405

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
				/*
				 * 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") */
421
				len = convert_pgbinary_to_char(neut_str, rgbValueBindRow, cbValueMax);
422 423 424

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

426
			default:
427 428 429 430 431
				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 */
432
					len = convert_linefeeds(neut_str, NULL, 0, &changed);
433 434 435 436 437 438 439 440 441 442 443 444
					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;
						}
445
						convert_linefeeds(neut_str, tempBuf, tempBuflen, &changed);
446 447 448 449 450 451 452 453 454
						ptr = tempBuf;
					}
					else
					{
						if (tempBuf)
						{
							free(tempBuf);
							tempBuf = NULL;
						}
455
						ptr = neut_str;
456 457 458 459
					}
				}
				else
					ptr = tempBuf;
460 461 462 463 464 465

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

				if (stmt->current_col >= 0)
				{
					if (stmt->bindings[stmt->current_col].data_left == 0)
466 467 468 469 470 471 472 473
					{
						if (tempBuf)
						{
							free(tempBuf);
							tempBuf = NULL;
						}
						/* The following seems to be needed for ADO ? */
						stmt->bindings[stmt->current_col].data_left = -2;
474
						return COPY_NO_DATA_FOUND;
475
					}
476 477
					else if (stmt->bindings[stmt->current_col].data_left > 0)
					{
478
						ptr += strlen(ptr) - stmt->bindings[stmt->current_col].data_left;
479 480 481
						len = stmt->bindings[stmt->current_col].data_left;
					}
					else
482
						stmt->bindings[stmt->current_col].data_left = len;
483 484
				}

485 486 487
				if (cbValueMax > 0)
				{
					copy_len = (len >= cbValueMax) ? cbValueMax - 1 : len;
488

489
					/* Copy the data */
490 491
					memcpy(rgbValueBindRow, ptr, copy_len);
					rgbValueBindRow[copy_len] = '\0';
492

493 494 495
					/* Adjust data_left for next time */
					if (stmt->current_col >= 0)
						stmt->bindings[stmt->current_col].data_left -= copy_len;
496 497
				}

498 499 500 501
				/*
				 * Finally, check for truncation so that proper status can
				 * be returned
				 */
502
				if (cbValueMax > 0 && len >= cbValueMax)
503
					result = COPY_RESULT_TRUNCATED;
504 505 506 507 508 509 510 511
				else
				{
					if (tempBuf)
					{
						free(tempBuf);
						tempBuf = NULL;
					}
				}
512 513


514 515
				mylog("    SQL_C_CHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
				break;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
516
		}
517 518


519 520 521
	}
	else
	{
522

523 524 525 526 527
		/*
		 * 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
528
		if (field_type == PG_TYPE_MONEY)
529 530 531 532 533 534 535 536 537
		{
			if (convert_money(neut_str, midtemp[mtemp_cnt], sizeof(midtemp[0])))
			{
				neut_str = midtemp[mtemp_cnt];
				mtemp_cnt++;
			}
			else
				return COPY_UNSUPPORTED_TYPE;
		}
Byron Nikolaidis's avatar
Byron Nikolaidis committed
538

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
		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;
555

556 557 558 559 560 561 562 563 564 565 566 567 568 569
			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
570

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
			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;
589

590 591 592
			case SQL_C_BIT:
				len = 1;
				if (bind_size > 0)
593
					*(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(neut_str);
594
				else
595
					*((UCHAR *) rgbValue + bind_row) = atoi(neut_str);
596

597
				/*
598
				 * mylog("SQL_C_BIT: bind_row = %d val = %d, cb = %d, rgb=%d\n",
599
				 * bind_row, atoi(neut_str), cbValueMax, *((UCHAR *)rgbValue));
600 601
				 */
				break;
602

603 604 605 606
			case SQL_C_STINYINT:
			case SQL_C_TINYINT:
				len = 1;
				if (bind_size > 0)
607
					*(SCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(neut_str);
608
				else
609
					*((SCHAR *) rgbValue + bind_row) = atoi(neut_str);
610
				break;
611

612 613 614
			case SQL_C_UTINYINT:
				len = 1;
				if (bind_size > 0)
615
					*(UCHAR *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(neut_str);
616
				else
617
					*((UCHAR *) rgbValue + bind_row) = atoi(neut_str);
618
				break;
619

620 621 622
			case SQL_C_FLOAT:
				len = 4;
				if (bind_size > 0)
623
					*(SFLOAT *) ((char *) rgbValue + (bind_row * bind_size)) = (float) atof(neut_str);
624
				else
625
					*((SFLOAT *) rgbValue + bind_row) = (float) atof(neut_str);
626
				break;
627

628 629 630
			case SQL_C_DOUBLE:
				len = 8;
				if (bind_size > 0)
631
					*(SDOUBLE *) ((char *) rgbValue + (bind_row * bind_size)) = atof(neut_str);
632
				else
633
					*((SDOUBLE *) rgbValue + bind_row) = atof(neut_str);
634
				break;
635

636 637 638 639
			case SQL_C_SSHORT:
			case SQL_C_SHORT:
				len = 2;
				if (bind_size > 0)
640
					*(SWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(neut_str);
641
				else
642
					*((SWORD *) rgbValue + bind_row) = atoi(neut_str);
643
				break;
644

645 646 647
			case SQL_C_USHORT:
				len = 2;
				if (bind_size > 0)
648
					*(UWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atoi(neut_str);
649
				else
650
					*((UWORD *) rgbValue + bind_row) = atoi(neut_str);
651
				break;
652

653 654 655 656
			case SQL_C_SLONG:
			case SQL_C_LONG:
				len = 4;
				if (bind_size > 0)
657
					*(SDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(neut_str);
658
				else
659
					*((SDWORD *) rgbValue + bind_row) = atol(neut_str);
660 661 662 663 664
				break;

			case SQL_C_ULONG:
				len = 4;
				if (bind_size > 0)
665
					*(UDWORD *) ((char *) rgbValue + (bind_row * bind_size)) = atol(neut_str);
666
				else
667
					*((UDWORD *) rgbValue + bind_row) = atol(neut_str);
668
				break;
669

670
			case SQL_C_BINARY:
671

672 673
				/* truncate if necessary */
				/* convert octal escapes to bytes */
674

675
				if (len = strlen(neut_str), len >= (int) tempBuflen)
676 677 678 679
				{
					tempBuf = realloc(tempBuf, len + 1);
					tempBuflen = len + 1;
				}
680
				len = convert_from_pgbinary(neut_str, tempBuf, tempBuflen);
681
				ptr = tempBuf;
682

683 684 685 686
				if (stmt->current_col >= 0)
				{
					/* No more data left for this column */
					if (stmt->bindings[stmt->current_col].data_left == 0)
687 688 689
					{
						free(tempBuf);
						tempBuf = NULL;
690
						return COPY_NO_DATA_FOUND;
691
					}
692

693 694 695 696 697 698 699 700 701
					/*
					 * 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;
					}
702

703 704 705
					/* First call to SQLGetData so initialize data_left */
					else
						stmt->bindings[stmt->current_col].data_left = len;
706

707
				}
708

709 710 711
				if (cbValueMax > 0)
				{
					copy_len = (len > cbValueMax) ? cbValueMax : len;
712

713 714
					/* Copy the data */
					memcpy(rgbValueBindRow, ptr, copy_len);
715

716 717 718
					/* Adjust data_left for next time */
					if (stmt->current_col >= 0)
						stmt->bindings[stmt->current_col].data_left -= copy_len;
719
				}
720

721 722 723 724 725 726
				/*
				 * Finally, check for truncation so that proper status can
				 * be returned
				 */
				if (len > cbValueMax)
					result = COPY_RESULT_TRUNCATED;
727

728 729 730 731 732
				if (tempBuf)
				{
					free(tempBuf);
					tempBuf = NULL;
				}
733 734 735 736 737
				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
738 739
		}
	}
740

741 742 743
	/* store the length of what was copied, if there's a place for it */
	if (pcbValue)
		*(SDWORD *) ((char *) pcbValue + pcbValueOffset) = len;
744

745
	return result;
746

747 748
}

749

750 751 752 753 754 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
/*--------------------------------------------------------------------
 *	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]);
}

921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
/*----------
 *	Check if the statement is	
 *	SELECT ... FOR UPDATE .....
 *	This isn't really a strict check but ...
 *---------- 
 */
static BOOL
table_for_update(const char *stmt, int *endpos)
{
	const char *wstmt = stmt;
	while (isspace((unsigned char) *(++wstmt)));
	if (! *wstmt)
		return FALSE;
	if (strnicmp(wstmt, "update", 6))
		return FALSE;
	wstmt += 6;
	*endpos = wstmt - stmt;
	return !wstmt[0] || isspace((unsigned char) wstmt[0]);
}

941 942 943
/*
 *	This function inserts parameters into an SQL statements.
 *	It will also modify a SELECT statement for use with declare/fetch cursors.
944
 *	This function does a dynamic memory allocation to get rid of query size limit!
945
 */
946
int
Bruce Momjian's avatar
Bruce Momjian committed
947
copy_statement_with_parameters(StatementClass *stmt)
948
{
949 950 951 952 953 954
	static char *func = "copy_statement_with_parameters";
	unsigned int opos,
				npos,
				oldstmtlen;
	char		param_string[128],
				tmp[256],
955
				cbuf[PG_NUMERIC_MAX_PRECISION * 2]; /* seems big enough to handle the data in this function */
956 957 958
	int			param_number;
	Int2		param_ctype,
				param_sqltype;
959
	char	   *old_statement = stmt->statement, oldchar;
960
	char	   *new_statement = stmt->stmt_with_params;
961
	unsigned int	new_stsize = 0;
962 963 964 965
	SIMPLE_TIME st;
	time_t		t = time(NULL);
	struct tm  *tim;
	SDWORD		used;
966
	char	   	*buffer, *buf;
967
	BOOL		in_quote = FALSE, in_dquote = FALSE, in_escape = FALSE;
968 969 970
	Oid			lobj_oid;
	int			lobj_fd,
				retval;
971
	BOOL	check_cursor_ok = FALSE; /* check cursor restriction */
972
	BOOL	proc_no_param = TRUE;
973
	unsigned int	declare_pos = 0;
974 975
	ConnectionClass	*conn = SC_get_conn(stmt);
	ConnInfo	*ci = &(conn->connInfo);
976
	BOOL		prepare_dummy_cursor = FALSE, begin_first = FALSE;
977 978 979
	char	token_save[32];
	int	token_len;
	BOOL	prev_token_end;
980
#ifdef	DRIVER_CURSOR_IMPLEMENT
981
	BOOL search_from_pos = FALSE;
982
#endif /* DRIVER_CURSOR_IMPLEMENT */
983 984
	if (ci->disallow_premature)
		prepare_dummy_cursor = stmt->pre_executing;
985 986 987

	if (!old_statement)
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
988
		SC_log_error(func, "No statement string", stmt);
989
		return SQL_ERROR;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
990
	}
991

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

994
	/* Initialize current date */
995 996 997 998 999
	tim = localtime(&t);
	st.m = tim->tm_mon + 1;
	st.d = tim->tm_mday;
	st.y = tim->tm_year + 1900;

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
#ifdef	DRIVER_CURSOR_IMPLEMENT
	if (stmt->statement_type != STMT_TYPE_SELECT)
	{
		stmt->options.cursor_type = SQL_CURSOR_FORWARD_ONLY;
		stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
	}
	else if (stmt->options.cursor_type == SQL_CURSOR_FORWARD_ONLY)
    		stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
	else if (stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
	{
		if (stmt->parse_status == STMT_PARSE_NONE)
			parse_statement(stmt);
		if (stmt->parse_status != STMT_PARSE_COMPLETE)
			stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
		else if (!stmt->ti || stmt->ntab != 1)
    			stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
1016 1017
		else
			search_from_pos = TRUE;
1018 1019
	}
#endif /* DRIVER_CURSOR_IMPLEMENT */
1020 1021 1022 1023 1024 1025

	/* If the application hasn't set a cursor name, then generate one */
	if (stmt->cursor_name[0] == '\0')
		sprintf(stmt->cursor_name, "SQL_CUR%p", stmt);
	oldstmtlen = strlen(old_statement);
	CVT_INIT(oldstmtlen);
1026

1027
	stmt->miscinfo = 0;
1028 1029
	token_len = 0;
	prev_token_end = TRUE;
1030 1031 1032 1033 1034 1035 1036 1037
	/* For selects, prepend a declare cursor to the statement */
	if (stmt->statement_type == STMT_TYPE_SELECT)
	{
		SC_set_pre_executable(stmt);
		if (prepare_dummy_cursor || ci->drivers.use_declarefetch)
		{
			if (prepare_dummy_cursor)
			{
1038 1039 1040 1041 1042
				if (!CC_is_in_trans(conn) && PG_VERSION_GE(conn, 7.1))
				{
					strcpy(new_statement, "BEGIN;");
					begin_first = TRUE;
				}
1043 1044 1045
			}
			else if (ci->drivers.use_declarefetch)
				SC_set_fetchcursor(stmt);
1046
			sprintf(new_statement, "%sdeclare %s cursor for ",
1047 1048
				 new_statement, stmt->cursor_name);
			npos = strlen(new_statement);
1049
			check_cursor_ok = TRUE;
1050 1051 1052 1053
			declare_pos = npos;
		}
	}
	param_number = -1;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1054
#ifdef MULTIBYTE
1055
	multibyte_init();
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1056
#endif
1057

1058 1059
	for (opos = 0; opos < oldstmtlen; opos++)
	{
1060
		oldchar = old_statement[opos];
1061
#ifdef MULTIBYTE
1062
		if (multibyte_char_check(oldchar) != 0)
1063
		{
1064
			CVT_APPEND_CHAR(oldchar);
1065 1066 1067 1068 1069 1070 1071
			continue;
		}
		/*
		 *	From here we are guaranteed to handle a
		 *	1-byte character.
		 */
#endif
1072

1073
		if (in_escape) /* escape check */
1074 1075
		{
			in_escape = FALSE;
1076
			CVT_APPEND_CHAR(oldchar);
1077 1078 1079 1080
			continue;
		}	
		else if (in_quote || in_dquote) /* quote/double quote check */
		{
1081 1082 1083
			if (oldchar == '\\')
				in_escape = TRUE;
			else if (oldchar == '\'' && in_quote)
1084
				in_quote = FALSE;
1085
			else if (oldchar == '\"' && in_dquote)
1086
				in_dquote = FALSE;
1087
			CVT_APPEND_CHAR(oldchar);
1088 1089 1090 1091
			continue;	
		}
		/*
		 *	From here we are guranteed to be in neither
1092
		 *	an escape, a quote nor a double quote.
1093
		 */
1094 1095 1096 1097
		/* Squeeze carriage-return/linefeed pairs to linefeed only */
		else if (oldchar == '\r' && opos + 1 < oldstmtlen &&
			old_statement[opos + 1] == '\n')
			continue;
1098 1099 1100 1101
		/*
		 * Handle literals (date, time, timestamp) and ODBC scalar
		 * functions
		 */
1102
		else if (oldchar == '{')
1103 1104 1105 1106
		{
			char	   *esc;
			char	   *begin = &old_statement[opos + 1];

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1107
#ifdef MULTIBYTE
1108
			char	   *end = multibyte_strchr(begin, '}');
1109

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1110
#else
1111
			char	   *end = strchr(begin, '}');
1112

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1113
#endif
1114

1115
			if (!end)
1116
				continue;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1117 1118 1119
			/* procedure calls */
			if (stmt->statement_type == STMT_TYPE_PROCCALL)
			{
1120
				int	lit_call_len = 4;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1121
				while (isspace((unsigned char) old_statement[++opos]));
1122
				/* '=?' to accept return values exists ? */
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
				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]));
				}
1134 1135
				if (strnicmp(&old_statement[opos], "call", lit_call_len) ||
					!isspace(old_statement[opos + lit_call_len]))
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1136 1137 1138 1139
				{
					opos--;
					continue;
				}
1140 1141
				opos += lit_call_len; 
				CVT_APPEND_STR("SELECT ");
1142 1143 1144
#ifdef MULTIBYTE
				if (multibyte_strchr(&old_statement[opos], '('))
#else
1145
				if (strchr(&old_statement[opos], '('))
1146
#endif /* MULTIBYTE */
1147
					proc_no_param = FALSE;
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1148 1149
				continue; 
			}
1150 1151 1152
			*end = '\0';

			esc = convert_escape(begin);
1153 1154
			if (esc)
			{
1155
				CVT_APPEND_STR(esc);
1156
			}
1157 1158 1159
			else
			{					/* it's not a valid literal so just copy */
				*end = '}';
1160
				CVT_APPEND_CHAR(oldchar);
1161 1162
				continue;
			}
1163

1164
			opos += end - begin + 1;
1165 1166 1167
			*end = '}';
			continue;
		}
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1168 1169
		/* End of a procedure call */
		else if (oldchar == '}' && stmt->statement_type == STMT_TYPE_PROCCALL)
1170 1171 1172
		{
			if (proc_no_param)
				CVT_APPEND_STR("()");
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1173
			continue;
1174
		}
1175

1176 1177 1178 1179 1180
		/*
		 * 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.
		 */
1181
		else if (oldchar == '?')
1182 1183 1184
			;					/* ok */
		else
		{
1185
			if (oldchar == '\'')
1186
				in_quote = TRUE;
1187
			else if (oldchar == '\\')
1188
				in_escape = TRUE;
1189
			else if (oldchar == '\"')
1190
				in_dquote = TRUE;
1191
			else 
1192
			{
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
				if (isspace(oldchar))
				{
					if (!prev_token_end)
					{
						prev_token_end = TRUE;
						token_save[token_len] = '\0';
						if (token_len == 4)
						{
							if (check_cursor_ok &&
    				 			   into_table_from(&old_statement[opos - token_len]))
							{
								stmt->statement_type = STMT_TYPE_CREATE;
								SC_no_pre_executable(stmt);
								SC_no_fetchcursor(stmt);
								stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
								memmove(new_statement, new_statement + declare_pos, npos - declare_pos);
								npos -= declare_pos;
							}
1211
#ifdef	DRIVER_CURSOR_IMPLEMENT
1212 1213 1214 1215 1216 1217 1218
							else if (search_from_pos && /* where's from clause */
    				 				 strnicmp(token_save, "from", 4) == 0)
							{
								search_from_pos = FALSE;
								npos -= 5;
								CVT_APPEND_STR(", CTID, OID from");
							}
1219
#endif /* DRIVER_CURSOR_IMPLEMENT */
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
						}
						if (token_len == 3)
						{
							int	endpos;
							if (check_cursor_ok &&
    				 			    strnicmp(token_save, "for", 3) == 0 &&
    				 			    table_for_update(&old_statement[opos], &endpos))
							{
								SC_no_fetchcursor(stmt);
								stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
								if (prepare_dummy_cursor)
								{
									npos -= 4;
									opos += endpos;
								}
								else
								{
									memmove(new_statement, new_statement + declare_pos, npos - declare_pos);
									npos -= declare_pos;
								}
							}
						}
					}	
				}
				else if (prev_token_end)
				{
					prev_token_end = FALSE;
					token_save[0] = oldchar;
					token_len = 1;
				}
				else
					token_save[token_len++] = oldchar;
			} 
1253
			CVT_APPEND_CHAR(oldchar);
1254 1255 1256
			continue;
		}

1257 1258 1259
		/*
		 * Its a '?' parameter alright
		 */
1260 1261
		param_number++;

1262
		if (param_number >= stmt->parameters_allocated)
1263 1264 1265
		{
			if (stmt->pre_executing)
			{
1266
				CVT_APPEND_STR("NULL");
1267 1268 1269 1270 1271
				stmt->inaccurate_result = TRUE;
				continue;
			}
			else
			{
1272
				CVT_APPEND_CHAR('?');
1273 1274 1275
				continue;
			}
		}
1276

1277 1278 1279
		/* Assign correct buffers based on data at exec param or not */
		if (stmt->parameters[param_number].data_at_exec)
		{
1280 1281 1282
			used = stmt->parameters[param_number].EXEC_used ? *stmt->parameters[param_number].EXEC_used : SQL_NTS;
			buffer = stmt->parameters[param_number].EXEC_buffer;
		}
1283 1284
		else
		{
1285 1286
			
			
1287
			used = stmt->parameters[param_number].used ? *stmt->parameters[param_number].used : SQL_NTS;
1288
			
1289 1290 1291
			buffer = stmt->parameters[param_number].buffer;
		}

1292 1293 1294
		/* Handle NULL parameter data */
		if (used == SQL_NULL_DATA)
		{
1295
			CVT_APPEND_STR("NULL");
1296 1297 1298
			continue;
		}

1299 1300 1301 1302 1303 1304
		/*
		 * If no buffer, and it's not null, then what the hell is it? Just
		 * leave it alone then.
		 */
		if (!buffer)
		{
1305 1306
			if (stmt->pre_executing)
			{
1307
				CVT_APPEND_STR("NULL");
1308 1309 1310 1311 1312
				stmt->inaccurate_result = TRUE;
				continue;
			}
			else
			{
1313
				CVT_APPEND_CHAR('?');
1314 1315
				continue;
			}
1316
		}
1317 1318 1319

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

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

1323
		/* replace DEFAULT with something we can use */
1324
		if (param_ctype == SQL_C_DEFAULT)
1325 1326 1327 1328 1329 1330
			param_ctype = sqltype_to_default_ctype(param_sqltype);

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

1331 1332 1333 1334 1335 1336 1337
		/* Convert input C type to a neutral format */
		switch (param_ctype)
		{
			case SQL_C_BINARY:
			case SQL_C_CHAR:
				buf = buffer;
				break;
1338

1339
			case SQL_C_DOUBLE:
1340
				sprintf(param_string, "%.15g",
1341 1342
						*((SDOUBLE *) buffer));
				break;
1343

1344
			case SQL_C_FLOAT:
1345
				sprintf(param_string, "%.6g",
1346 1347
						*((SFLOAT *) buffer));
				break;
1348

1349 1350 1351 1352 1353
			case SQL_C_SLONG:
			case SQL_C_LONG:
				sprintf(param_string, "%ld",
						*((SDWORD *) buffer));
				break;
1354

1355 1356 1357 1358 1359
			case SQL_C_SSHORT:
			case SQL_C_SHORT:
				sprintf(param_string, "%d",
						*((SWORD *) buffer));
				break;
1360

1361 1362 1363 1364 1365
			case SQL_C_STINYINT:
			case SQL_C_TINYINT:
				sprintf(param_string, "%d",
						*((SCHAR *) buffer));
				break;
1366

1367 1368 1369 1370
			case SQL_C_ULONG:
				sprintf(param_string, "%lu",
						*((UDWORD *) buffer));
				break;
1371

1372 1373 1374 1375
			case SQL_C_USHORT:
				sprintf(param_string, "%u",
						*((UWORD *) buffer));
				break;
1376

1377 1378 1379 1380
			case SQL_C_UTINYINT:
				sprintf(param_string, "%u",
						*((UCHAR *) buffer));
				break;
1381

1382 1383 1384
			case SQL_C_BIT:
				{
					int			i = *((UCHAR *) buffer);
1385

1386 1387 1388
					sprintf(param_string, "%d", i ? 1 : 0);
					break;
				}
1389

1390 1391 1392
			case SQL_C_DATE:
				{
					DATE_STRUCT *ds = (DATE_STRUCT *) buffer;
1393

1394 1395 1396
					st.m = ds->month;
					st.d = ds->day;
					st.y = ds->year;
1397

1398 1399
					break;
				}
1400

1401 1402 1403
			case SQL_C_TIME:
				{
					TIME_STRUCT *ts = (TIME_STRUCT *) buffer;
1404

1405 1406 1407
					st.hh = ts->hour;
					st.mm = ts->minute;
					st.ss = ts->second;
1408

1409 1410
					break;
				}
1411

1412 1413 1414
			case SQL_C_TIMESTAMP:
				{
					TIMESTAMP_STRUCT *tss = (TIMESTAMP_STRUCT *) buffer;
1415

1416 1417 1418 1419 1420 1421
					st.m = tss->month;
					st.d = tss->day;
					st.y = tss->year;
					st.hh = tss->hour;
					st.mm = tss->minute;
					st.ss = tss->second;
1422

1423
					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);
1424

1425
					break;
1426

1427 1428 1429 1430 1431
				}
			default:
				/* error */
				stmt->errormsg = "Unrecognized C_parameter type in copy_statement_with_parameters";
				stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
1432
				CVT_TERMINATE	/* just in case */
1433 1434 1435
				SC_log_error(func, "", stmt);
				return SQL_ERROR;
		}
1436

1437 1438 1439 1440
		/*
		 * Now that the input data is in a neutral format, convert it to
		 * the desired output format (sqltype)
		 */
1441

1442 1443 1444 1445 1446
		switch (param_sqltype)
		{
			case SQL_CHAR:
			case SQL_VARCHAR:
			case SQL_LONGVARCHAR:
1447

1448
				CVT_APPEND_CHAR('\'');	/* Open Quote */
1449

1450 1451 1452
				/* it was a SQL_C_CHAR */
				if (buf)
				{
1453
					CVT_SPECIAL_CHARS(buf, used);
1454
				}
1455

1456 1457 1458
				/* it was a numeric type */
				else if (param_string[0] != '\0')
				{
1459
					CVT_APPEND_STR(param_string);
1460
				}
1461

1462 1463 1464 1465 1466
				/* 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);
1467

1468
					CVT_APPEND_STR(tmp);
1469
				}
1470

1471
				CVT_APPEND_CHAR('\'');	/* Close Quote */
1472

1473
				break;
1474

1475 1476 1477 1478 1479 1480
			case SQL_DATE:
				if (buf)
				{				/* copy char data to time */
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1481

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

1484
				CVT_APPEND_STR(tmp);
1485
				break;
1486

1487 1488 1489 1490 1491 1492
			case SQL_TIME:
				if (buf)
				{				/* copy char data to time */
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1493

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

1496
				CVT_APPEND_STR(tmp);
1497
				break;
1498

1499
			case SQL_TIMESTAMP:
1500

1501 1502 1503 1504 1505
				if (buf)
				{
					my_strcpy(cbuf, sizeof(cbuf), buf, used);
					parse_datetime(cbuf, &st);
				}
1506

1507 1508
				sprintf(tmp, "'%.4d-%.2d-%.2d %.2d:%.2d:%.2d'",
						st.y, st.m, st.d, st.hh, st.mm, st.ss);
1509

1510
				CVT_APPEND_STR(tmp);
1511

1512
				break;
1513

1514 1515 1516
			case SQL_BINARY:
			case SQL_VARBINARY:/* non-ascii characters should be
								 * converted to octal */
1517
				CVT_APPEND_CHAR('\'');	/* Open Quote */
1518

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

1521
				CVT_APPEND_BINARY(buf, used);
1522

1523
				CVT_APPEND_CHAR('\'');	/* Close Quote */
1524

1525
				break;
1526

1527 1528 1529 1530 1531 1532 1533
			case SQL_LONGVARBINARY:

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

1539
						res = CC_send_query(conn, "BEGIN", NULL);
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
						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;
						}
1556

1557
						CC_set_in_trans(conn);
1558
					}
1559

1560
					/* store the oid */
1561
					lobj_oid = lo_creat(conn, INV_READ | INV_WRITE);
1562 1563
					if (lobj_oid == 0)
					{
1564
						stmt->errornumber = STMT_EXEC_ERROR;
1565
						stmt->errormsg = "Couldnt create (in-line) large object.";
1566 1567 1568
						SC_log_error(func, "", stmt);
						return SQL_ERROR;
					}
1569 1570

					/* store the fd */
1571
					lobj_fd = lo_open(conn, lobj_oid, INV_WRITE);
1572 1573
					if (lobj_fd < 0)
					{
1574
						stmt->errornumber = STMT_EXEC_ERROR;
1575
						stmt->errormsg = "Couldnt open (in-line) large object for writing.";
1576 1577 1578 1579
						SC_log_error(func, "", stmt);
						return SQL_ERROR;
					}

1580
					retval = lo_write(conn, lobj_fd, buffer, used);
1581

1582
					lo_close(conn, lobj_fd);
1583

1584
					/* commit transaction if needed */
1585
					if (!ci->drivers.use_declarefetch && CC_is_in_autocommit(conn))
1586 1587 1588
					{
						QResultClass *res;
						char		ok;
1589

1590
						res = CC_send_query(conn, "COMMIT", NULL);
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
						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;
						}
1607

1608
						CC_set_no_trans(conn);
1609 1610
					}
				}
1611

1612 1613 1614 1615 1616 1617
				/*
				 * 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);
1618
				CVT_APPEND_STR(param_string);
1619

1620 1621 1622 1623 1624 1625 1626
				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) */
1627

1628 1629 1630 1631
			case SQL_REAL:
				if (buf)
					my_strcpy(param_string, sizeof(param_string), buf, used);
				sprintf(tmp, "'%s'::float4", param_string);
1632
				CVT_APPEND_STR(tmp);
1633 1634 1635 1636 1637 1638
				break;
			case SQL_FLOAT:
			case SQL_DOUBLE:
				if (buf)
					my_strcpy(param_string, sizeof(param_string), buf, used);
				sprintf(tmp, "'%s'::float8", param_string);
1639
				CVT_APPEND_STR(tmp);
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
				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);
1652
				CVT_APPEND_STR(cbuf);
1653 1654 1655
				break;
			default:			/* a numeric type or SQL_BIT */
				if (param_sqltype == SQL_BIT)
1656
					CVT_APPEND_CHAR('\'');		/* Open Quote */
1657 1658 1659

				if (buf)
				{
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
					switch (used)
					{
						case SQL_NULL_DATA:
							break;
						case SQL_NTS:
							CVT_APPEND_STR(buf);
							break;
						default:
							CVT_APPEND_DATA(buf, used);
					}
1670 1671
				}
				else
1672
					CVT_APPEND_STR(param_string);
1673 1674

				if (param_sqltype == SQL_BIT)
1675
					CVT_APPEND_CHAR('\'');		/* Close Quote */
1676 1677

				break;
1678
		}
1679
	}							/* end, for */
1680

1681
	/* make sure new_statement is always null-terminated */
1682
	CVT_TERMINATE
1683

1684
	if (conn->DriverToDataSource != NULL)
1685 1686 1687
	{
		int			length = strlen(new_statement);

1688
		conn->DriverToDataSource(conn->translation_option,
1689 1690 1691 1692
									   SQL_CHAR,
									   new_statement, length,
									   new_statement, length, NULL,
									   NULL, 0, NULL);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1693 1694
	}

1695
#ifdef	DRIVER_CURSOR_IMPLEMENT
1696
	if (search_from_pos)
1697 1698
		stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
#endif /* DRIVER_CURSOR_IMPLEMENT */
1699 1700 1701 1702 1703
	if (prepare_dummy_cursor && SC_is_pre_executable(stmt))
	{
		char fetchstr[128];	
		sprintf(fetchstr, ";fetch backward in %s;close %s;",
				stmt->cursor_name, stmt->cursor_name);
1704 1705
		if (begin_first && CC_is_in_autocommit(conn))
			strcat(fetchstr, "COMMIT;");
1706 1707 1708 1709
		CVT_APPEND_STR(fetchstr);
		stmt->inaccurate_result = TRUE;
	}

1710 1711 1712
	return SQL_SUCCESS;
}

1713

1714
char *
1715
mapFunction(const char *func)
1716
{
1717
	int			i;
1718 1719

	for (i = 0; mapFuncs[i][0]; i++)
1720
		if (!stricmp(mapFuncs[i][0], func))
1721 1722 1723 1724
			return mapFuncs[i][1];

	return NULL;
}
1725

1726 1727 1728 1729

/*
 * convert_escape()
 *
1730 1731
 * This function returns a pointer to static memory!
 */
1732 1733 1734
char *
convert_escape(char *value)
{
1735 1736
	static char escape[1024];
	char		key[33];
1737

1738
	/* Separate off the key, skipping leading and trailing whitespace */
1739 1740
	while ((*value != '\0') && isspace((unsigned char) *value))
		value++;
1741
	sscanf(value, "%32s", key);
1742 1743 1744 1745
	while ((*value != '\0') && (!isspace((unsigned char) *value)))
		value++;
	while ((*value != '\0') && isspace((unsigned char) *value))
		value++;
1746

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

1749 1750
	if ((strcmp(key, "d") == 0) ||
		(strcmp(key, "t") == 0) ||
1751 1752
		(strcmp(key, "oj") == 0) ||		/* {oj syntax support for 7.1
										 * servers */
1753 1754
		(strcmp(key, "ts") == 0))
	{
1755
		/* Literal; return the escape part as-is */
1756
		strncpy(escape, value, sizeof(escape) - 1);
1757
	}
1758 1759
	else if (strcmp(key, "fn") == 0)
	{
1760

1761 1762 1763
		/*
		 * Function invocation Separate off the func name, skipping
		 * trailing whitespace.
1764
		 */
1765 1766 1767
		char	   *funcEnd = value;
		char		svchar;
		char	   *mapFunc;
1768 1769

		while ((*funcEnd != '\0') && (*funcEnd != '(') &&
1770
			   (!isspace((unsigned char) *funcEnd)))
1771
			funcEnd++;
1772 1773 1774 1775
		svchar = *funcEnd;
		*funcEnd = '\0';
		sscanf(value, "%32s", key);
		*funcEnd = svchar;
1776 1777
		while ((*funcEnd != '\0') && isspace((unsigned char) *funcEnd))
			funcEnd++;
1778

1779 1780 1781
		/*
		 * We expect left parenthesis here, else return fn body as-is
		 * since it is one of those "function constants".
1782
		 */
1783 1784 1785
		if (*funcEnd != '(')
		{
			strncpy(escape, value, sizeof(escape) - 1);
1786
			return escape;
1787
		}
1788
		mapFunc = mapFunction(key);
1789 1790 1791 1792

		/*
		 * We could have mapFunction() return key if not in table... -
		 * thomas 2000-04-03
1793
		 */
1794 1795
		if (mapFunc == NULL)
		{
1796
			/* If unrecognized function name, return fn body as-is */
1797
			strncpy(escape, value, sizeof(escape) - 1);
1798 1799 1800 1801
			return escape;
		}
		/* copy mapped name and remaining input string */
		strcpy(escape, mapFunc);
1802
		strncat(escape, funcEnd, sizeof(escape) - 1 - strlen(mapFunc));
1803
	}
1804 1805
	else
	{
1806
		/* Bogus key, leave untranslated */
1807 1808 1809 1810 1811 1812 1813
		return NULL;
	}

	return escape;
}


1814 1815
BOOL
convert_money(const char *s, char *sout, size_t soutmax)
1816
{
1817
	size_t		i = 0, out = 0;
1818

1819
	for (i = 0; s[i]; i++)
1820
	{
1821
		if (s[i] == '$' || s[i] == ',' || s[i] == ')')
1822
			;					/* skip these characters */
1823
		else
1824 1825 1826 1827 1828 1829 1830 1831
		{
			if (out + 1 >= soutmax)
				return FALSE; /* sout is too short */
			if (s[i] == '(')
				sout[out++] = '-';
			else
				sout[out++] = s[i];
		}
1832
	}
1833 1834
	sout[out] = '\0';
	return TRUE;
1835 1836 1837
}


1838 1839 1840 1841
/*
 *	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
 */
1842
char
Bruce Momjian's avatar
Bruce Momjian committed
1843
parse_datetime(char *buf, SIMPLE_TIME *st)
1844
{
1845 1846 1847 1848 1849 1850 1851 1852
	int			y,
				m,
				d,
				hh,
				mm,
				ss;
	int			nf;

1853 1854
	y = m = d = hh = mm = ss = 0;

1855 1856 1857 1858 1859 1860 1861 1862
	/* escape sequence ? */
	if (buf[0] == '{')
	{
		while (*(++buf) && *buf != '\'');
		if (!(*buf))
			return FALSE;
		buf++;
	}
1863 1864
	if (buf[4] == '-')			/* year first */
		nf = sscanf(buf, "%4d-%2d-%2d %2d:%2d:%2d", &y, &m, &d, &hh, &mm, &ss);
1865
	else
1866
		nf = sscanf(buf, "%2d-%2d-%4d %2d:%2d:%2d", &m, &d, &y, &hh, &mm, &ss);
1867

1868 1869
	if (nf == 5 || nf == 6)
	{
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
		st->y = y;
		st->m = m;
		st->d = d;
		st->hh = hh;
		st->mm = mm;
		st->ss = ss;

		return TRUE;
	}

1880
	if (buf[4] == '-')			/* year first */
1881 1882 1883 1884
		nf = sscanf(buf, "%4d-%2d-%2d", &y, &m, &d);
	else
		nf = sscanf(buf, "%2d-%2d-%4d", &m, &d, &y);

1885 1886
	if (nf == 3)
	{
1887 1888 1889 1890 1891 1892 1893 1894
		st->y = y;
		st->m = m;
		st->d = d;

		return TRUE;
	}

	nf = sscanf(buf, "%2d:%2d:%2d", &hh, &mm, &ss);
1895 1896
	if (nf == 2 || nf == 3)
	{
1897 1898 1899 1900 1901 1902 1903 1904 1905
		st->hh = hh;
		st->mm = mm;
		st->ss = ss;

		return TRUE;
	}

	return FALSE;
}
1906

1907

1908
/*	Change linefeed to carriage-return/linefeed */
1909
int
1910
convert_linefeeds(const char *si, char *dst, size_t max, BOOL *changed)
1911
{
1912 1913
	size_t		i = 0,
				out = 0;
1914

1915 1916 1917 1918
	if (max == 0)
		max = 0xffffffff;
	*changed = FALSE;
	for (i = 0; si[i] && out < max - 1; i++)
1919 1920 1921 1922 1923 1924
	{
		if (si[i] == '\n')
		{
			/* Only add the carriage-return if needed */
			if (i > 0 && si[i - 1] == '\r')
			{
1925 1926 1927 1928
				if (dst)
					dst[out++] = si[i];
				else
					out++;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1929 1930
				continue;
			}
1931
			*changed = TRUE;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1932

1933 1934 1935 1936 1937 1938 1939
			if (dst)
			{
				dst[out++] = '\r';
				dst[out++] = '\n';
			}
			else
				out += 2;
1940 1941
		}
		else
1942 1943 1944 1945 1946 1947
		{
			if (dst)
				dst[out++] = si[i];
			else
				out++;
		}
1948
	}
1949 1950
	if (dst)
		dst[out] = '\0';
1951
	return out;
1952 1953
}

1954 1955 1956 1957 1958

/*
 *	Change carriage-return/linefeed to just linefeed
 *	Plus, escape any special characters.
 */
1959
int
1960
convert_special_chars(const char *si, char *dst, int used)
1961
{
1962 1963 1964
	size_t		i = 0,
				out = 0,
				max;
1965
	char	   *p = NULL;
1966 1967 1968 1969 1970 1971


	if (used == SQL_NTS)
		max = strlen(si);
	else
		max = used;
1972 1973 1974 1975 1976
	if (dst)
	{
		p = dst;
		p[0] = '\0';
	}
Hiroshi Inoue's avatar
Hiroshi Inoue committed
1977 1978 1979
#ifdef MULTIBYTE
	multibyte_init();
#endif
1980

1981 1982
	for (i = 0; i < max; i++)
	{
1983 1984 1985 1986 1987 1988 1989 1990 1991
#ifdef MULTIBYTE
		if (multibyte_char_check(si[i]) != 0)
		{
			if (p)
				p[out] = si[i];
			out++;
			continue;
		}
#endif
1992
		if (si[i] == '\r' && si[i + 1] == '\n')
1993
			continue;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
1994
		else if (si[i] == '\'' || si[i] == '\\')
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
		{
			if (p)
				p[out++] = '\\';
			else
				out++;
		}
		if (p)
			p[out++] = si[i];
		else
			out++;
2005
	}
2006 2007 2008
	if (p)
		p[out] = '\0';
	return out;
2009 2010
}

2011

2012 2013
/*	!!! Need to implement this function !!!  */
int
2014
convert_pgbinary_to_char(const char *value, char *rgbValue, int cbValueMax)
2015
{
2016 2017 2018
	mylog("convert_pgbinary_to_char: value = '%s'\n", value);

	strncpy_null(rgbValue, value, cbValueMax);
2019 2020 2021
	return 0;
}

2022

2023
unsigned int
2024
conv_from_octal(const unsigned char *s)
2025
{
2026 2027
	int			i,
				y = 0;
2028

2029 2030
	for (i = 1; i <= 3; i++)
		y += (s[i] - 48) * (int) pow(8, 3 - i);
2031 2032

	return y;
2033

2034 2035
}

2036

Byron Nikolaidis's avatar
Byron Nikolaidis committed
2037
unsigned int
2038
conv_from_hex(const unsigned char *s)
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2039
{
2040 2041 2042
	int			i,
				y = 0,
				val;
2043

2044 2045 2046 2047 2048 2049 2050 2051
	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
2052

2053
		y += val * (int) pow(16, 2 - i);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2054 2055 2056 2057 2058
	}

	return y;
}

2059

2060
/*	convert octal escapes to bytes */
2061
int
2062
convert_from_pgbinary(const unsigned char *value, unsigned char *rgbValue, int cbValueMax)
2063
{
2064
	size_t		i, ilen = strlen(value);
2065
	int			o = 0;
2066

2067

2068
	for (i = 0; i < ilen;)
2069 2070 2071
	{
		if (value[i] == '\\')
		{
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
			if (value[i + 1] == '\\')
			{
				rgbValue[o] = value[i];
				i += 2;
			}
			else
			{
				rgbValue[o] = conv_from_octal(&value[i]);
				i += 4;
			}
2082
		}
2083
		else
2084 2085 2086 2087
			rgbValue[o] = value[i++];
		mylog("convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]);
		o++;
	}
2088

2089
	rgbValue[o] = '\0';			/* extra protection */
2090

2091 2092 2093 2094 2095 2096 2097
	return o;
}


char *
conv_to_octal(unsigned char val)
{
2098 2099
	int			i;
	static char x[6];
2100 2101 2102 2103 2104

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

2105 2106
	for (i = 4; i > 1; i--)
	{
2107 2108 2109 2110 2111 2112 2113
		x[i] = (val & 7) + 48;
		val >>= 3;
	}

	return x;
}

2114

2115
/*	convert non-ascii bytes to octal escape sequences */
2116
int
2117
convert_to_pgbinary(const unsigned char *in, char *out, int len)
2118
{
2119 2120
	int			i,
				o = 0;
2121

2122 2123
	for (i = 0; i < len; i++)
	{
2124
		mylog("convert_to_pgbinary: in[%d] = %d, %c\n", i, in[i], in[i]);
2125
		if (isalnum(in[i]) || in[i] == ' ')
2126
			out[o++] = in[i];
2127 2128 2129
		else
		{
			strcpy(&out[o], conv_to_octal(in[i]));
2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
			o += 5;
		}
	}

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

	return o;
}


Byron Nikolaidis's avatar
Byron Nikolaidis committed
2140
void
2141
encode(const char *in, char *out)
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2142
{
2143
	unsigned int i, ilen = strlen(in),
2144
				o = 0;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2145

2146
	for (i = 0; i < ilen; i++)
2147 2148 2149
	{
		if (in[i] == '+')
		{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2150 2151 2152
			sprintf(&out[o], "%%2B");
			o += 3;
		}
2153
		else if (isspace((unsigned char) in[i]))
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2154
			out[o++] = '+';
2155 2156
		else if (!isalnum((unsigned char) in[i]))
		{
2157
			sprintf(&out[o], "%%%02x", (unsigned char) in[i]);
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
			o += 3;
		}
		else
			out[o++] = in[i];
	}
	out[o++] = '\0';
}


void
2168
decode(const char *in, char *out)
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2169
{
2170
	unsigned int i, ilen = strlen(in),
2171
				o = 0;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2172

2173
	for (i = 0; i < ilen; i++)
2174
	{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2175 2176
		if (in[i] == '+')
			out[o++] = ' ';
2177 2178
		else if (in[i] == '%')
		{
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2179
			sprintf(&out[o++], "%c", conv_from_hex(&in[i]));
2180
			i += 2;
Byron Nikolaidis's avatar
Byron Nikolaidis committed
2181 2182 2183 2184 2185 2186 2187 2188
		}
		else
			out[o++] = in[i];
	}
	out[o++] = '\0';
}


2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
/*-------
 *	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.
 *-------
 */
2205
int
2206
convert_lo(StatementClass *stmt, const void *value, Int2 fCType, PTR rgbValue,
Bruce Momjian's avatar
Bruce Momjian committed
2207
		   SDWORD cbValueMax, SDWORD *pcbValue)
2208
{
2209 2210 2211 2212
	Oid			oid;
	int			retval,
				result,
				left = -1;
Tom Lane's avatar
Tom Lane committed
2213
	BindInfoClass *bindInfo = NULL;
2214 2215
	ConnectionClass	*conn = SC_get_conn(stmt);
	ConnInfo	*ci = &(conn->connInfo);
2216

2217
	/* If using SQLGetData, then current_col will be set */
2218 2219
	if (stmt->current_col >= 0)
	{
2220 2221 2222
		bindInfo = &stmt->bindings[stmt->current_col];
		left = bindInfo->data_left;
	}
2223

2224 2225 2226 2227
	/*
	 * if this is the first call for this column, open the large object
	 * for reading
	 */
2228

2229 2230
	if (!bindInfo || bindInfo->data_left == -1)
	{
2231
		/* begin transaction if needed */
2232
		if (!CC_is_in_trans(conn))
2233
		{
2234
			QResultClass *res;
2235
			char		ok;
2236

2237
			res = CC_send_query(conn, "BEGIN", NULL);
2238 2239
			if (!res)
			{
2240 2241 2242 2243 2244 2245
				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);
2246 2247
			if (!ok)
			{
2248 2249 2250 2251 2252
				stmt->errormsg = "Could not begin (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

2253
			CC_set_in_trans(conn);
2254 2255
		}

2256
		oid = atoi(value);
2257
		stmt->lobj_fd = lo_open(conn, oid, INV_READ);
2258 2259
		if (stmt->lobj_fd < 0)
		{
2260
			stmt->errornumber = STMT_EXEC_ERROR;
2261
			stmt->errormsg = "Couldnt open large object for reading.";
2262 2263
			return COPY_GENERAL_ERROR;
		}
2264

2265
		/* Get the size */
2266
		retval = lo_lseek(conn, stmt->lobj_fd, 0L, SEEK_END);
2267 2268
		if (retval >= 0)
		{
2269
			left = lo_tell(conn, stmt->lobj_fd);
2270 2271 2272
			if (bindInfo)
				bindInfo->data_left = left;

2273
			/* return to beginning */
2274
			lo_lseek(conn, stmt->lobj_fd, 0L, SEEK_SET);
2275 2276
		}
	}
2277
	mylog("lo data left = %d\n", left);
2278

2279
	if (left == 0)
2280
		return COPY_NO_DATA_FOUND;
2281

2282 2283
	if (stmt->lobj_fd < 0)
	{
2284 2285 2286 2287
		stmt->errornumber = STMT_EXEC_ERROR;
		stmt->errormsg = "Large object FD undefined for multiple read.";
		return COPY_GENERAL_ERROR;
	}
2288

2289
	retval = lo_read(conn, stmt->lobj_fd, (char *) rgbValue, cbValueMax);
2290 2291
	if (retval < 0)
	{
2292
		lo_close(conn, stmt->lobj_fd);
2293 2294

		/* commit transaction if needed */
2295
		if (!ci->drivers.use_declarefetch && CC_is_in_autocommit(conn))
2296
		{
2297
			QResultClass *res;
2298
			char		ok;
2299

2300
			res = CC_send_query(conn, "COMMIT", NULL);
2301 2302
			if (!res)
			{
2303 2304 2305 2306 2307 2308
				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);
2309 2310
			if (!ok)
			{
2311 2312 2313 2314 2315
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

2316
			CC_set_no_trans(conn);
2317 2318
		}

2319 2320 2321 2322 2323 2324 2325
		stmt->lobj_fd = -1;

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

2326 2327 2328 2329 2330 2331 2332
	if (retval < left)
		result = COPY_RESULT_TRUNCATED;
	else
		result = COPY_OK;

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

2334
	if (bindInfo && bindInfo->data_left > 0)
2335
		bindInfo->data_left -= retval;
2336

2337 2338
	if (!bindInfo || bindInfo->data_left == 0)
	{
2339
		lo_close(conn, stmt->lobj_fd);
2340 2341

		/* commit transaction if needed */
2342
		if (!ci->drivers.use_declarefetch && CC_is_in_autocommit(conn))
2343
		{
2344
			QResultClass *res;
2345
			char		ok;
2346

2347
			res = CC_send_query(conn, "COMMIT", NULL);
2348 2349
			if (!res)
			{
2350 2351 2352 2353 2354 2355
				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);
2356 2357
			if (!ok)
			{
2358 2359 2360 2361 2362
				stmt->errormsg = "Could not commit (in-line) a transaction";
				stmt->errornumber = STMT_EXEC_ERROR;
				return COPY_GENERAL_ERROR;
			}

2363
			CC_set_no_trans(conn);
2364 2365
		}

2366
		stmt->lobj_fd = -1;		/* prevent further reading */
2367
	}
2368 2369

	return result;
2370
}