Intro
The data type determines the kind of data the data is. In programming, variables are usually declared as being of a particular data type. This is done so that the program can tell the computer to reserve a customized amount of memory. In fact some languages require that all variables be declared.
The most common data types may be grouped into data groups. The examples below are typical data types for ISO, but they are very year dependent. EGs: SQL86, SQL89, SQL92, SQL:1999, SQL:2003. See also SQL Server Datatypes.
 Strings. Bytes assumed to be characters or text. Usually singlebyte encoded (usu. ISO 8859 Latin 1 or ANSI 1252 Windows) unless explicitly noted as doublebyte encoded (probably Unicode).
 Fixed Length. Stored as length noted.
 char[(n)] = character[(n)]
 PLSQL> char[(n)] = character[(n)]. Default n = 1. Max n in v7 = 255, v8 = v9 = 2000 , vP = 32,767.
 TSQL> char[(n)]. Default n = 10. Max n = 8000.
 national char[(n)] = national character[(n)]
 PLSQL> nchar(n). Max n in v7 = NA, v8 = v9 = 2000 B , vP = 32,767 B.
 TSQL> nchar[(n)]. Default n = 10. Max n = 4000. Unicode literals are specified with a leading N. EG:
N'A Unicode string'
.
 Miscellany
 aaGH> [n]char[(n)] [charset x]. Default n = 1. Max = 255 B.
 MySQL> [national] char[(n)] [binary  ascii  unicode  character set x  charset x]. Also available: character, nchar, and binary. Range of n = 1 to 255 before MySQL 3.23, 0 to 255 3.23+. char = char(1). char(0) can take NULL or empty string ('').The ascii option assigns character set = latin1. The unicode option assigns character set = ucs.
 TSQL> sysname. A systemsupplied userdefined data type frequently used for referencing database objects. It is actually nvarchar(128).
 char[(n)] = character[(n)]
 Variable Length. Stored as up to length noted.
 char varying[(n)], character varying[(n)]
 Access> Text. Default 50 B. Max = 255 B.
 PLSQL> varchar(n) = varchar2(n) = string(n). Max n in ver7 = 2000, ver8 = ver9 = 4000 , verP = 32,767.
 TSQL> varchar[(n)  (max)]. Default n = 50. Max n = 8000. varchar(max) is available in SQL Server 2005, has a max size of 2^32  1 B, and replaces the data type text.
 national char varying[(n)] = national character varying[(n)]
 PLSQL> nvarchar2(n). Max n in v7er = NA, ver8 = ver9 = 4000 B , verP = 32,767 B.
 TSQL> nvarchar[(n)  (max)]. Default n = 50. Max n = 4000. nvarchar(max) is available in SQL Server 2005, has a max size of 2^31  1 B, and replaces the datatype ntext.
 Miscellany
 aaGH> [n]varchar[(n)] [charset x]. Default = 64 B. Max = 65,535 B.
 MySQL> [national] varchar(n) [binary  character set x  charset x]. Range of n = 1 to 255 before MySQL 4.0.2, 0 to 255 4.0.2+, 0 to 65,535 in 5.0.3+. Also available character varying and varbinary.
 char varying[(n)], character varying[(n)]
 Huge Length. Stored as up to max length.
 text
 aaGH> [n]blob24 [charset x]. Max = 2^24  1 B = 16,777,215 ~ 17 MB.
 aaGH> [n]blob32 [charset x]. Max = 2^32  1 B = 4,294,967,295 ~ 4 GB.
 Access> Memo. Up to 65,535.
 MySQL> tinyblob [binary  character set x  charset x] = tinytext [binary  character set x  charset x]. Max size = 2^8 1 B = 255 B. tinytext has a character set, while tinyblob does not.
 MySQL> blob[(n)] [binary  character set x  charset x] = text[(n)] [binary  character set x  charset x]. Max n = 2^16  1 B = 65,535 B. text has a character set, while blob does not.
 MySQL> mediumblob [binary  character set x  charset x] = mediumtext [binary  character set x  charset x]. Max size = 2^24  1 B = 16,777,215 ~ 17 MB. mediumtext has a character set, while mediumblob does not.
 MySQL> longblob [binary  character set x  charset x] = longtext [binary  character set x  charset x]. Max size = 2^32  1 B = 4,294,967,295 ~ 4 GB. longtext has a character set, while longblob does not.
 PLSQL> long. Max = 2 GB.
 PLSQL> clob. Max = 4 GB.
 PLSQL> nclob. Max = 4 GB.
 TSQL> text. Max = 2^31  1 ~ 2.15e9 ~ 2 GB. Deprecated for varchar(max) in SQL Server 2005.
 national text
 TSQL> ntext. Max characters = 2^30  1 ~1.07e9 ~ 1 GB. Deprecated for nvarchar(max) in SQL Server 2005.
 text
 Miscellany
 MySQL> enum('value1','value2',...). Stores as a 2 B integer which is equivalent to one of 65,535 values, NULL, error empty string, or 0 (evaluates to nonerror empty string).
 MySQL> set('value1','value2',...). Stores as 1 B integer which is equivalent to one of 64 members, NULL, error empty string, or 0 (evaluates to nonerror empty string).
 OLE DB> dbtype_str.
 Fixed Length. Stored as length noted.
 Integer. Exact whole numbers without fractions. EG: 3.
 Fixed Length. Stored as length noted.
 bit = boolean. 0 or 1 or NULL. Works as Yes/No, True/False, On/Off. Stored as 1 b, not 1 B.
 Access> Yes/No.
 MySQL> Same as tinyint(1) before MySQL 5.0.3.
 OLE DB> dbtype_bool.
 TSQL> bit. Nonzero integers converted to 1.
 bit[(n)]. Stored as n b. Unsigned: 2^n = 0 to 2^n  1. Signed: 2^(n1) to 2^(n1)  1.
 aaGH> bit[(n)]. Max n = 64. Default n = 1.
 MySQL> bit[(n)]. Max n = 64. Default n = 1, i.e. same as bool. Unsigned only. For MySQL 5.0.3+.
 int1 = tinyint = binary = byte. Unsigned: 2^8 = 0 to 255. Signed: 2^7 to 2^7 1 = 128 to 127. Stored as 1 B.
 aaGH> int1 [unsigned] [zerofill].
 Access> Number.Byte. Unsigned only.
 MySQL> tinyint[(n)] [unsigned] [zerofill]. n is the display width.
 OLE DB> dbtype_i1.
 TSQL> tinyint. Unsigned only.
 int2 = smallint. Unsigned: 2^16 = 0 to 65,535 = 0 to ~6.55e4. Signed: 2^15 to 2^15  1 = 32,768 to 32,767 ~ ±3.28e4. Stored as 2 B.
 aaGH> int2 [unsigned] [zerofill].
 Access> Number.Integer.
 MySQL> smallint[(n)] [unsigned] [zerofill]. n is the display width.
 OLE DB> dbtype_i2.
 PLSQL> smallint.
 TSQL> smallint.
 int3 = mediumint. Unsigned: 2^24 = 0 to 16,777,215 = 0 to ~1.68e7. Signed: 2^23 to 2^23 1 = 8,388,608 to 8,388,607 ~ ±8.39e6. Stored as 3 B.
 MySQL> mediumint[(n)] [unsigned] [zerofill]. n is the display width.
 int4 = int = integer. Unsigned: 2^32 = 0 to 4,294,967,295 = 0 to ~4.29e9. Signed: 2^31 to 2^31  1 = 2147483648 to 2147483647 ~±2.15e9. Stored as 4 B.
 aaGH> int4 [unsigned] [zerofill].
 Access> Number.Long Integer. AutoNumber.Long Integer.
 MySQL> int[(n)] [unsigned] [zerofill] = integer[(n)] [unsigned] [zerofill]. n is the display width.
 OLE DB> dbtype_i4.
 PLSQL > int, integer.
 TSQL> int.
 int8 = bigint. Unsigned: 2^64 = 0 to 18,446,744,073,709,551,615 = 0 to ~1.84e19. Signed: 2^63 to 2^63  1 = 9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 ~ ±9.22e18. Stores as 8 B.
 aaGH> int8 [unsigned] [zerofill].
 Access> Date/Time. Date and time value between 100/9999. Stored as 8 B.
 MySQL> bigint[(n)] [unsigned] [zerofill]. Max and default n = 64. n is the display width.
 OLE DB> dbtype_i8.
 OLE DB> dbtype_date.
 TSQL> bigint.
 int16. Unsigned: 2^128 = 0 to ~3.40e38. Signed: 2^127 to 2^127  1 ~ 1.70e38. Stores as 16 B.
 aaGH> int16 [unsigned] [zerofill].
 Access> Number.Replication ID. AutoNumber.Replication ID. A 16 B datatype used as a GUID for replications.
 OLE DB> dbtype_guid.
 TSQL> uniqueidentifier. A GUID (Globally Unique Identifier) with this syntax:
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
. Note that each x is a hexadecimal. EG:6F9619FF8B86D011B42D00C04FC964FF
. Stored as 16 B.
 binary[(n)]. Stores as n B.
 aaGH> intx[(n)]. Default n = 8. Max n = 64.
 MySQL> binary[(n)]. Before MySQL 4.1.2 binary[(n)] was the same as char[(n)].
 OLE DB> dbtype_byte.
 TSQL> binary[(n)]. Default n = 10. Max n = 8000. Binary constants are represented as hexadecimal with this syntax:
0xHexadecimal
. EG:0x2A
=2A
hexadecimal =42
decimal =52
octal =00101010
binary =*
ASCII. Stored as n+4.
 bit = boolean. 0 or 1 or NULL. Works as Yes/No, True/False, On/Off. Stored as 1 b, not 1 B.
 Variable Length. Stored as up to length noted.
 bit varying[(n)] = varbit[(n)].
 aaGH> varbit[(n)]. Max n = 64. Default n = 1.
 binary varying[(n)]
 aaGH> varintx[(n)]. Default n = 8. Max n = 64.
 MySQL> varbinary[(n)]. Before MySQL 4.1.2 varbinary[(n)] was the same as varchar[(n)].
 TSQL> varbinary[(n)]. Default n = 50. Max n = 8000. nvarbinary(max) is available in SQL Server 2005, has a max size of 2^31  1 B, and replaces the datatype image.
 PLSQL> raw(n). Max n = 2000.
 bit varying[(n)] = varbit[(n)].
 Huge Length. Stored as up to max length.
 OLE DB> dbtype_bytes.
 PLSQL> long raw. Max size = 2 GB. Deprecated.
 PLSQL> blob. Max size = 4 GB.
 PLSQL> bfile. External binary file. Max size = 4 GB.
 TSQL> image. Like varbinary, but the max = 2^31  1 (~2.15e9) B. Default size = 16 B. nvarbinary(max) is available in SQL Server 2005, has a max size of 2^31  1 B, and replaces the datatype image.
 Fixed Length. Stored as length noted.
 Decimal. Whole numbers with fractions. EG: 3.5.
 Fixed point. Number with a decimal portion that is exactly represented with binary numbers. p = Precision = # of significant digits. s = Scale = # of decimal places.
 dec = decimal(p, s) = num = numeric(p, s)
 aaGH> fixed[(p, s)] [unsigned] [zerofill]. Default p, s = 17, 2. Max p = 64.
 Access> Number.Decimal(p, s). Default p = 18, s = 0. Max p = 28. Stores as 12 B.
 MySQL> decimal[(p[, s])] [unsigned][zerofill] = dec[(p[, s])] [unsigned] [zerofill], numeric[(p[, s])] [unsigned] [zerofill] , fixed[(p[, s])] [unsigned] [zerofill] . Default p, s = 10, 0. Max p, s = 64, 30. Unsigned disallows negative values.
 OLE DB> dbtype_numeric
 PLSQL> dec(p,s) = decimal(p,s) = number(p,s) = numeric(p,s). Max p = 38. s between 84 and 127.
 TSQL> decimal[(p[, s])] = numeric[(p[, s])]. ±10^38. Default p, s = 18, 0. Max p = 38. p >= s >= 0. If p = 19, then stores as 5 B. p = 1019, then 9 B (the default size). p = 2028, then 13 B. p = 2938, then 17 B.
 money
 Access> Currency. Comparable to decimal(19,4).
 OLE DB> dbtype_cy.
 TSQL> smallmoney. ~±214,748.3648. Comparable to decimal(10, 4). Stored as 4 B.
 TSQL> money. ~±2^63 (~±9.22e14). Comparable to decimal(19, 4). Stored as 8 B.
 dec = decimal(p, s) = num = numeric(p, s)
 Floating point. Number with a decimal portion that is approximated with binary numbers. In addition to the p and s, floating points also use b = bits to store the fractional part of the significand of the number in binary.
 float4, float(24), real, single precision
 Access> Number.Single. 3.402823e38 to 1.401298e45 for negative values and from 1.401298e45 to 3.402823e38 for positive values. p = 7.
 MySQL> float(b) [unsigned] [zerofill], when b is between 0 to 24. Unsigned disallows negative values.
 MySQL> float[(p,s)] [unsigned] [zerofill]. 3.402823466e38 to 1.175494351e38 for negative values and from 1.175494351e38 to 3.402823466e38 for positive values. p ~ 7 by default. Note that in MySQL, ISO "float" and "real" are generally switched. Unsigned disallows negative values.
 OLE DB> dbtype_r4.
 PLSQL> real.
 TSQL> real. ~±3.40e38. p = 7. Stored as 4 B.
 TSQL> float[(b)] when b is 124, then p = 7, and it is stored as 4 B. ~±1.79E308.
 float8, float(53), float, double precision
 aaGH> float53
 Access> Number.Double. 1.79769313486231e308 to 4.94065645841247e324 for negative values and from 1.79769313486231e308 to 4.94065645841247e324 for positive values. p = 15.
 MySQL> float(b) [unsigned] [zerofill], when b is between 25 to 53. Unsigned disallows negative values.
 MySQL> doublle[(p, b)] [unsigned] [zerofill] = double precision[(p, b)] [unsigned] [zerofill] , real[(p, b)] [unsigned] [zerofill] . 1.7976931348623157e308 to 2.2250738585072014e308 for negative values and 2.2250738585072014e308 to 1.7976931348623157e308 for positive values. p ~15 by default. Unsigned disallows negative values.
 OLE DB> dbtype_r8.
 PLSQL> double precision = float
 TSQL> float[(b)] when b is 2553, then p = 15, and it is stored as 8 B. ~±1.79E308.
 Miscellany
 aaGH> float[(p, b)]. Default p,b = 7,24. Max p,b = 15,53.
 float4, float(24), real, single precision
 Fixed point. Number with a decimal portion that is exactly represented with binary numbers. p = Precision = # of significant digits. s = Scale = # of decimal places.
 Date and Time
 date
 aaGH> date. Date value between 00010101 and 99991231. Accepts strings or numbers. Date parts can be entered as zero if not certain. EG: '19990000'. Two digit year values are converted as follows: 00/69 = 2000/2069 and 70/99 = 1970/1999.
 MySQL> date. Date value between 10000101 and 99991231. Lovely ISO format! Accepts strings or numbers. Date parts can be entered as zero if not certain. EG: '19990000'. Stored as 3 B.
 MySQL> year[(24)]. Year in 2 or 4 digit format. Default = 4. Two digit year values are converted as follows: 00/69 = 2000/2069 and 70/99 = 1970/1999. Stored as 1 B.
 OLE DB> dbtype_dbdate.
 TSQL> date. Date value between 00010101 and 99991231. Accepts strings or numbers. New as of v2008. Stored as 3 B.
 interval. An interval of time.
 PLSQL> interval day(dayPrecision) to second(secondPrecision). Stored as 11 B.
 PLSQL> interval year(yearPrecision) to month. Stored as 5 B.
 time
 aaGH> time. Time value between 00:00:00.000000 to 24:59:59.999999. Accepts strings or numbers.
 MySQL> time. Time value between 838:59:59 to 838:59:59. Accepts strings or numbers. Stored as 3 B.
 OLE DB> dbtype_dbtime.
 TSQL> time. Time value between 00:00:00.0000000 through 23:59:59.9999999. Accepts strings or numbers. New as of v2008. Stored as 5 B.
 time with time zone
 aaGH> timetzd. Time value as hh:mm:ss.ssss±hh:mm.
 timestamp
 aaGH> datetime. Date and time value between 00010101 00:00:00.000000 to 99991231 23:59:59.999999. Accepts strings or numbers.
 aaGH> datetimetzd. Date and time value between 10000101 00:00:00.000000±hh:mm to 99991231 23:59:59.999999±hh:mm. Accepts strings or numbers.
 MySQL> datetime. Date and time value between 10000101 00:00:00 to 99991231 23:59:59. Accepts strings or numbers. Stored as 8 B.
 MySQL> timestamp[(n)]. Date and time value between 19700101 00:00:00 and roughly 2037. Such a column automatically enters timestamp upon insert or update. As of MySQL v4.1 the "[(n)]" is no longer available and always stores as 19 characters. Stored as 4 B.
 OLE DB> dbtype_dbtimestamp.
 PLSQL> date. Date and time. v7: 47120101/47121231. v8 = v9: 47120101/99991231.
 PLSQL> timestamp(n). Date and time. n is 0 to 9 and indicates decimal places of second. Stores as 711 B.
 PLSQL> timestamp(n) with time zone. As timestamp(n) but also stores time zone. Stores as 13 B.
 PLSQL> timestamp(n) with local time. Date and time. As timestamp(n) with time zone, but assume the local timezone. Stores as 711 B.
 TSQL> smalldatetime. Date and time value between 19000101/20790606. Accurate to the minute. Stored as two 2 B integers.
 TSQL> datetime. Date and time value between 17530101/99991231. Accurate to 3.33 ms. Stored as two 4 B integers.
 TSQL> datetime2. Date and time value between 00010101/99991231. Accurate to 100 ns. New as of v2008. Stored as 68 B.
 TSQL> datetimeoffset. Date and time value between 00010101/99991231. Time zone offset range: 14:00 through +14:00. New as of v2008. Stored as 10 B.
 rowversion
 TSQL> timestamp. A databasewide unique number that gets updated every time a row gets updated.
 date
 Miscellany. There are proprietary DBMS datatypes. There are even user defined datatypes which is usually an object collecting various other data types. In OOP (Object Oriented Programming) the distinction between datatypes and object types gets blurry, especially when the datatype is a pointer that can point to nearly any kind of object.
 Access> OLE Object. Linked or embedded in Access.
 Access> Hyperlink. This datatype stores stores values such as text to display and URL. Syntax:
DisplayedText#URL#Bookmark#Screentip
.  Access> Lookup Wizard. This "datatype" is more part of the DBMS IDE than a real datatype.
 PLSQL> rowid.
BBBBBBB.RRRR.FFFFF
where Bs = block in DB file, Rs = row in block, and Fs = DB file.  PLSQL> urowid. Up to 2000 B.
 TSQL> cursor. A reference to a cursor. Cannot be used for a column.
 TSQL> sql_variant. A data type that stores values of various SQL Serversupported data types, except text, ntext, timestamp, and sql_variant.
 TSQL> table. A special data type used to store a result set for later processing. Use DECLARE @local_variable to declare variables of type table. Cannot be used for a column.
Floating Point Numbers
A floating point number is the digital representation of many rational numbers.
A = M × b^{e}
The "floating point number", A, is represented by two numbers:
 M, a coefficient called the "significand" (or informally the "mantissa"). M will be expressed with a "precision" of p digits. If M has an integer portion that is singledigit and nonzero, then M is said to be "normalized". EG: Of these significants,
1.2
,12
, and0.12
, all havep = 2
, but only the first one is normalized.  b^{e}, a "base" (or "radix"), b, raised to an integer power, e, called the "exponent". EG: If
b = 10
ande = 2
, then10^{2} = 10^2 = 10e2
.
Here are some example floating point numbers:
1.2 * 10^2 = 1.2e2 = 120e0. These are equal in value to integer number of 120.
0.12e0 = 1.2e1 = 1.2 * 10^1. These are equal to the fixed point notation of 0.12.
Computers use binary so they can only represent certain numbers approximately with floating point notation. It is for this reason that fixed point notation is preferable in certain situations (such as money calculations). EG: 0.1
can only be approximated in floating point notation, but can be represented exactly with fixed point notation.
In one sense floating point numbers are no more than A = M × b^{e}, but since it is concerned with the digital representation, such a datatype must be able to represent other values such as infinities and NaN (not a number). According to IEEE 754 (Standard for Binary FloatingPoint Arithmetic), the most common standard for floating point computations, specifies four formats for representing floating point values.
 singleprecision (32bit). Most floating point numbers are normalized. This is SQL datatype float4, float(24), real, or single precision.
1 8 23 width in bits ++++ S Exp  Fraction  00000000000000000000000000000000 zero x00000000 nonzero  denormalized number x 1254  any  normalized number 11000010111011010100000000000000 EG: 118.625 x1111111100000000000000000000000 infinity x11111111 any  NaN ++++ 31 30 23 22 0 bit index (0 on right) bias +127 S = 1 because of the sign. 118.625 = 1110110.101. Normalizing it makes it 1.110110101 * 2^6. With bias, Exp = 6 + 127 = 133 = 10000101. The fraction of the significand is 110110101, so padding it with 0s to fill the space yields 11011010100000000000000. Note that this fraction is similar to the slide rule usage of mantissa but not quite. The integer portion of a normalized binary number is assumed to be 1.
 doubleprecision (64bit). This is SQL datatype float8, float(53), float, or double precision.
1 11 52 ++++ S Exp  Fraction  ++++ 63 62 52 51 0 bias +1023
 singleextended precision (≥ 43bit, not commonly used)
 doubleextended precision (≥ 79bit, usually implemented with 80 bits).
FYI: One of the older definitions of "mantissa" wasn't even mathematical: a "mantissa" was a minor addition or supplement, usu. an added statement. Later on, especially in the days of slide rules, the word "mantissa" referred to the fractional part of a common logarithm. EG:
log_{10} 120 =
log_{10} (10^{2} * 1.2) =
log_{10 }(1.2 * 10^{2}) =
log_{10} (10^{2}) + log_{10} (1.2) ~
2 + 0.079181
The2
was the characteristic and the0.079181
was the "mantissa".
Microsoft ADO
The DataTypeEnum can be used by the ADO Field, Parameter, and Property objects.
Common  Constant  Value  Description 

AdArray (Does not apply to ADOX.) 
0x2000  A flag value, always combined with another data type constant, that indicates an array of that other data type.  
adBigInt  20  Indicates an eightbyte signed integer (DBTYPE_I8).  
X  adBinary  128  Indicates a binary value (DBTYPE_BYTES). 
X  adBoolean  11  Indicates a boolean value (DBTYPE_BOOL). 
adBSTR  8  Indicates a nullterminated character string (Unicode) (DBTYPE_BSTR).  
adChapter  136  Indicates a fourbyte chapter value that identifies rows in a child rowset (DBTYPE_HCHAPTER).  
X  adChar  129  Indicates a string value (DBTYPE_STR). 
X  adCurrency  6  Indicates a currency value (DBTYPE_CY). Currency is a fixedpoint number with four digits to the right of the decimal point. It is stored in an eightbyte signed integer scaled by 10,000. 
X  adDate  7  Indicates a date value (DBTYPE_DATE). A date is stored as a double, the whole part of which is the number of days since December 30, 1899, and the fractional part of which is the fraction of a day. 
X  adDBDate  133  Indicates a date value (yyyymmdd) (DBTYPE_DBDATE). 
X  adDBTime  134  Indicates a time value (hhmmss) (DBTYPE_DBTIME). 
X  adDBTimeStamp  135  Indicates a date/time stamp (yyyymmddhhmmss plus a fraction in billionths) (DBTYPE_DBTIMESTAMP). 
X  adDecimal  14  Indicates an exact numeric value with a fixed precision and scale (DBTYPE_DECIMAL). 
X  adDouble  5  Indicates a doubleprecision floatingpoint value (DBTYPE_R8). 
adEmpty  0  Specifies no value (DBTYPE_EMPTY).  
adError  10  Indicates a 32bit error code (DBTYPE_ERROR).  
adFileTime  64  Indicates a 64bit value representing the number of 100nanosecond intervals since January 1, 1601 (DBTYPE_FILETIME).  
adGUID  72  Indicates a globally unique identifier (GUID) (DBTYPE_GUID).  
adIDispatch  9 
Indicates a pointer to an IDispatch interface on a COM object (DBTYPE_IDISPATCH).
Note This data type is currently not supported by ADO. Usage may cause unpredictable results. 

X  adInteger  3  Indicates a fourbyte signed integer (DBTYPE_I4). 
adIUnknown  13 
Indicates a pointer to an IUnknown interface on a COM object (DBTYPE_IUNKNOWN).
Note This data type is currently not supported by ADO. Usage may cause unpredictable results. 

adLongVarBinary  205  Indicates a long binary value (Parameter object only).  
adLongVarChar  201  Indicates a long string value (Parameter object only).  
adLongVarWChar  203  Indicates a long nullterminated Unicode string value (Parameter object only).  
X  adNumeric  131  Indicates an exact numeric value with a fixed precision and scale (DBTYPE_NUMERIC). 
adPropVariant  138  Indicates an Automation PROPVARIANT (DBTYPE_PROP_VARIANT).  
X  adSingle  4  Indicates a singleprecision floatingpoint value (DBTYPE_R4). 
X  adSmallInt  2  Indicates a twobyte signed integer (DBTYPE_I2). 
adTinyInt  16  Indicates a onebyte signed integer (DBTYPE_I1).  
adUnsignedBigInt  21  Indicates an eightbyte unsigned integer (DBTYPE_UI8).  
adUnsignedInt  19  Indicates a fourbyte unsigned integer (DBTYPE_UI4).  
adUnsignedSmallInt  18  Indicates a twobyte unsigned integer (DBTYPE_UI2).  
adUnsignedTinyInt  17  Indicates a onebyte unsigned integer (DBTYPE_UI1).  
adUserDefined  132  Indicates a userdefined variable (DBTYPE_UDT).  
adVarBinary  204  Indicates a binary value (Parameter object only).  
adVarChar  200  Indicates a string value (Parameter object only).  
adVariant  12 
Indicates an Automation Variant (DBTYPE_VARIANT).
Note This data type is currently not supported by ADO. Usage may cause unpredictable results. 

adVarNumeric  139  Indicates a numeric value (Parameter object only).  
adVarWChar  202  Indicates a nullterminated Unicode character string (Parameter object only).  
adWChar  130  Indicates a nullterminated Unicode character string (DBTYPE_WSTR). 