Exemplo n.º 1
0
bool
ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
			 enum ECPGttype type, enum ECPGttype ind_type,
			 char *var, char *ind, long varcharsize, long offset,
			 long ind_offset, enum ARRAY_TYPE isarray, enum COMPAT_MODE compat, bool force_indicator)
{
	struct sqlca_t *sqlca = ECPGget_sqlca();
	char	   *pval = (char *) PQgetvalue(results, act_tuple, act_field);
	int			binary = PQfformat(results, act_field);
	int			size = PQgetlength(results, act_tuple, act_field);
	int			value_for_indicator = 0;
	long		log_offset;

	/*
	 * use a global variable to see if the environment variable
	 * ECPG_REGRESSION is set or not. Remember the state in order to avoid
	 * subsequent calls to getenv() for this purpose.
	 */
	if (ECPG_regression_mode == NOT_CHECKED)
	{
		if (getenv("ECPG_REGRESSION"))
			ECPG_regression_mode = REGRESS;
		else
			ECPG_regression_mode = NORMAL;
	}

	/*
	 * If we are running in a regression test, do not log the offset variable,
	 * it depends on the machine's alignment.
	 */
	if (ECPG_regression_mode == REGRESS)
		log_offset = -1;
	else
		log_offset = offset;

	ECPGlog("ECPGget_data line %d: RESULT: %s offset: %ld array: %s\n", lineno, pval ? (binary ? "BINARY" : pval) : "EMPTY", log_offset, isarray ? "Yes" : "No");

	/* We will have to decode the value */

	/*
	 * check for null value and set indicator accordingly, i.e. -1 if NULL and
	 * 0 if not
	 */
	if (PQgetisnull(results, act_tuple, act_field))
		value_for_indicator = -1;

	switch (ind_type)
	{
		case ECPGt_short:
		case ECPGt_unsigned_short:
			*((short *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
		case ECPGt_int:
		case ECPGt_unsigned_int:
			*((int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
		case ECPGt_long:
		case ECPGt_unsigned_long:
			*((long *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
#ifdef HAVE_LONG_LONG_INT_64
		case ECPGt_long_long:
		case ECPGt_unsigned_long_long:
			*((long long int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
#endif   /* HAVE_LONG_LONG_INT_64 */
		case ECPGt_NO_INDICATOR:
			if (value_for_indicator == -1)
			{
				if (force_indicator == false)
				{
					/*
					 * Informix has an additional way to specify NULLs note
					 * that this uses special values to denote NULL
					 */
					ECPGset_noind_null(type, var + offset * act_tuple);
				}
				else
				{
					ECPGraise(lineno, ECPG_MISSING_INDICATOR,
							  ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER,
							  NULL);
					return (false);
				}
			}
			break;
		default:
			ECPGraise(lineno, ECPG_UNSUPPORTED,
					  ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
					  ECPGtype_name(ind_type));
			return (false);
			break;
	}

	if (value_for_indicator == -1)
		return (true);

	/* pval is a pointer to the value */
	/* let's check if it really is an array if it should be one */
	if (isarray == ECPG_ARRAY_ARRAY)
	{
		if (!pval || *pval != '{')
		{
			ECPGraise(lineno, ECPG_DATA_NOT_ARRAY,
					  ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
			return (false);
		}

		switch (type)
		{
			case ECPGt_char:
			case ECPGt_unsigned_char:
			case ECPGt_varchar:
				break;

			default:
				pval++;
				break;
		}
	}

	do
	{
		if (binary)
		{
			if (pval)
			{
				if (varcharsize == 0 || varcharsize * offset >= size)
					memcpy((char *) ((long) var + offset * act_tuple),
						   pval, size);
				else
				{
					memcpy((char *) ((long) var + offset * act_tuple),
						   pval, varcharsize * offset);

					if (varcharsize * offset < size)
					{
						/* truncation */
						switch (ind_type)
						{
							case ECPGt_short:
							case ECPGt_unsigned_short:
								*((short *) (ind + ind_offset * act_tuple)) = size;
								break;
							case ECPGt_int:
							case ECPGt_unsigned_int:
								*((int *) (ind + ind_offset * act_tuple)) = size;
								break;
							case ECPGt_long:
							case ECPGt_unsigned_long:
								*((long *) (ind + ind_offset * act_tuple)) = size;
								break;
#ifdef HAVE_LONG_LONG_INT_64
							case ECPGt_long_long:
							case ECPGt_unsigned_long_long:
								*((long long int *) (ind + ind_offset * act_tuple)) = size;
								break;
#endif   /* HAVE_LONG_LONG_INT_64 */
							default:
								break;
						}
						sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
					}
				}
				pval += size;
			}
		}
		else
		{
			switch (type)
			{
					long		res;
					unsigned long ures;
					double		dres;
					char	   *scan_length;
					numeric    *nres;
					date		ddres;
					timestamp	tres;
					interval   *ires;

				case ECPGt_short:
				case ECPGt_int:
				case ECPGt_long:
					if (pval)
					{
						res = strtol(pval, &scan_length, 10);
						if (garbage_left(isarray, scan_length, compat))
						{
							ECPGraise(lineno, ECPG_INT_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
						pval = scan_length;
					}
					else
						res = 0L;

					switch (type)
					{
						case ECPGt_short:
							*((short *) (var + offset * act_tuple)) = (short) res;
							break;
						case ECPGt_int:
							*((int *) (var + offset * act_tuple)) = (int) res;
							break;
						case ECPGt_long:
							*((long *) (var + offset * act_tuple)) = (long) res;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

				case ECPGt_unsigned_short:
				case ECPGt_unsigned_int:
				case ECPGt_unsigned_long:
					if (pval)
					{
						ures = strtoul(pval, &scan_length, 10);
						if (garbage_left(isarray, scan_length, compat))
						{
							ECPGraise(lineno, ECPG_UINT_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
						pval = scan_length;
					}
					else
						ures = 0L;

					switch (type)
					{
						case ECPGt_unsigned_short:
							*((unsigned short *) (var + offset * act_tuple)) = (unsigned short) ures;
							break;
						case ECPGt_unsigned_int:
							*((unsigned int *) (var + offset * act_tuple)) = (unsigned int) ures;
							break;
						case ECPGt_unsigned_long:
							*((unsigned long *) (var + offset * act_tuple)) = (unsigned long) ures;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

#ifdef HAVE_LONG_LONG_INT_64
#ifdef HAVE_STRTOLL
				case ECPGt_long_long:
					if (pval)
					{
						*((long long int *) (var + offset * act_tuple)) = strtoll(pval, &scan_length, 10);
						if (garbage_left(isarray, scan_length, compat))
						{
							ECPGraise(lineno, ECPG_INT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
						pval = scan_length;
					}
					else
						*((long long int *) (var + offset * act_tuple)) = (long long) 0;

					break;
#endif   /* HAVE_STRTOLL */
#ifdef HAVE_STRTOULL
				case ECPGt_unsigned_long_long:
					if (pval)
					{
						*((unsigned long long int *) (var + offset * act_tuple)) = strtoull(pval, &scan_length, 10);
						if ((isarray && *scan_length != ',' && *scan_length != '}')
							|| (!isarray && !(INFORMIX_MODE(compat) && *scan_length == '.') && *scan_length != '\0' && *scan_length != ' '))	/* Garbage left */
						{
							ECPGraise(lineno, ECPG_UINT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
						pval = scan_length;
					}
					else
						*((unsigned long long int *) (var + offset * act_tuple)) = (long long) 0;

					break;
#endif   /* HAVE_STRTOULL */
#endif   /* HAVE_LONG_LONG_INT_64 */

				case ECPGt_float:
				case ECPGt_double:
					if (pval)
					{
						if (isarray && *pval == '"')
							dres = strtod(pval + 1, &scan_length);
						else
							dres = strtod(pval, &scan_length);

						if (isarray && *scan_length == '"')
							scan_length++;

						if (garbage_left(isarray, scan_length, compat))
						{
							ECPGraise(lineno, ECPG_FLOAT_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
						pval = scan_length;
					}
					else
						dres = 0.0;

					switch (type)
					{
						case ECPGt_float:
							*((float *) (var + offset * act_tuple)) = dres;
							break;
						case ECPGt_double:
							*((double *) (var + offset * act_tuple)) = dres;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

				case ECPGt_bool:
					if (pval)
					{
						if (pval[0] == 'f' && pval[1] == '\0')
						{
							if (offset == sizeof(char))
								*((char *) (var + offset * act_tuple)) = false;
							else if (offset == sizeof(int))
								*((int *) (var + offset * act_tuple)) = false;
							else
								ECPGraise(lineno, ECPG_CONVERT_BOOL,
										  ECPG_SQLSTATE_DATATYPE_MISMATCH,
										  "different size");
							break;
						}
						else if (pval[0] == 't' && pval[1] == '\0')
						{
							if (offset == sizeof(char))
								*((char *) (var + offset * act_tuple)) = true;
							else if (offset == sizeof(int))
								*((int *) (var + offset * act_tuple)) = true;
							else
								ECPGraise(lineno, ECPG_CONVERT_BOOL,
										  ECPG_SQLSTATE_DATATYPE_MISMATCH,
										  "different size");
							break;
						}
						else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
						{
							/* NULL is valid */
							break;
						}
					}

					ECPGraise(lineno, ECPG_CONVERT_BOOL,
							  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
					return (false);
					break;

				case ECPGt_char:
				case ECPGt_unsigned_char:
					if (pval)
					{
						if (varcharsize == 0 || varcharsize > size)
							strncpy((char *) ((long) var + offset * act_tuple), pval, size + 1);
						else
						{
							strncpy((char *) ((long) var + offset * act_tuple), pval, varcharsize);

							if (varcharsize < size)
							{
								/* truncation */
								switch (ind_type)
								{
									case ECPGt_short:
									case ECPGt_unsigned_short:
										*((short *) (ind + ind_offset * act_tuple)) = size;
										break;
									case ECPGt_int:
									case ECPGt_unsigned_int:
										*((int *) (ind + ind_offset * act_tuple)) = size;
										break;
									case ECPGt_long:
									case ECPGt_unsigned_long:
										*((long *) (ind + ind_offset * act_tuple)) = size;
										break;
#ifdef HAVE_LONG_LONG_INT_64
									case ECPGt_long_long:
									case ECPGt_unsigned_long_long:
										*((long long int *) (ind + ind_offset * act_tuple)) = size;
										break;
#endif   /* HAVE_LONG_LONG_INT_64 */
									default:
										break;
								}
								sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
							}
						}
						pval += size;
					}
					break;

				case ECPGt_varchar:
					if (pval)
					{
						struct ECPGgeneric_varchar *variable =
						(struct ECPGgeneric_varchar *) ((long) var + offset * act_tuple);

						variable->len = size;
						if (varcharsize == 0)
							strncpy(variable->arr, pval, variable->len);
						else
						{
							strncpy(variable->arr, pval, varcharsize);

							if (variable->len > varcharsize)
							{
								/* truncation */
								switch (ind_type)
								{
									case ECPGt_short:
									case ECPGt_unsigned_short:
										*((short *) (ind + offset * act_tuple)) = variable->len;
										break;
									case ECPGt_int:
									case ECPGt_unsigned_int:
										*((int *) (ind + offset * act_tuple)) = variable->len;
										break;
									case ECPGt_long:
									case ECPGt_unsigned_long:
										*((long *) (ind + offset * act_tuple)) = variable->len;
										break;
#ifdef HAVE_LONG_LONG_INT_64
									case ECPGt_long_long:
									case ECPGt_unsigned_long_long:
										*((long long int *) (ind + ind_offset * act_tuple)) = variable->len;
										break;
#endif   /* HAVE_LONG_LONG_INT_64 */
									default:
										break;
								}
								sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';

								variable->len = varcharsize;
							}
						}
						pval += size;
					}
					break;

				case ECPGt_decimal:
				case ECPGt_numeric:
					if (pval)
					{
						if (isarray && *pval == '"')
							nres = PGTYPESnumeric_from_asc(pval + 1, &scan_length);
						else
							nres = PGTYPESnumeric_from_asc(pval, &scan_length);

						/* did we get an error? */
						if (nres == NULL)
						{
							ECPGlog("ECPGget_data line %d: RESULT: %s errno %d\n",
									lineno, pval ? pval : "", errno);

							if (INFORMIX_MODE(compat))
							{
								/*
								 * Informix wants its own NULL value here
								 * instead of an error
								 */
								nres = PGTYPESnumeric_new();
								if (nres)
									ECPGset_noind_null(ECPGt_numeric, nres);
								else
								{
									ECPGraise(lineno, ECPG_OUT_OF_MEMORY,
									 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
									return (false);
								}
							}
							else
							{
								ECPGraise(lineno, ECPG_NUMERIC_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						else
						{
							if (isarray && *scan_length == '"')
								scan_length++;

							if (garbage_left(isarray, scan_length, compat))
							{
								free(nres);
								ECPGraise(lineno, ECPG_NUMERIC_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						pval = scan_length;
					}
					else
						nres = PGTYPESnumeric_from_asc("0.0", &scan_length);

					if (type == ECPGt_numeric)
						PGTYPESnumeric_copy(nres, (numeric *) (var + offset * act_tuple));
					else
						PGTYPESnumeric_to_decimal(nres, (decimal *) (var + offset * act_tuple));

					free(nres);
					break;

				case ECPGt_interval:
					if (pval)
					{
						if (isarray && *pval == '"')
							ires = PGTYPESinterval_from_asc(pval + 1, &scan_length);
						else
							ires = PGTYPESinterval_from_asc(pval, &scan_length);

						/* did we get an error? */
						if (ires == NULL)
						{
							if (INFORMIX_MODE(compat))
							{
								/*
								 * Informix wants its own NULL value here
								 * instead of an error
								 */
								ires = (interval *) ECPGalloc(sizeof(interval), lineno);
								if (!ires)
									return (false);

								ECPGset_noind_null(ECPGt_interval, ires);
							}
							else
							{
								ECPGraise(lineno, ECPG_INTERVAL_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						else
						{
							if (isarray && *scan_length == '"')
								scan_length++;

							if (garbage_left(isarray, scan_length, compat))
							{
								free(ires);
								ECPGraise(lineno, ECPG_INTERVAL_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						pval = scan_length;
					}
					else
						ires = PGTYPESinterval_from_asc("0 seconds", NULL);

					PGTYPESinterval_copy(ires, (interval *) (var + offset * act_tuple));
					free(ires);
					break;
				case ECPGt_date:
					if (pval)
					{
						if (isarray && *pval == '"')
							ddres = PGTYPESdate_from_asc(pval + 1, &scan_length);
						else
							ddres = PGTYPESdate_from_asc(pval, &scan_length);

						/* did we get an error? */
						if (errno != 0)
						{
							if (INFORMIX_MODE(compat))
							{
								/*
								 * Informix wants its own NULL value here
								 * instead of an error
								 */
								ECPGset_noind_null(ECPGt_date, &ddres);
							}
							else
							{
								ECPGraise(lineno, ECPG_DATE_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						else
						{
							if (isarray && *scan_length == '"')
								scan_length++;

							if (garbage_left(isarray, scan_length, compat))
							{
								ECPGraise(lineno, ECPG_DATE_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}

						*((date *) (var + offset * act_tuple)) = ddres;
						pval = scan_length;
					}
					break;

				case ECPGt_timestamp:
					if (pval)
					{
						if (isarray && *pval == '"')
							tres = PGTYPEStimestamp_from_asc(pval + 1, &scan_length);
						else
							tres = PGTYPEStimestamp_from_asc(pval, &scan_length);

						/* did we get an error? */
						if (errno != 0)
						{
							if (INFORMIX_MODE(compat))
							{
								/*
								 * Informix wants its own NULL value here
								 * instead of an error
								 */
								ECPGset_noind_null(ECPGt_timestamp, &tres);
							}
							else
							{
								ECPGraise(lineno, ECPG_TIMESTAMP_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}
						else
						{
							if (isarray && *scan_length == '"')
								scan_length++;

							if (garbage_left(isarray, scan_length, compat))
							{
								ECPGraise(lineno, ECPG_TIMESTAMP_FORMAT,
									  ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
								return (false);
							}
						}

						*((timestamp *) (var + offset * act_tuple)) = tres;
						pval = scan_length;
					}
					break;

				default:
					ECPGraise(lineno, ECPG_UNSUPPORTED,
							  ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
							  ECPGtype_name(type));
					return (false);
					break;
			}
			if (isarray == ECPG_ARRAY_ARRAY)
			{
				bool		string = false;

				/* set array to next entry */
				++act_tuple;

				/* set pval to the next entry */
				for (; string || (*pval != ',' && *pval != '}' && *pval != '\0'); ++pval)
					if (*pval == '"')
						string = string ? false : true;

				if (*pval == ',')
					++pval;
			}
			else if (isarray == ECPG_ARRAY_VECTOR)
			{
				bool		string = false;

				/* set array to next entry */
				++act_tuple;

				/* set pval to the next entry */
				for (; string || (*pval != ' ' && *pval != '\0'); ++pval)
					if (*pval == '"')
						string = string ? false : true;

				if (*pval == ' ')
					++pval;
			}
		}
	} while (*pval != '\0' && ((isarray == ECPG_ARRAY_ARRAY && *pval != '}') || isarray == ECPG_ARRAY_VECTOR));

	return (true);
}
Exemplo n.º 2
0
bool
ecpg_get_data(const PGresult *results, int act_tuple, int act_field, int lineno,
			  enum ECPGttype type, enum ECPGttype ind_type,
			  char *var, char *ind, long varcharsize, long offset,
			  long ind_offset, enum ARRAY_TYPE isarray, enum COMPAT_MODE compat, bool force_indicator)
{
	struct sqlca_t *sqlca = ECPGget_sqlca();
	char	   *pval = (char *) PQgetvalue(results, act_tuple, act_field);
	int			binary = PQfformat(results, act_field);
	int			size = PQgetlength(results, act_tuple, act_field);
	int			value_for_indicator = 0;
	long		log_offset;

	/*
	 * If we are running in a regression test, do not log the offset variable,
	 * it depends on the machine's alignment.
	 */
	if (ecpg_internal_regression_mode)
		log_offset = -1;
	else
		log_offset = offset;

	ecpg_log("ecpg_get_data on line %d: RESULT: %s offset: %ld; array: %s\n", lineno, pval ? (binary ? "BINARY" : pval) : "EMPTY", log_offset, ECPG_IS_ARRAY(isarray) ? "yes" : "no");

	/* pval is a pointer to the value */
	if (!pval)
	{
		/*
		 * This should never happen because we already checked that we found
		 * at least one tuple, but let's play it safe.
		 */
		ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
		return (false);
	}

	/* We will have to decode the value */

	/*
	 * check for null value and set indicator accordingly, i.e. -1 if NULL and
	 * 0 if not
	 */
	if (PQgetisnull(results, act_tuple, act_field))
		value_for_indicator = -1;

	switch (ind_type)
	{
		case ECPGt_short:
		case ECPGt_unsigned_short:
			*((short *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
		case ECPGt_int:
		case ECPGt_unsigned_int:
			*((int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
		case ECPGt_long:
		case ECPGt_unsigned_long:
			*((long *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
#ifdef HAVE_LONG_LONG_INT
		case ECPGt_long_long:
		case ECPGt_unsigned_long_long:
			*((long long int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
			break;
#endif   /* HAVE_LONG_LONG_INT */
		case ECPGt_NO_INDICATOR:
			if (value_for_indicator == -1)
			{
				if (force_indicator == false)
				{
					/*
					 * Informix has an additional way to specify NULLs note
					 * that this uses special values to denote NULL
					 */
					ECPGset_noind_null(type, var + offset * act_tuple);
				}
				else
				{
					ecpg_raise(lineno, ECPG_MISSING_INDICATOR,
							 ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER,
							   NULL);
					return (false);
				}
			}
			break;
		default:
			ecpg_raise(lineno, ECPG_UNSUPPORTED,
					   ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
					   ecpg_type_name(ind_type));
			return (false);
			break;
	}

	if (value_for_indicator == -1)
		return (true);

	/* let's check if it really is an array if it should be one */
	if (isarray == ECPG_ARRAY_ARRAY)
	{
		if (*pval != '{')
		{
			ecpg_raise(lineno, ECPG_DATA_NOT_ARRAY,
					   ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
			return (false);
		}

		switch (type)
		{
			case ECPGt_char:
			case ECPGt_unsigned_char:
			case ECPGt_varchar:
			case ECPGt_string:
				break;

			default:
				pval++;
				break;
		}
	}

	do
	{
		if (binary)
		{
			if (varcharsize == 0 || varcharsize * offset >= size)
				memcpy(var + offset * act_tuple, pval, size);
			else
			{
				memcpy(var + offset * act_tuple, pval, varcharsize * offset);

				if (varcharsize * offset < size)
				{
					/* truncation */
					switch (ind_type)
					{
						case ECPGt_short:
						case ECPGt_unsigned_short:
							*((short *) (ind + ind_offset * act_tuple)) = size;
							break;
						case ECPGt_int:
						case ECPGt_unsigned_int:
							*((int *) (ind + ind_offset * act_tuple)) = size;
							break;
						case ECPGt_long:
						case ECPGt_unsigned_long:
							*((long *) (ind + ind_offset * act_tuple)) = size;
							break;
#ifdef HAVE_LONG_LONG_INT
						case ECPGt_long_long:
						case ECPGt_unsigned_long_long:
							*((long long int *) (ind + ind_offset * act_tuple)) = size;
							break;
#endif   /* HAVE_LONG_LONG_INT */
						default:
							break;
					}
					sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
				}
			}
			pval += size;
		}
		else
		{
			switch (type)
			{
					long		res;
					unsigned long ures;
					double		dres;
					char	   *scan_length;
					numeric    *nres;
					date		ddres;
					timestamp	tres;
					interval   *ires;

				case ECPGt_short:
				case ECPGt_int:
				case ECPGt_long:
					res = strtol(pval, &scan_length, 10);
					if (garbage_left(isarray, scan_length, compat))
					{
						ecpg_raise(lineno, ECPG_INT_FORMAT,
								   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
						return (false);
					}
					pval = scan_length;

					switch (type)
					{
						case ECPGt_short:
							*((short *) (var + offset * act_tuple)) = (short) res;
							break;
						case ECPGt_int:
							*((int *) (var + offset * act_tuple)) = (int) res;
							break;
						case ECPGt_long:
							*((long *) (var + offset * act_tuple)) = (long) res;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

				case ECPGt_unsigned_short:
				case ECPGt_unsigned_int:
				case ECPGt_unsigned_long:
					ures = strtoul(pval, &scan_length, 10);
					if (garbage_left(isarray, scan_length, compat))
					{
						ecpg_raise(lineno, ECPG_UINT_FORMAT,
								   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
						return (false);
					}
					pval = scan_length;

					switch (type)
					{
						case ECPGt_unsigned_short:
							*((unsigned short *) (var + offset * act_tuple)) = (unsigned short) ures;
							break;
						case ECPGt_unsigned_int:
							*((unsigned int *) (var + offset * act_tuple)) = (unsigned int) ures;
							break;
						case ECPGt_unsigned_long:
							*((unsigned long *) (var + offset * act_tuple)) = (unsigned long) ures;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

#ifdef HAVE_LONG_LONG_INT
#ifdef HAVE_STRTOLL
				case ECPGt_long_long:
					*((long long int *) (var + offset * act_tuple)) = strtoll(pval, &scan_length, 10);
					if (garbage_left(isarray, scan_length, compat))
					{
						ecpg_raise(lineno, ECPG_INT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
						return (false);
					}
					pval = scan_length;

					break;
#endif   /* HAVE_STRTOLL */
#ifdef HAVE_STRTOULL
				case ECPGt_unsigned_long_long:
					*((unsigned long long int *) (var + offset * act_tuple)) = strtoull(pval, &scan_length, 10);
					if ((isarray && *scan_length != ',' && *scan_length != '}')
						|| (!isarray && !(INFORMIX_MODE(compat) && *scan_length == '.') && *scan_length != '\0' && *scan_length != ' '))		/* Garbage left */
					{
						ecpg_raise(lineno, ECPG_UINT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
						return (false);
					}
					pval = scan_length;

					break;
#endif   /* HAVE_STRTOULL */
#endif   /* HAVE_LONG_LONG_INT */

				case ECPGt_float:
				case ECPGt_double:
					if (isarray && *pval == '"')
						pval++;

					if (!check_special_value(pval, &dres, &scan_length))
						dres = strtod(pval, &scan_length);

					if (isarray && *scan_length == '"')
						scan_length++;

					if (garbage_left(isarray, scan_length, compat))
					{
						ecpg_raise(lineno, ECPG_FLOAT_FORMAT,
								   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
						return (false);
					}
					pval = scan_length;

					switch (type)
					{
						case ECPGt_float:
							*((float *) (var + offset * act_tuple)) = dres;
							break;
						case ECPGt_double:
							*((double *) (var + offset * act_tuple)) = dres;
							break;
						default:
							/* Cannot happen */
							break;
					}
					break;

				case ECPGt_bool:
					if (pval[0] == 'f' && pval[1] == '\0')
					{
						if (offset == sizeof(char))
							*((char *) (var + offset * act_tuple)) = false;
						else if (offset == sizeof(int))
							*((int *) (var + offset * act_tuple)) = false;
						else
							ecpg_raise(lineno, ECPG_CONVERT_BOOL,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH,
									   NULL);
						pval++;
						break;
					}
					else if (pval[0] == 't' && pval[1] == '\0')
					{
						if (offset == sizeof(char))
							*((char *) (var + offset * act_tuple)) = true;
						else if (offset == sizeof(int))
							*((int *) (var + offset * act_tuple)) = true;
						else
							ecpg_raise(lineno, ECPG_CONVERT_BOOL,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH,
									   NULL);
						pval++;
						break;
					}
					else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
					{
						/* NULL is valid */
						break;
					}

					ecpg_raise(lineno, ECPG_CONVERT_BOOL,
							   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
					return (false);
					break;

				case ECPGt_char:
				case ECPGt_unsigned_char:
				case ECPGt_string:
					{
						char	   *str = (char *) (var + offset * act_tuple);

						/*
						 * If varcharsize is unknown and the offset is that of
						 * char *, then this variable represents the array of
						 * character pointers. So, use extra indirection.
						 */
						if (varcharsize == 0 && offset == sizeof(char *))
							str = *(char **)str;

						if (varcharsize == 0 || varcharsize > size)
						{
							strncpy(str, pval, size + 1);
							/* do the rtrim() */
							if (type == ECPGt_string)
							{
								char	   *last = str + size;

								while (last > str && (*last == ' ' || *last == '\0'))
								{
									*last = '\0';
									last--;
								}
							}
						}
						else
						{
							strncpy(str, pval, varcharsize);

							if (varcharsize < size)
							{
								/* truncation */
								switch (ind_type)
								{
									case ECPGt_short:
									case ECPGt_unsigned_short:
										*((short *) (ind + ind_offset * act_tuple)) = size;
										break;
									case ECPGt_int:
									case ECPGt_unsigned_int:
										*((int *) (ind + ind_offset * act_tuple)) = size;
										break;
									case ECPGt_long:
									case ECPGt_unsigned_long:
										*((long *) (ind + ind_offset * act_tuple)) = size;
										break;
#ifdef HAVE_LONG_LONG_INT
									case ECPGt_long_long:
									case ECPGt_unsigned_long_long:
										*((long long int *) (ind + ind_offset * act_tuple)) = size;
										break;
#endif   /* HAVE_LONG_LONG_INT */
									default:
										break;
								}
								sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
							}
						}
						pval += size;
					}
					break;

				case ECPGt_varchar:
					{
						struct ECPGgeneric_varchar *variable =
						(struct ECPGgeneric_varchar *) (var + offset * act_tuple);

						variable->len = size;
						if (varcharsize == 0)
							strncpy(variable->arr, pval, variable->len);
						else
						{
							strncpy(variable->arr, pval, varcharsize);

							if (variable->len > varcharsize)
							{
								/* truncation */
								switch (ind_type)
								{
									case ECPGt_short:
									case ECPGt_unsigned_short:
										*((short *) (ind + ind_offset * act_tuple)) = variable->len;
										break;
									case ECPGt_int:
									case ECPGt_unsigned_int:
										*((int *) (ind + ind_offset * act_tuple)) = variable->len;
										break;
									case ECPGt_long:
									case ECPGt_unsigned_long:
										*((long *) (ind + ind_offset * act_tuple)) = variable->len;
										break;
#ifdef HAVE_LONG_LONG_INT
									case ECPGt_long_long:
									case ECPGt_unsigned_long_long:
										*((long long int *) (ind + ind_offset * act_tuple)) = variable->len;
										break;
#endif   /* HAVE_LONG_LONG_INT */
									default:
										break;
								}
								sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';

								variable->len = varcharsize;
							}
						}
						pval += size;
					}
					break;

				case ECPGt_decimal:
				case ECPGt_numeric:
					if (isarray && *pval == '"')
						nres = PGTYPESnumeric_from_asc(pval + 1, &scan_length);
					else
						nres = PGTYPESnumeric_from_asc(pval, &scan_length);

					/* did we get an error? */
					if (nres == NULL)
					{
						ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
								 lineno, pval ? pval : "", errno);

						if (INFORMIX_MODE(compat))
						{
							/*
							 * Informix wants its own NULL value here instead
							 * of an error
							 */
							nres = PGTYPESnumeric_new();
							if (nres)
								ECPGset_noind_null(ECPGt_numeric, nres);
							else
							{
								ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
									 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
								return (false);
							}
						}
						else
						{
							ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					else
					{
						if (isarray && *scan_length == '"')
							scan_length++;

						if (garbage_left(isarray, scan_length, compat))
						{
							free(nres);
							ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					pval = scan_length;

					if (type == ECPGt_numeric)
						PGTYPESnumeric_copy(nres, (numeric *) (var + offset * act_tuple));
					else
						PGTYPESnumeric_to_decimal(nres, (decimal *) (var + offset * act_tuple));

					PGTYPESnumeric_free(nres);
					break;

				case ECPGt_interval:
					if (isarray && *pval == '"')
						ires = PGTYPESinterval_from_asc(pval + 1, &scan_length);
					else
						ires = PGTYPESinterval_from_asc(pval, &scan_length);

					/* did we get an error? */
					if (ires == NULL)
					{
						ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
								 lineno, pval ? pval : "", errno);

						if (INFORMIX_MODE(compat))
						{
							/*
							 * Informix wants its own NULL value here instead
							 * of an error
							 */
							ires = (interval *) ecpg_alloc(sizeof(interval), lineno);
							if (!ires)
								return (false);

							ECPGset_noind_null(ECPGt_interval, ires);
						}
						else
						{
							ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					else
					{
						if (isarray && *scan_length == '"')
							scan_length++;

						if (garbage_left(isarray, scan_length, compat))
						{
							free(ires);
							ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					pval = scan_length;

					PGTYPESinterval_copy(ires, (interval *) (var + offset * act_tuple));
					free(ires);
					break;

				case ECPGt_date:
					if (isarray && *pval == '"')
						ddres = PGTYPESdate_from_asc(pval + 1, &scan_length);
					else
						ddres = PGTYPESdate_from_asc(pval, &scan_length);

					/* did we get an error? */
					if (errno != 0)
					{
						ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
								 lineno, pval ? pval : "", errno);

						if (INFORMIX_MODE(compat))
						{
							/*
							 * Informix wants its own NULL value here instead
							 * of an error
							 */
							ECPGset_noind_null(ECPGt_date, &ddres);
						}
						else
						{
							ecpg_raise(lineno, ECPG_DATE_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					else
					{
						if (isarray && *scan_length == '"')
							scan_length++;

						if (garbage_left(isarray, scan_length, compat))
						{
							ecpg_raise(lineno, ECPG_DATE_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}

					*((date *) (var + offset * act_tuple)) = ddres;
					pval = scan_length;
					break;

				case ECPGt_timestamp:
					if (isarray && *pval == '"')
						tres = PGTYPEStimestamp_from_asc(pval + 1, &scan_length);
					else
						tres = PGTYPEStimestamp_from_asc(pval, &scan_length);

					/* did we get an error? */
					if (errno != 0)
					{
						ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
								 lineno, pval ? pval : "", errno);

						if (INFORMIX_MODE(compat))
						{
							/*
							 * Informix wants its own NULL value here instead
							 * of an error
							 */
							ECPGset_noind_null(ECPGt_timestamp, &tres);
						}
						else
						{
							ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}
					else
					{
						if (isarray && *scan_length == '"')
							scan_length++;

						if (garbage_left(isarray, scan_length, compat))
						{
							ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
									   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
							return (false);
						}
					}

					*((timestamp *) (var + offset * act_tuple)) = tres;
					pval = scan_length;
					break;

				default:
					ecpg_raise(lineno, ECPG_UNSUPPORTED,
							   ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
							   ecpg_type_name(type));
					return (false);
					break;
			}
			if (ECPG_IS_ARRAY(isarray))
			{
				bool		string = false;

				/* set array to next entry */
				++act_tuple;

				/* set pval to the next entry */

				/*
				 * *pval != '\0' should not be needed, but is used as a safety
				 * guard
				 */
				for (; *pval != '\0' && (string || (!array_delimiter(isarray, *pval) && !array_boundary(isarray, *pval))); ++pval)
					if (*pval == '"')
						string = string ? false : true;

				if (array_delimiter(isarray, *pval))
					++pval;
			}
		}
	} while (*pval != '\0' && !array_boundary(isarray, *pval));

	return (true);
}
Exemplo n.º 3
0
int
main(void)
{
	/* exec sql begin declare section */
		 
		  
		 
		 
		 
	
#line 62 "dt_test2.pgc"
 date date1 ;
 
#line 63 "dt_test2.pgc"
 timestamp ts1 , ts2 ;
 
#line 64 "dt_test2.pgc"
 char * text ;
 
#line 65 "dt_test2.pgc"
 interval * i1 ;
 
#line 66 "dt_test2.pgc"
 date * dc ;
/* exec sql end declare section */
#line 67 "dt_test2.pgc"


	int i, j;
	char *endptr;

	ECPGdebug(1, stderr);

	ts1 = PGTYPEStimestamp_from_asc("2003-12-04 17:34:29", NULL);
	text = PGTYPEStimestamp_to_asc(ts1);

	printf("timestamp: %s\n", text);
	free(text);

	date1 = PGTYPESdate_from_timestamp(ts1);
	dc = PGTYPESdate_new();
	*dc = date1;
	text = PGTYPESdate_to_asc(*dc);
	printf("Date of timestamp: %s\n", text);
	free(text);
	PGTYPESdate_free(dc);

	for (i = 0; dates[i]; i++)
	{
		bool err = false;
		date1 = PGTYPESdate_from_asc(dates[i], &endptr);
		if (date1 == INT_MIN) {
			err = true;
		}
		text = PGTYPESdate_to_asc(date1);
		printf("Date[%d]: %s (%c - %c)\n",
					i, err ? "-" : text,
					endptr ? 'N' : 'Y',
					err ? 'T' : 'F');
		free(text);
		if (!err)
		{
			for (j = 0; times[j]; j++)
			{
				int length = strlen(dates[i])
						+ 1
						+ strlen(times[j])
						+ 1;
				char* t = malloc(length);
				sprintf(t, "%s %s", dates[i], times[j]);
				ts1 = PGTYPEStimestamp_from_asc(t, NULL);
				text = PGTYPEStimestamp_to_asc(ts1);
				printf("TS[%d,%d]: %s\n",
				       i, j, errno ? "-" : text);
				free(text);
				free(t);
			}
		}
	}

	ts1 = PGTYPEStimestamp_from_asc("2004-04-04 23:23:23", NULL);

	for (i = 0; intervals[i]; i++)
	{
		interval *ic;
		i1 = PGTYPESinterval_from_asc(intervals[i], &endptr);
		if (*endptr)
			printf("endptr set to %s\n", endptr);
		if (!i1)
		{
			printf("Error parsing interval %d\n", i);
			continue;
		}
		j = PGTYPEStimestamp_add_interval(&ts1, i1, &ts2);
		if (j < 0)
			continue;
		text = PGTYPESinterval_to_asc(i1);
		printf("interval[%d]: %s\n", i, text ? text : "-");
		free(text);

		ic = PGTYPESinterval_new();
		PGTYPESinterval_copy(i1, ic);
		text = PGTYPESinterval_to_asc(i1);
		printf("interval_copy[%d]: %s\n", i, text ? text : "-");
		free(text);
		PGTYPESinterval_free(ic);
		PGTYPESinterval_free(i1);
	}

	return 0;
}