Home • About • Contact
Login • Page Content • Site Map

Search
GH.com   GH.com dir
Wikipedia   Web

• Intro
• Floating Point Numbers
• Microsoft ADO

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: SQL-86, SQL-89, SQL-92, SQL:1999, SQL:2003. See also SQL Server Datatypes.

• Strings. Bytes assumed to be characters or text. Usually single-byte encoded (usu. ISO 8859 Latin 1 or ANSI 1252 Windows) unless explicitly noted as double-byte 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.
      • T-SQL> 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.
      • T-SQL> 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.
      • T-SQL> sysname. A system-supplied user-defined data type frequently used for referencing database objects. It is actually nvarchar(128).
  • 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.
      • T-SQL> 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.
      • T-SQL> 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.
  • 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.
      • T-SQL> text. Max = 2^31 - 1 ~ 2.15e9 ~ 2 GB. Deprecated for varchar(max) in SQL Server 2005.
    • national text
      • T-SQL> ntext. Max characters = 2^30 - 1 ~1.07e9 ~ 1 GB. Deprecated for nvarchar(max) in SQL Server 2005.
  • 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 non-error 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 non-error empty string).
    • OLE DB> dbtype_str.
• 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.
      • T-SQL> bit.  Non-zero integers converted to 1.
    • bit[(n)]. Stored as n b. Unsigned: 2^n = 0 to 2^n - 1. Signed: 2^(n-1) to 2^(n-1) - 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.
      • T-SQL> 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.
      • T-SQL> 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.
      • T-SQL> 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.
      • T-SQL> 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.
      • T-SQL> uniqueidentifier. A GUID (Globally Unique Identifier) with this syntax: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. Note that each x is a hexadecimal. EG: 6F9619FF-8B86-D011-B42D-00C04FC964FF. 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.
      • T-SQL> 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.
  • 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)].
      • T-SQL> 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.
  • 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.
    • T-SQL> 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.
• 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.
      • T-SQL> decimal[(p[,s])] = numeric[(p[,s])]. ±10^38. Default p,s = 18,0. Max p = 38. p >= s >= 0. If p = 1-9, then stores as 5 B. p = 10-19, then 9 B (the default size). p = 20-28, then 13 B. p = 29-38, then 17 B.
    • money
      • Access> Currency. Comparable to decimal(19,4).
      • OLE DB> dbtype_cy.
      • T-SQL> smallmoney. ~±214,748.3648. Comparable to decimal(10,4). Stored as 4 B.
      • T-SQL> money. ~±2^63 (~±9.22e14). Comparable to decimal(19,4). Stored as 8 B.
  • 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.401298e-45 for negative values and from 1.401298e-45 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.175494351e-38 for negative values and from 1.175494351e-38 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.
      • T-SQL> real. ~±3.40e38. p = 7. Stored as 4 B.
      • T-SQL> float[(b)] when b is 1-24, 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.94065645841247e-324 for negative values and from 1.79769313486231e308 to 4.94065645841247e-324 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.2250738585072014e-308 for negative values and 2.2250738585072014e-308 to 1.7976931348623157e308 for positive values. p ~15 by default. Unsigned disallows negative values.
      • OLE DB> dbtype_r8.
      • PLSQL> double precision = float
      • T-SQL> float[(b)] when b is 25-53, 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.
• Date and Time
  • date
    • aaGH> date. Date value between 1000-01-01 and 9999-12-31. (MySQL got it right!) Accepts strings or numbers. Date parts can be entered as zero if not certain. EG: '1999-00-00'. Two digit year values are converted as follows: 00/69 = 2000/2069 and 70/99 = 1970/1999.
    • MySQL> date. Date value between 1000-01-01 and 9999-12-31. Lovely ISO format! Accepts strings or numbers. Date parts can be entered as zero if not certain. EG: '1999-00-00'. Stored as 3 B.
    • MySQL> year[(2|4)]. 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.
  • 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.0000 to 24:59:59.9999. 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.
  • time with time zone
    • aaGH> timetzd. Time value as hh:mm:ss.ssss±hh:mm.
  • timestamp
    • aaGH> datetime. Date and time value between 1000-01-01 00:00:00 to 9999-12-31 23:59:59. Accepts strings or numbers.
    • aaGH> datetimetzd. Date and time value between 1000-01-01 00:00:00±hh:mm to 9999-12-31 23:59:59±hh:mm. Accepts strings or numbers.
    • MySQL> datetime. Date and time value between 1000-01-01 00:00:00 to 9999-12-31 23:59:59. Accepts strings or numbers. Stored as 8 B.
    • MySQL> timestamp[(n)]. Date and time value between 1970-01-01 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: -4712-01-01/4712-12-31. v8 = v9: -4712-01-01/9999-12-31.
    • PLSQL> timestamp(n). Date and time. n is 0 to 9 and indicates decimal places of second. Stores as 7-11 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 7-11 B.
    • T-SQL> smalldatetime. Date and time value between 1900-01-01/2079-06-06. Accurate to the minute. Stored as two 2 B integers.
    • T-SQL> datetime. Date and time value between 1753-01-01/9999-12-31. Accurate to 3.33 ms. Stored as two 4 B integers.
    • T-SQL> I hope Microsoft will come out with a timestamp with the time zone
  • rowversion
    • T-SQL> timestamp. A database-wide unique number that gets updated every time a row gets updated.
• 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.
  • T-SQL> cursor. A reference to a cursor. Cannot be used for a column.
  • T-SQL> sql_variant. A data type that stores values of various SQL Server-supported data types, except text, ntext, timestamp, and sql_variant.
  • T-SQL> 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 single-digit and non-zero, then M is said to be "normalized". EG: Of these significants, 1.2, 12, and -0.12, all have p = 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 and e = 2, then 102 = 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.2e-1 = -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 Floating-Point Arithmetic), the most common standard for floating point computations, specifies four formats for representing floating point values.

• single-precision (32-bit). 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             |
   |0|00000000|00000000000000000000000|   zero
   |x|00000000|  non-zero             |   denormalized number
   |x| 1-254  |  any                  |   normalized number
   |1|10000101|11011010100000000000000|   EG: -118.625
   |x|11111111|00000000000000000000000|   infinity
   |x|11111111|  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.

• double-precision (64-bit). This is SQL datatype float8, float(53), float, or double precision.

    1     11                                52
   +-+-----------+----------------------------------------------------+
   |S|  Exp      |  Fraction                                          |
   +-+-----------+----------------------------------------------------+
   63 62       52 51                                                 0
      bias +1023

• single-extended precision (≥ 43-bit, not commonly used)
• double-extended precision (≥ 79-bit, 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₁₀ 120 =
log₁₀ (10² * 1.2) =
log₁₀ (1.2 * 10²) =
log₁₀ (10²) + log₁₀ (1.2) ~
2 + 0.079181

The 2 was the characteristic and the 0.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 eight-byte 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 null-terminated character string (Unicode) (DBTYPE_BSTR).
	adChapter	136	Indicates a four-byte 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 fixed-point number with four digits to the right of the decimal point. It is stored in an eight-byte 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 double-precision floating-point value (DBTYPE_R8).
	adEmpty	0	Specifies no value (DBTYPE_EMPTY).
	adError	10	Indicates a 32-bit error code (DBTYPE_ERROR).
	adFileTime	64	Indicates a 64-bit value representing the number of 100-nanosecond 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 four-byte 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 null-terminated 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 single-precision floating-point value (DBTYPE_R4).
X	adSmallInt	2	Indicates a two-byte signed integer (DBTYPE_I2).
	adTinyInt	16	Indicates a one-byte signed integer (DBTYPE_I1).
	adUnsignedBigInt	21	Indicates an eight-byte unsigned integer (DBTYPE_UI8).
	adUnsignedInt	19	Indicates a four-byte unsigned integer (DBTYPE_UI4).
	adUnsignedSmallInt	18	Indicates a two-byte unsigned integer (DBTYPE_UI2).
	adUnsignedTinyInt	17	Indicates a one-byte unsigned integer (DBTYPE_UI1).
	adUserDefined	132	Indicates a user-defined 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 null-terminated Unicode character string (Parameter object only).
	adWChar	130	Indicates a null-terminated Unicode character string (DBTYPE_WSTR).

Page Modified: (Hand noted: 2007-10-05 19:18:45Z) (Auto noted: 2007-11-17 06:47:52Z)