ODBCTypes Class Reference

Inheritance diagram for ODBCTypes:

CreoleTypes

List of all members.

Static Public Member Functions

static loadTypeMap ($conn=null)
 Loads the map of ODBC data types to Creole (JDBC) types.
static getType ($nativeType)
 This method returns the generic Creole (JDBC-like) type when given the native db type.
static getNativeType ($creoleType)
 This method will return a native type that corresponds to the specified Creole (JDBC-like) type.

Static Protected Attributes

static $typeMap = null
 Map ODBC native types to Creole (JDBC) types.
static $reverseMap = null
 Reverse mapping, created on demand.


Detailed Description

Definition at line 32 of file ODBCTypes.php.


Member Function Documentation

static ODBCTypes::getNativeType ( creoleType  )  [static]

This method will return a native type that corresponds to the specified Creole (JDBC-like) type.

If there is more than one matching native type, then the LAST defined native type will be returned.

Parameters:
int $creoleType
Returns:
string Native type string.

Reimplemented from CreoleTypes.

Definition at line 178 of file ODBCTypes.php.

References loadTypeMap().

00179     {
00180         if (!self::$typeMap)
00181             self::loadTypeMap();
00182 
00183         if (self::$reverseMap === null) {
00184             self::$reverseMap = array_flip(self::$typeMap);
00185         }
00186         return @self::$reverseMap[$creoleType];
00187     }

static ODBCTypes::getType ( nativeType  )  [static]

This method returns the generic Creole (JDBC-like) type when given the native db type.

Parameters:
string $nativeType DB native type (e.g. 'TEXT', 'byetea', etc.).
Returns:
int Creole native type (e.g. CreoleTypes::LONGVARCHAR, CreoleTypes::BINARY, etc.).

Reimplemented from CreoleTypes.

Definition at line 156 of file ODBCTypes.php.

References loadTypeMap(), and CreoleTypes::OTHER.

Referenced by ODBCTableInfo::initColumns(), and ODBCCachedResultSet::loadCache().

00157     {
00158         if (!self::$typeMap)
00159             self::loadTypeMap();
00160 
00161         $t = strtoupper($nativeType);
00162 
00163         if (isset(self::$typeMap[$t])) {
00164             return self::$typeMap[$t];
00165         } else {
00166             return CreoleTypes::OTHER;
00167         }
00168     }

static ODBCTypes::loadTypeMap ( conn = null  )  [static]

Loads the map of ODBC data types to Creole (JDBC) types.

NOTE: This function cannot map DBMS-specific datatypes. If you use a driver which implements DBMS-specific datatypes, you will need to modify/extend this class to add the correct mapping.

Definition at line 51 of file ODBCTypes.php.

References $result, CreoleTypes::BIGINT, CreoleTypes::BINARY, CreoleTypes::BOOLEAN, CreoleTypes::CHAR, CreoleTypes::DATE, CreoleTypes::DECIMAL, CreoleTypes::DOUBLE, CreoleTypes::FLOAT, CreoleTypes::INTEGER, CreoleTypes::LONGVARBINARY, CreoleTypes::LONGVARCHAR, CreoleTypes::NUMERIC, CreoleTypes::OTHER, CreoleTypes::REAL, CreoleTypes::SMALLINT, CreoleTypes::TIME, CreoleTypes::TIMESTAMP, CreoleTypes::TINYINT, CreoleTypes::VARBINARY, and CreoleTypes::VARCHAR.

Referenced by getNativeType(), getType(), ODBCTableInfo::initColumns(), and ODBCCachedResultSet::loadCache().

00052     {
00053         if (self::$typeMap !== null && count(self::$typeMap) > 0)
00054             return;
00055 
00056         if ($conn == null)
00057             throw new SQLException('No connection specified when loading ODBC type map.');
00058 
00059         self::$typeMap = array();
00060 
00061         $result = @odbc_gettypeinfo($conn->getResource());
00062 
00063         if ($result === false)
00064             throw new SQLException('Failed to retrieve type info.', $conn->nativeError());
00065 
00066         $rowNum = 1;
00067 
00068         while (odbc_fetch_row($result, $rowNum++))
00069         {
00070             $odbctypeid = odbc_result($result, 'DATA_TYPE');
00071             $odbctypename = odbc_result($result, 'TYPE_NAME');
00072 
00073             switch ($odbctypeid)
00074             {
00075                 case SQL_CHAR:
00076                     self::$typeMap[$odbctypename] = CreoleTypes::CHAR;
00077                     break;
00078                 case SQL_VARCHAR:
00079                     self::$typeMap[$odbctypename] = CreoleTypes::VARCHAR;
00080                     break;
00081                 case SQL_LONGVARCHAR:
00082                     self::$typeMap[$odbctypename] = CreoleTypes::LONGVARCHAR;
00083                     break;
00084                 case SQL_DECIMAL:
00085                     self::$typeMap[$odbctypename] = CreoleTypes::DECIMAL;
00086                     break;
00087                 case SQL_NUMERIC:
00088                     self::$typeMap[$odbctypename] = CreoleTypes::NUMERIC;
00089                     break;
00090                 case SQL_BIT:
00091                     self::$typeMap[$odbctypename] = CreoleTypes::BOOLEAN;
00092                     break;
00093                 case SQL_TINYINT:
00094                     self::$typeMap[$odbctypename] = CreoleTypes::TINYINT;
00095                     break;
00096                 case SQL_SMALLINT:
00097                     self::$typeMap[$odbctypename] = CreoleTypes::SMALLINT;
00098                     break;
00099                 case SQL_INTEGER:
00100                     self::$typeMap[$odbctypename] = CreoleTypes::INTEGER;
00101                     break;
00102                 case SQL_BIGINT:
00103                     self::$typeMap[$odbctypename] = CreoleTypes::BIGINT;
00104                     break;
00105                 case SQL_REAL:
00106                     self::$typeMap[$odbctypename] = CreoleTypes::REAL;
00107                     break;
00108                 case SQL_FLOAT:
00109                     self::$typeMap[$odbctypename] = CreoleTypes::FLOAT;
00110                     break;
00111                 case SQL_DOUBLE:
00112                     self::$typeMap[$odbctypename] = CreoleTypes::DOUBLE;
00113                     break;
00114                 case SQL_BINARY:
00115                     self::$typeMap[$odbctypename] = CreoleTypes::BINARY;
00116                     break;
00117                 case SQL_VARBINARY:
00118                     self::$typeMap[$odbctypename] = CreoleTypes::VARBINARY;
00119                     break;
00120                 case SQL_LONGVARBINARY:
00121                     self::$typeMap[$odbctypename] = CreoleTypes::LONGVARBINARY;
00122                     break;
00123                 case SQL_DATE:
00124                     self::$typeMap[$odbctypename] = CreoleTypes::DATE;
00125                     break;
00126                 case SQL_TIME:
00127                     self::$typeMap[$odbctypename] = CreoleTypes::TIME;
00128                     break;
00129                 case SQL_TIMESTAMP:
00130                     self::$typeMap[$odbctypename] = CreoleTypes::TIMESTAMP;
00131                     break;
00132                 case SQL_TYPE_DATE:
00133                     self::$typeMap[$odbctypename] = CreoleTypes::DATE;
00134                     break;
00135                 case SQL_TYPE_TIME:
00136                     self::$typeMap[$odbctypename] = CreoleTypes::TIME;
00137                     break;
00138                 case SQL_TYPE_TIMESTAMP:
00139                     self::$typeMap[$odbctypename] = CreoleTypes::TIMESTAMP;
00140                     break;
00141                 default:
00142                     self::$typeMap[$odbctypename] = CreoleTypes::OTHER;
00143                     break;
00144             }
00145         }
00146 
00147         @odbc_free_result($result);
00148     }


Member Data Documentation

ODBCTypes::$reverseMap = null [static, protected]

Reverse mapping, created on demand.

Definition at line 42 of file ODBCTypes.php.

ODBCTypes::$typeMap = null [static, protected]

Map ODBC native types to Creole (JDBC) types.

Definition at line 37 of file ODBCTypes.php.


The documentation for this class was generated from the following file:

Generated on Wed May 6 23:10:50 2009 for fareofficelib by  doxygen 1.5.8