convert.c

ncbi源码

		  * or {XXXXXXXX-XXXX-XXXX-XXXXXXXXXXXXXXXX} 
		  * SQL seem to ignore additional character... */
		if (srclen < (32+3)) return TDS_CONVERT_SYNTAX;
		if (src[0] == '{') {
			if (srclen < (32+5) || src[32+4] != '}')
				return TDS_CONVERT_SYNTAX;
			++src;
		}
		if (src[8] != '-' || src[8+4+1] != '-' || src[16+2] != '-')
			return TDS_CONVERT_SYNTAX;
		/* test all characters and get value 
		 * first I tried using sscanf but it work if number terminate
		 * with less digits */
		for(i = 0; i < 32+3; ++i) {
			c = src[i];
			switch(i) {
				case 8:
					if (c!='-') return TDS_CONVERT_SYNTAX;
					cr->u.Data1 = n;
					n = 0;
					break;
				case 8+4+1:
					if (c!='-') return TDS_CONVERT_SYNTAX;
					cr->u.Data2 = n;
					n = 0;
					break;
				case 16+2:
					if (c!='-') return TDS_CONVERT_SYNTAX;
					cr->u.Data3 = n;
					n = 0;
					break;
				default:
					n = n << 4;
					if (c >= '0' && c <= '9') n += c-'0';
					else {
						c &= 0x20 ^ 0xff;
						if (c >= 'A' && c <= 'F')
							n += c-('A'-10);
						else return TDS_CONVERT_SYNTAX;
					}
					if (i>(16+2) && !(i&1)) {
						cr->u.Data4[(i>>1)-10] = n;
						n = 0;
					}
			}
		}
	 }
	 return sizeof(TDS_UNIQUE);
	 default:
		return TDS_CONVERT_NOAVAIL;
		break;
	} /* end switch */
} /* tds_convert_char */

static TDS_INT 
tds_convert_bit(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
	int canonic = src[0] ? 1 : 0;
	switch(desttype) {
		case SYBCHAR:
		case SYBVARCHAR:
		case SYBTEXT:
			cr->c = (TDS_CHAR *) malloc(2);
			test_alloc(cr->c);
			cr->c[0] = '0' + canonic;
			cr->c[1] = 0;
			return 1;
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,1,cr);
			break;
		case SYBINT1:
			cr->ti = canonic;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			cr->si = canonic;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			cr->i = canonic;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = canonic;
			return sizeof(TDS_INT8);
			break;
		case SYBFLT8:
			cr->f = canonic;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = (TDS_REAL) canonic;
			return sizeof(TDS_REAL);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = src[0];
			return sizeof(TDS_TINYINT);
			break;
		case SYBMONEY:
		case SYBMONEY4:
			return tds_convert_int1( SYBINT1, (src[0])? "\1" : "\0", desttype, cr);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			return stringz_to_numeric(canonic ? "1" : "0",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_int1(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_TINYINT buf;
TDS_CHAR tmp_str[5];

	memcpy(&buf, src, sizeof(buf));
	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			sprintf(tmp_str,"%d",buf);
			return string_to_result(tmp_str,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,1,cr);
			break;
		case SYBINT1:
			cr->ti = buf;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			cr->si = buf;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			cr->i = buf;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = buf;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = buf ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f = buf;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = buf;
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY4:
			cr->m4.mny4 = buf * 10000;
			return sizeof(TDS_MONEY4);
			break;
		case SYBMONEY:
			cr->m.mny = buf * 10000;
			return sizeof(TDS_MONEY);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			sprintf(tmp_str,"%d",buf);
			return stringz_to_numeric(tmp_str,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_int2(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_SMALLINT buf;
TDS_CHAR tmp_str[16];
	
	memcpy(&buf,src,sizeof(buf));
	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			sprintf(tmp_str,"%d",buf);
			return string_to_result(tmp_str,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,2,cr);
			break;
		case SYBINT1:
			if (!IS_TINYINT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) buf;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			cr->si = buf;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			cr->i = buf;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = buf;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = buf ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f = buf;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = buf;
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY4:
			cr->m4.mny4 = buf * 10000;
			return sizeof(TDS_MONEY4);
			break;
		case SYBMONEY:
			cr->m.mny = buf * 10000;
			return sizeof(TDS_MONEY);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			sprintf(tmp_str,"%d",buf);
			return stringz_to_numeric(tmp_str,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_int4(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_INT buf;
TDS_CHAR tmp_str[16];
	
	memcpy(&buf,src,sizeof(buf));
	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			sprintf(tmp_str,"%d",buf);
			return string_to_result(tmp_str,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,4,cr);
			break;
		case SYBINT1:
			if (!IS_TINYINT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = buf;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			if (!IS_SMALLINT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->si = buf;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			cr->i = buf;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = buf;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = buf ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f = buf;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = (TDS_REAL) buf;
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY4:
			if (buf > 214748 || buf < -214748)
				return TDS_CONVERT_OVERFLOW;
			cr->m4.mny4 = buf * 10000;
			return sizeof(TDS_MONEY4);
			break;
		case SYBMONEY:
			cr->m.mny = (TDS_INT8)buf * 10000;
			return sizeof(TDS_MONEY);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			sprintf(tmp_str,"%d",buf);
			return stringz_to_numeric(tmp_str,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_int8(int srctype, const TDS_CHAR *src,
	int desttype, CONV_RESULT *cr)
{
TDS_INT8 buf;
TDS_CHAR tmp_str[24];
	
	memcpy(&buf,src,sizeof(buf));
	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			/* TODO: fix for all platform */
			sprintf(tmp_str,"%lld",buf);
			return string_to_result(tmp_str,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,8,cr);
			break;
		case SYBINT1:
			if (!IS_TINYINT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) buf;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			if (!IS_SMALLINT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) buf;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			if (!IS_INT(buf))
				return TDS_CONVERT_OVERFLOW;
			cr->i = (TDS_INT) buf;
			return sizeof(TDS_INT);
			break;
		case SYBINT8:
			cr->bi = buf;
			return sizeof(TDS_INT8);
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = buf ? 1 : 0;
			return sizeof(TDS_TINYINT);
			break;
		case SYBFLT8:
			cr->f = (TDS_FLOAT) buf;
			return sizeof(TDS_FLOAT);
			break;
		case SYBREAL:
			cr->r = (TDS_REAL) buf;
			return sizeof(TDS_REAL);
			break;
		case SYBMONEY4:
			if (buf > 214748 || buf < -214748)
				return TDS_CONVERT_OVERFLOW;
			cr->m4.mny4 = (TDS_INT) (buf * 10000);
			return sizeof(TDS_MONEY4);
			break;
		case SYBMONEY:
			/* TODO check overflow */
			cr->m.mny = buf * 10000;
			return sizeof(TDS_MONEY);
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			/* TODO portability problem */
			sprintf(tmp_str,"%lld",buf);
			return stringz_to_numeric(tmp_str,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_numeric(int srctype, const TDS_NUMERIC *src, TDS_INT srclen,
	int desttype, CONV_RESULT *cr)
{
char tmpstr[MAXPRECISION];
long i;

	switch(desttype) {
		case SYBCHAR:
		case SYBTEXT:
		case SYBVARCHAR:
			tds_numeric_to_string(src,tmpstr);
			return string_to_result(tmpstr,cr);
			break;
		case SYBBINARY:
		case SYBIMAGE:
		case SYBVARBINARY:
			return binary_to_result(src,sizeof(TDS_NUMERIC),cr);
			break;
		case SYBINT1:
			tds_numeric_to_string(src,tmpstr);
			/* TODO what happen if numeric is too big ?? */
			i = atoi(tmpstr);
			if (!IS_TINYINT(i))
				return TDS_CONVERT_OVERFLOW;
			cr->ti = (TDS_TINYINT) i;
			return sizeof(TDS_TINYINT);
			break;
		case SYBINT2:
			tds_numeric_to_string(src,tmpstr);
			i = atoi(tmpstr);
			if (!IS_SMALLINT(i))
				return TDS_CONVERT_OVERFLOW;
			cr->si = (TDS_SMALLINT) i;
			return sizeof(TDS_SMALLINT);
			break;
		case SYBINT4:
			tds_numeric_to_string(src,tmpstr);
			i = atoi(tmpstr);
			if (!IS_INT(i))
				return TDS_CONVERT_OVERFLOW;
			cr->i = i;
			return 4;
			break;
		case SYBINT8:
			tds_numeric_to_string(src,tmpstr);
			/* TODO check for overflow */
			cr->bi = atoll(tmpstr);
			return 8;
			break;
		case SYBBIT:
		case SYBBITN:
			cr->ti = 0;
			for(i=g__numeric_bytes_per_prec[src->precision]; --i > 0;)
				if (src->array[i] != 0) {
					cr->ti = 1;
					break;
				}
			return 1;
			break;
		case SYBNUMERIC:
		case SYBDECIMAL:
            memcpy(&(cr->n), src, sizeof(TDS_NUMERIC));
            return sizeof(TDS_NUMERIC);
            break;
		case SYBFLT8:
            tds_numeric_to_string(src,tmpstr);
            cr->f = atof(tmpstr);
            return 8;
            break;
		case SYBREAL:
            tds_numeric_to_string(src,tmpstr);
            cr->r = atof(tmpstr);