convert.c

ncbi源码

            return 4;
            break;
	    /* TODO conversions to money */
		/* conversions not allowed */
		case SYBUNIQUE:
		case SYBDATETIME4:
		case SYBDATETIME:
		case SYBDATETIMN:
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
#ifndef NCBI_FTDS
	return TDS_CONVERT_FAIL;
#endif
}
static TDS_INT 
tds_convert_money4(int srctype, const TDS_CHAR *src, int srclen,
	int desttype, CONV_RESULT *cr)
{
TDS_MONEY4 mny;
long dollars, fraction;
char tmp_str[33];

	memcpy(&mny, src, sizeof(mny));
	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			/* FIXME should be rounded ??
			 * see also all conversion to int and from money 
			 * rounding with dollars = (mny.mny4 + 5000) /10000
			 * can give arithmetic overflow solution should be
			 * dollars = (mny.mny4/2 + 2500)/5000 */
			dollars  = mny.mny4 / 10000;
			fraction = mny.mny4 % 10000;
			if (fraction < 0)	{ fraction = -fraction; }
			/* TODO print 4 decimal digits ?? */
			sprintf(tmp_str,"%ld.%02lu",dollars,fraction/100);
			return string_to_result(tmp_str,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_MONEY4),cr);
			break;
		case SYBINT1:
			dollars  = mny.mny4 / 10000;
			if (!IS_TINYINT(dollars))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) dollars;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			dollars  = mny.mny4 / 10000;
			if (!IS_SMALLINT(dollars))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) dollars;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			cr->i = mny.mny4 / 10000;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = mny.mny4 / 10000;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = mny.mny4 ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f = ((TDS_FLOAT)mny.mny4) / 10000.0;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = (TDS_REAL) (mny.mny4 / 10000.0);
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY:
			cr->m.mny = (TDS_INT8)mny.mny4; 
			return sizeof(TDS_MONEY);
			break;
		case SYBMONEY4:
			memcpy(&(cr->m4), src, sizeof(TDS_MONEY4));
			return sizeof(TDS_MONEY4);
			break;
		/* conversions not allowed */
		case SYBUNIQUE:
		case SYBDATETIME4:
		case SYBDATETIME:
		case SYBDATETIMN:
			break;
		case SYBDECIMAL:
		case SYBNUMERIC:
			dollars  = mny.mny4 / 10000;
			fraction = mny.mny4 % 10000;
			if (fraction < 0)	{ fraction = -fraction; }
			sprintf(tmp_str,"%ld.%04lu",dollars,fraction);
			return stringz_to_numeric(tmp_str,cr);
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
	return TDS_CONVERT_FAIL;
}

static TDS_INT 
tds_convert_money(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
char *s;

TDS_INT8 mymoney,dollars;
char tmpstr [64];

    tdsdump_log(TDS_DBG_FUNC, "%L inside tds_convert_money()\n");
#if defined(WORDS_BIGENDIAN) || !defined(HAVE_INT64)
    memcpy(&mymoney, src, sizeof(TDS_INT8)); 
#else
    memcpy(((char*)&mymoney)+4, src, 4);
    memcpy(&mymoney, src+4, 4);
#endif

#	if (SIZEOF_LONG_LONG > 0)
	tdsdump_log(TDS_DBG_FUNC, "%L mymoney = %lld\n", mymoney);
#	else
	tdsdump_log(TDS_DBG_FUNC, "%L mymoney = %ld\n", mymoney);
#	endif
	switch(desttype) {
		case SYBCHAR:
		case SYBVARCHAR:
		case SYBTEXT:
			s = tds_money_to_string((const TDS_MONEY *)src, tmpstr);
			return string_to_result(s,cr);
			break;

		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_MONEY),cr);
			break;
		case SYBINT1:
			dollars  = mymoney / 10000;
			if (!IS_TINYINT(dollars))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) dollars;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			dollars  = mymoney / 10000;
			if (!IS_SMALLINT(dollars))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) dollars;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			dollars  = mymoney / 10000;
			if (!IS_INT(dollars))
				return TDS_CONVERT_OVERFLOW;
			cr->i = (TDS_INT) dollars;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = mymoney / 10000;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = mymoney ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f  = ((TDS_FLOAT)mymoney) / 10000.0;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r  = (TDS_REAL) (mymoney / 10000.0);
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY4:
			if (!IS_INT(mymoney))
				return TDS_CONVERT_OVERFLOW;
			cr->m4.mny4 = (TDS_INT) mymoney;
			return sizeof(TDS_MONEY4);
			break;
		case SYBMONEY:
			cr->m.mny = mymoney;
			return sizeof(TDS_MONEY);
			break;
		case SYBDECIMAL:
		case SYBNUMERIC:
			s = tds_money_to_string((const TDS_MONEY *)src, tmpstr);
			return stringz_to_numeric(tmpstr,cr);
			break;
		/* conversions not allowed */
		case SYBUNIQUE:
		case SYBDATETIME4:
		case SYBDATETIME:
		case SYBDATETIMN:
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
#ifndef NCBI_FTDS
	return TDS_CONVERT_FAIL;
#endif
}

static TDS_INT 
tds_convert_datetime(TDSCONTEXT *tds_ctx, int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{

unsigned int dt_days, dt_time;

char whole_date_string[30];
TDSDATEREC when;

	switch(desttype) {
		case SYBCHAR:
		case SYBVARCHAR:
		case SYBTEXT:
			if (!src) {
				cr->c = (TDS_CHAR *) malloc(1);
				test_alloc(cr->c);
				*(cr->c) = '\0';
                return 0;
			} else {

				memset( &when, 0, sizeof(when) );

                tds_datecrack (SYBDATETIME, src, &when);
                tds_strftime  (whole_date_string, sizeof(whole_date_string), tds_ctx->locale->date_fmt, &when );

				return string_to_result(whole_date_string,cr);
			}
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_DATETIME),cr);
			break;
		case SYBDATETIME:
			memcpy(&dt_days, src, 4);
			memcpy(&dt_time, src + 4, 4);
			cr->dt.dtdays = dt_days;
			cr->dt.dttime = dt_time;
            return sizeof(TDS_DATETIME);
			break;
		case SYBDATETIME4:
			memcpy(&dt_days, src, 4);
			memcpy(&dt_time, src + 4, 4);
			cr->dt4.days    = dt_days;
			cr->dt4.minutes = (dt_time / 300) / 60;
            return sizeof(TDS_DATETIME4);
			break;
		/* conversions not allowed */
		case SYBUNIQUE:
		case SYBBIT:
		case SYBBITN:
		case SYBINT1:
		case SYBINT2:
		case SYBINT4:
		case SYBINT8:
		case SYBMONEY4:
		case SYBMONEY:
		case SYBNUMERIC:
		case SYBDECIMAL:
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
#ifndef NCBI_FTDS
	return TDS_CONVERT_FAIL;
#endif
}


/*
static int days_this_year (int years)
{
int year;

   year = 1900 + years;
   if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
      return 366;
   else
      return 365;
}
*/

static TDS_INT 
tds_convert_datetime4(TDSCONTEXT *tds_ctx, int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{

TDS_USMALLINT dt_days, dt_mins;

char whole_date_string[30];
TDSDATEREC when;

	switch(desttype) {
		case SYBCHAR:
		case SYBVARCHAR:
		case SYBTEXT:
			if (!src) {
				cr->c = (TDS_CHAR *) malloc(1);
				test_alloc(cr->c);
				*(cr->c) = '\0';
                return 0;
			} else {

				memset( &when, 0, sizeof(when) );

                tds_datecrack (SYBDATETIME4, src, &when);
                tds_strftime  (whole_date_string, sizeof(whole_date_string), tds_ctx->locale->date_fmt, &when );

				return string_to_result(whole_date_string,cr);
			}
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_DATETIME4),cr);
			break;
		case SYBDATETIME:
			memcpy(&dt_days, src, 2);
			memcpy(&dt_mins, src + 2, 2);
			cr->dt.dtdays = dt_days;
			cr->dt.dttime = (dt_mins * 60) * 300;
            return sizeof(TDS_DATETIME);
			break;
		case SYBDATETIME4:
			memcpy(&dt_days, src, 2);
			memcpy(&dt_mins, src + 2, 2);
			cr->dt4.days    = dt_days;
			cr->dt4.minutes = dt_mins;
            return sizeof(TDS_DATETIME4);
			break;
		/* conversions not allowed */
		case SYBUNIQUE:
		case SYBBIT:
		case SYBBITN:
		case SYBINT1:
		case SYBINT2:
		case SYBINT4:
		case SYBINT8:
		case SYBMONEY4:
		case SYBMONEY:
		case SYBNUMERIC:
		case SYBDECIMAL:
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
#ifndef NCBI_FTDS
	return TDS_CONVERT_FAIL;
#endif
}

static TDS_INT 
tds_convert_real(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_REAL the_value;
/* FIXME how many big should be this buffer ?? */
char tmp_str[128];
TDS_INT  mymoney4;
TDS_INT8 mymoney;

   memcpy(&the_value, src, 4);

   switch(desttype) {
      case SYBCHAR:
      case SYBTEXT:
      case SYBVARCHAR:
            sprintf(tmp_str,"%.7g", the_value);
	    return string_to_result(tmp_str,cr);
            break;

		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_REAL),cr);
			break;
		case SYBINT1:
			if (!IS_TINYINT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) the_value;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			if (!IS_SMALLINT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) the_value;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			if (!IS_INT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->i = (TDS_INT) the_value;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			/* TODO check overflow */
			cr->bi = the_value;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = the_value ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;

		case SYBFLT8:
			cr->f = the_value;
			return sizeof(TDS_FLOAT);
			break;

		case SYBREAL:
			cr->r = the_value;
			return sizeof(TDS_REAL);
			break;

		case SYBMONEY:
			/* TODO check overflow */
			mymoney = the_value * 10000;
			memcpy(&(cr->m), &mymoney, sizeof(TDS_MONEY));
			return sizeof(TDS_MONEY);
			break;

		case SYBMONEY4:
			/* TODO check overflow */
			mymoney4 = the_value * 10000;
			memcpy(&(cr->m4), &mymoney4, sizeof(TDS_MONEY4));
			return sizeof(TDS_MONEY4);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			sprintf(tmp_str,"%.*f", cr->n.scale,  the_value);
			return stringz_to_numeric(tmp_str, cr);
			break;
		/* not allowed */
		case SYBUNIQUE:
		case SYBDATETIME4:
		case SYBDATETIME:
		case SYBDATETIMN:
		default:
			return TDS_CONVERT_NOAVAIL;
			break;
	}
#ifndef NCBI_FTDS
	return TDS_CONVERT_FAIL;
#endif
}

static TDS_INT 
tds_convert_flt8(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_FLOAT the_value;
char      tmp_str[25];

   memcpy(&the_value, src, 8);
   switch(desttype) {
      case SYBCHAR:
      case SYBVARCHAR:
      case SYBTEXT:
            sprintf(tmp_str,"%.15g", the_value);
	    return string_to_result(tmp_str,cr);
            break;

		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_FLOAT),cr);
			break;
		case SYBINT1:
			if (!IS_TINYINT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) the_value;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			if (!IS_SMALLINT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) the_value;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			if (!IS_INT(the_value))
				return TDS_CONVERT_OVERFLOW;
			cr->i = (TDS_INT) the_value;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			/* TODO check overflow */
			cr->bi = the_value;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = the_value ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;

      case SYBMONEY:
			/* TODO check overflow */
            cr->m.mny = (TDS_INT8)the_value * 10000.0;
            return sizeof(TDS_MONEY);
            break;
      case SYBMONEY4:
			/* TODO check overflow */
            cr->m4.mny4 = the_value * 10000.0;
            return sizeof(TDS_MONEY4);
            break;
		case SYBREAL:
			cr->r = the_value;