odbc-rails 1.2

data/AUTHORS

@@ -0,0 +1,16 @@
+#
+#  List of Authors/Contributors
+#
+
+Original Author:
+----------------
+Carl Blakeley <cblakeley@openlinksw.co.uk>				(cb)
+
+
+Current Maintainer:
+-------------------
+Patrick van Kleef <iodbc@@openlinksw.com>				(pvk)
+
+
+Contributors:
+-------------

data/COPYING

@@ -0,0 +1,21 @@
+OpenLink ODBC Adapter for Ruby on Rails
+Copyright (C) 2006 OpenLink Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject
+to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ChangeLog

@@ -0,0 +1,89 @@
+2006-12-11 12:01  source
+
+	* Updated for final release 1.2
+
+2006-12-11 12:00  source
+
+	* Added additional documentation for installing gem and plugin version
+
+2006-12-06 16:16  source
+
+	* Added for gem support
+
+2006-12-06 16:14  source
+
+	* Added dependency to activerecord
+
+2006-12-06 15:01  source
+
+	* Fixed version number
+
+2006-12-06 15:01  source
+
+	* Changed doc into rdoc
+
+2006-12-06 14:55  source
+
+	* Added support for building plugin
+	* Added support for building gem
+
+2006-12-06 14:42  source
+
+	* Changed directory structure for building both plugin and gem
+
+2006-11-22 15:53  source
+
+	* Added support for Progress versions 8 (SQL89 engine), 9 & 10 (SQL92 engine)
+
+2006-10-18 14:32  source
+
+	* Updated package version to 1.1
+
+2006-10-10 14:13  source
+
+	* Less files to ignore
+
+2006-10-10 10:57  source
+
+	* Reindented code (cmb)
+
+2006-10-09 09:03  source
+
+	* Latest diff for rails code (cmb)
+
+2006-10-09 07:25  source
+
+	* Added support for DB2 (cmb)
+
+2006-10-09 07:23  source
+
+	* Renamed sybase_odbc.sql to sybase.sql (cmb)
+
+2006-09-28 10:31  source
+
+	* Added support for MySQL, Sybase and SQL Server (cb)
+
+2006-08-23 14:07  source
+
+	* Final documentation patches
+
+2006-08-22 20:26  source
+
+	Initial checkin
+
+2006-08-21 23:37  source
+
+	Initial checkin
+
+2006-08-21 14:00  source
+
+	Initial checkin
+
+2006-08-21 12:57  source
+
+	Initial checkin
+
+2006-08-17 16:54  source
+
+	Initial checkin
+

data/LICENSE

@@ -0,0 +1,5 @@
+ODBC Adapter for Ruby on Rails
+Copyright (C) 2006 OpenLink Software
+
+The OpenLink ODBC Adapter for Ruby on Rails is released under the
+MIT license (see COPYING).

data/NEWS

@@ -0,0 +1,12 @@
+December 11, 2006, V1.2:
+  * Added option to install adapter as a gem
+  * Added option to install adapter as a plugin
+  * Added support for Progress 8 (SQL 89) 
+  * Added support for Progress 9 and 10 (SQL 92)
+
+October 18, 2006, V1.1:
+  * Added support for DB2, MySQL, Sybase and SQL Server
+  * Fixed initial unicode support
+
+August 23 2006, V1.0:
+  * Initial archive

data/README

@@ -0,0 +1,282 @@
+= OpenLink ODBC Data Adapter for Ruby on Rails
+
+(C) 2006 OpenLink Software
+
+11-December-2006
+
+
+== Status
+
+The adapter accompanying this note is a Generic ODBC Adapter for Ruby on Rails
+being developed by <B>OpenLink&nbsp;Software</B>[http://www.openlinksw.com].
+
+The aim of this development is to provide a single ODBC-based adapter
+capable of supporting the most popular DBMSes, in contrast to the
+current approach in the Rails community of each database requiring
+its own adapter.
+
+It currently supports Ingres r3, Informix 9.3 or later, Oracle 10g,
+MySQL 5 and OpenLink's Virtuoso
+(Open&nbsp;Source&nbsp;Edition[http://virtuoso.openlinksw.com]), 
+SQL Server 2000, Sybase ASE 15, DB2 v9 and Progress v8/9/10
+
+Testing to date has been limited to the ROR 'Expenses' sample
+application described at http://developer.apple.com/tools/rubyonrails.html
+and the ActiveRecord test modules base_test.rb and migration_test.rb.
+
+Testing has been performed on Linux, Windows and Mac OS X using
+OpenLink's own ODBC drivers and the native Virtuoso ODBC client.
+
+
+== Pre-Requisites
+
+The OpenLink ODBC Adapter for Ruby on Rails needs the
+ActiveRecord[http://wiki.rubyonrails.com/rails/pages/ActiveRecord]
+package installed.
+
+The Adapter also requires Christian Werner's
+Ruby&nbsp;ODBC&nbsp;Bridge[http://www.ch-werner.de/rubyodbc]
+(release 0.9991 or later), to bridge to an underlying ODBC driver.
+
+
+== Contents
+
+In the accompanying sources, the lib directory structure is equivalent
+to the lib directory located under ACTIVE_RECORD_ROOT in your main
+Ruby tree.
+
+On Windows ACTIVE_RECORD_ROOT will be something like:
+
+    c:\ruby\lib\ruby\gems\1.8\gems\activerecord-x.y.z
+
+On Unix and Mac OS X ACTIVE_RECORD_ROOT will be something like:
+
+    /usr/lib/ruby/gems/1.8/gems/activerecord-x.y.z
+or
+    /usr/local/lib/ruby/gems/1.8/gems/activerecord-x.y.z
+
+On Mac OS X using Locomotive ACTIVE_RECORD_ROOT will be
+something like:
+
+    /Applications/Locomotive2/bundles/rails112.locobundle/i386/lib/ruby/gems/1.8/gems/activerecord-x.y.z
+
+lib/ contains the files which constitute the new ODBC adapter.
+
+test/ contains the fixture definitions for testing the adapter.
+
+support/odbc_rails.diff contains some patches to ActiveRecord.
+
+These will be submitted to the ActiveRecord source maintainer in
+due course, if we request that the OpenLink ODBC Adapter for Ruby
+on Rails be added to the ActiveRecord source distribution to accompany
+the existing Rails adapters.
+
+Only one patch in this diff file is really necessary - that to
+
+    lib/active_record/connection_adapters/abstract/schema_definitions.rb
+
+This fixes what appears to be a bug in Active Record.
+
+The patches to base_test.rb and migration_test.rb are not essential.
+However, they modify or bypass certain tests to cope with limitations
+of particular databases. Other developers have previously modified
+the tests similarly to cope with limitations of other Rails-supported
+databases. The patched versions of files touched by odbc_rails.diff can be 
+found in support/lib and support/test.
+
+== Installation
+
+There are 3 ways to install the ODBC Adapter package: either as a gem
+(recommended), a plugin, or by running the custom installation script. Pick
+one of the following, depending on whether you want the adapter to be
+available system-wide or just within a particular Rails project.
+
+=== Installation as a Gem
+
+Install the odbc-rails gem by running:
+
+    # gem install -r odbc-rails --include-dependencies
+
+Enable loading of the adapter by editing your Rails project's
+config/environment.rb script: 
+
+   * Add a <tt>require</tt> to your config/environment.rb immediately after
+     the line
+
+       require File.join(File.dirname(__FILE__), 'boot')
+
+     i.e.
+
+       require File.join(File.dirname(__FILE__), 'boot')
+       require 'odbc_adapter'
+
+
+=== Installation as a Plugin
+
+Installing the OpenLink ODBC Data Adapter as a plugin makes it available to
+a particular Rails application only.
+
+==== Automatic Plugin installation
+
+The adapter can be automatically installed as a plugin by navigating to the
+root of your Rails application and typing either:
+
+    script/plugin install odbc-rails
+or
+    script/plugin install http://odbc-rails.rubyforge.org/plugins/odbc-rails
+
+On Windows, replace <tt>script/plugin</tt> by <tt>ruby script/plugin</tt>.
+e.g. <tt>ruby script/plugin install odbc-rails</tt>
+
+
+==== Manual Plugin Installation
+
+You can also install the plugin manually by unpacking the sources into the
+vendor/plugins directory of your Rails application. If you use this method,
+you must run install.rb immediately afterwards. This need only be done once.
+
+install.rb modifies your application's config/environment.rb file, adding a
+line to ensure that the database adapter plugin is initialized before
+ActiveRecord. i.e.
+
+    require File.join(File.dirname(__FILE__), 'boot')
+
+    # Added by OpenLink ODBC Adapter (odbc-rails) plugin
+    Rails::Initializer.run(:load_plugins)
+
+    Rails::Initializer.run do |config|
+
+Without this change, Rails attempts to initialize ActiveRecord before it loads 
+any plugins, causing an AdapterNotFound error. install.rb saves a copy of 
+environment.rb before making any changes.
+
+=== Custom installation script
+
+When using <tt>rake install</tt> or running the install_odbc.rb script by
+hand, the script tries to determine the location of the activerecord
+package within your Ruby installation and allows you to overrule the
+directory it has found with a directory of your choice. If more than one
+version of activerecord is found, the default will be the latest version.
+
+On Mac OS X the installation script is also capable of locating Locomotive,
+if installed, and will ask to install in there.
+
+The install_odbc.rb script also verifies that the pre-requisites are
+installed.
+
+If all else fails this document also describes the steps to install the
+ODBC adapter into activerecord manually.
+
+
+==== Using rake
+
+The simplest way to install the adapter is by using the following
+command as root:
+
+    # rake install
+
+or if your system supports sudo:
+
+    $ sudo rake install
+
+
+The Rakefile also defines some targets specifically for developers:
+
+    $ rake rdoc         # Generate rdoc documentation in ~/doc
+
+    $ rake package	# Create distribution package in ~/distrib
+
+    $ rake clean	# Remove generated files and directories
+
+
+==== Running installation script
+
+The second way of installing the adapter is running the
+<tt>install_odbc.rb</tt> script as root.
+
+    # ruby install_odbc.rb
+
+or if your system supports sudo:
+
+    $ sudo ruby install_odbc.rb
+
+
+=== Installing files manually
+
+The third way of installing the adapter is by performing the installation
+steps yourself.
+
+* Copy odbc_adapter.rb to the ACTIVE_RECORD_ROOT/lib/active_record/connection_adapters/ directory
+
+* Copy the odbcext_*.rb files to the ACTIVE_RECORD_ROOT/lib/active_record/vendor/ directory
+
+* Enable loading of the adapter (see below)
+
+
+== Enabling Loading of the Adapter
+
+This step is only necessary if the adapter was installed either as a gem or
+by copying files into your Rails core manually. It is not required if the
+adapter was installed as a plugin, using <tt>rake install</tt> or using
+install_odbc.rb.
+
+There are two ways to enable loading of the adapter:
+
+1. Modify active_record.rb in your Rails 'core', adding the ODBC adapter to
+   the list of adapters recognized by ActiveRecord:
+
+   * Edit ACTIVE_RECORD_ROOT/lib/active_record.rb, appending `odbc' to the line:
+
+       RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase)
+
+     i.e.
+
+       RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql ... openbase odbc)
+
+     *or*
+
+2. Modify your Rails application's configuration to <tt>require</tt> the
+   adapter:
+
+
+   * Add a <tt>require</tt> to your config/environment.rb immediately after
+     the line
+
+       require File.join(File.dirname(__FILE__), 'boot')
+
+     i.e.
+
+       require File.join(File.dirname(__FILE__), 'boot')
+       require 'odbc_adapter'
+
+== Configuring the Adapter
+
+Examples of the required connection parameters can be found in
+
+   test/connections/native_odbc/connection.rb
+
+If you enable call-tracing by setting :trace => true,  specify the
+logger output file as illustrated in connection.rb, e.g.
+
+    ActiveRecord::Base.logger = Logger.new("debug_odbc.log")
+
+
+== License
+
+The OpenLink ODBC Adapter for Ruby on Rails is released under the
+MIT license as detailed in the file COPYING.
+
+
+=== Submitting fixes and enhancements
+
+Patches and new contributions can be submitted as diffs from the
+current CVS archive by:
+
+    $ cvs add newfiles
+
+    $ cvs -z3 diff -uN > diffs
+
+Patches and  contributions can be send to the OpenLink iODBC source
+archive mainainter at mailto:iodbc@openlinksw.com to be included
+in the next distribution. Please provide accompanying documentation
+on which bugs are fixed or new features are introduced.

data/lib/active_record/connection_adapters/odbc_adapter.rb

@@ -0,0 +1,1792 @@
+#
+#  $Id: odbc_adapter.rb,v 1.2 2006/12/11 12:00:10 source Exp $
+#
+#  OpenLink ODBC Adapter for Ruby on Rails
+#  Copyright (C) 2006 OpenLink Software
+#
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject
+#  to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+#  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+#  ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+#  CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+begin
+  require_library_or_gem 'odbc' unless self.class.const_defined?(:ODBC)
+  #-------------------------------------------------------------------------
+  
+  module ActiveRecord
+    class Base  # :nodoc:
+      def self.odbc_connection(config) #:nodoc:     
+        config = config.symbolize_keys      
+        if config.has_key?(:dsn)
+          dsn = config[:dsn]
+        else
+          raise ActiveRecordError, "No data source name (DSN) specified."
+        end
+        username = config[:username] ? config[:username].to_s : nil
+        password = config[:password] ? config[:password].to_s : nil
+        trace = config[:trace] ? config[:trace] : false
+        conv_num_lits = config[:convert_numeric_literals] ? config[:convert_numeric_literals] : false
+        conn = ODBC::connect(dsn, username, password)      
+        conn.autocommit = true
+        ConnectionAdapters::ODBCAdapter.new(conn, [dsn, username, password],
+                                            trace, conv_num_lits, logger)
+      end
+    end # class Base
+    
+    module ConnectionAdapters # :nodoc:
+      
+      # This is an ODBC adapter for the ActiveRecord framework.
+      #
+      # The ODBC adapter requires the Ruby ODBC module (version 0.9991 or 
+      # later), available from http://raa.ruby-lang.org/project/ruby-odbc
+      #
+      # == Status at 11-Dec-2006
+      #
+      # The current adapter supports Ingres r3, Informix 9.3 or later, 
+      # Virtuoso (Open-Source Edition) 4.5, Oracle 10g, MySQL 5, 
+      # SQL Server 2000, Sybase ASE 15, DB2 v9, Progress 9/10 (SQL-92 engine)
+      # and Progress 8 (SQL-89 engine).
+      #
+      # == Testing Environments
+      #
+      # The adapter has been tested in the following environments:
+      # * Windows XP, Linux Fedora Core, Mac OS X
+      # The iODBC Driver Manager was used on Linux and Mac OS X.
+      #
+      # Databases supported using OpenLink ODBC drivers:
+      # * Informix, Ingres, Oracle, MySQL, SQL Server, Sybase, DB2, Progress
+      # Databases supported using the database's own native ODBC driver:
+      # * Virtuoso, MySQL, Informix
+      #
+      # === Note
+      # * OpenLink ODBC drivers work with v0.998 or later of the Ruby ODBC 
+      #   bridge.
+      # * The native MySQL driver requires v0.9991 of the Ruby ODBC bridge.
+      #
+      # == Information
+      #
+      # More information can be found at:
+      # * http://rubyforge.org/projects/odbc-rails/
+      # * http://odbc-rails.openlinksw.com 
+      # * http://virtuoso.openlinksw.com/wiki/main/OdbcRails/RailsAdapterWeb
+      # * http://sourceforge.net/projects/virtuoso/
+      #
+      # Maintainer: Carl Blakeley (mailto:cblakeley@openlinksw.co.uk)
+      #
+      # == Connection Options
+      #
+      # The following options are supported by the ODBC adapter.
+      #
+      # <tt>:dsn</tt>::
+      #   Specifies the ODBC data source name.
+      # <tt>:username</tt>::
+      #   Specifies the database user.
+      # <tt>:password</tt>::
+      #   Specifies the database password.
+      # <tt>:trace</tt>::
+      #   If set to <tt>true</tt>, turns on simple call tracing to the log file
+      #   referenced by ActiveRecord::Base.logger. If omitted, <tt>:trace</tt>
+      #   defaults to <tt>false</tt>. (We also suggest setting 
+      #   ActiveRecord::Base.colorize_logging = false).
+      # <tt>:convert_numeric_literals</tt>::
+      #   If set to <tt>true</tt>, suppresses quoting of numeric literals.
+      #   If omitted, <tt>:convert_numeric_literals</tt> defaults to 
+      #   <tt>false</tt>.
+      #   
+      # == Usage Notes
+      # === Informix
+      # In order to match the formats of Ruby's Date, Time and DateTime types,
+      # the following settings for Informix were used:
+      # * DBDATE=Y4MD-
+      # * DBTIME=%Y-%m-%d %H:%M:%S
+      # To support mixed-case/quoted table names:
+      # * DELIMIDENT=y
+      # To allow embedded newlines in quoted strings:
+      # * set ALLOW_NEWLINE=1 in the ONCONFIG configuration file.
+      #
+      # The adapter relies on an ODBC extension to SQLGetStmtOption implemented
+      # by some ODBC drivers (SQL_LASTSERIAL=1049) to retrieve the primary key 
+      # value auto-generated by an insert into a SERIAL column.
+      #
+      # === Ingres
+      # To match the formats of Ruby's Time and DateTime types,
+      # the following settings for Ingres were used:
+      # * II_DATE_FORMAT=SWEDEN
+      #
+      # === Oracle
+      # If using an OpenLink Oracle driver or agent, the 'jetfix' configuration
+      # option must be enabled to obtain the correct type mappings.
+      # 
+      # === Sybase
+      # Set the connection option :convert_numeric_literals to <tt>true</tt> to 
+      # avoid errors similar to: 
+      # "Implicit conversion from datatype 'VARCHAR' to 'INT' is not allowed."
+      #
+      # :boolean columns use the BIT SQL type, which does not allow nulls or 
+      # indexes. If a DEFAULT is not specified for #create_table, the
+      # column will be declared with DEFAULT 0.
+      #
+      # Migrations are supported, but for ALTER TABLE commands to
+      # work, the database must have the database option 'select into' set to
+      # 'true' with sp_dboption.
+      # 
+      # === DB2
+      # Set the connection option :convert_numeric_literals to <tt>true</tt> to 
+      # avoid errors similar to: 
+      # "The data types of the operands for the operation "=" are not compatible."
+      # 
+      # To obtain the correct type mappings, ensure LongDataCompat is set to 1 
+      # in the file db2cli.ini included in the DB2 client.
+      # 
+      # Migrations are supported but the following methods are not
+      # implemented because of lack of support in DB2 SQL.
+      # * <tt>change_column, remove_column, rename_column</tt> 
+      #
+      # === Progress 9/10 with SQL-92 engine
+      # Connections to Progress v9 and above are assumed to be to the SQL-92 
+      # engine. Migrations are supported but the following methods are not
+      # implemented because of lack of support in Progress SQL.
+      # * <tt>rename_table, change_column, remove_column, rename_column</tt>
+      # 
+      # === Progress 8 with SQL-89 engine
+      # Set the connection option :convert_numeric_literals to <tt>true</tt>
+      # to avoid errors similar to: 
+      # "Incompatible data types in expression or assignment. (223)"
+      # 
+      # Migrations are supported but the following methods are not
+      # implemented because of lack of support in Progress SQL.
+      # * <tt>rename_table, change_column, remove_column, rename_column</tt>
+      # 
+      
+      class ODBCAdapter < AbstractAdapter
+        
+        #-------------------------------------------------------------------
+        # DbmsInfo holds DBMS-dependent information which cannot be derived 
+        # satisfactorily through ODBC
+        class DbmsInfo # :nodoc: all
+          private_class_method :new
+          @@dbmsInfo = nil        
+          @@dbms_lookup_tbl = {
+            # Uses dbmsName as key and dbmsMajorVer as a subkey.          
+            :db2 => {
+              :any_version => {
+                :primary_key => "integer generated by default as identity (start with 10000) primary key",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :informix => {
+              :any_version => {
+                :primary_key => "serial primary key",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :ingres => {
+              :any_version => {
+                :primary_key => "integer primary key not null",
+                :has_autoincrement_col => false,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :mysql => {
+              :any_version => {
+                :primary_key => "int(11) not null auto_increment primary key",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => false,
+                :supports_count_distinct => true
+              },
+              5 => {
+                :primary_key => "int(11) not null auto_increment primary key",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => false,
+                :supports_count_distinct => true
+              }
+            },
+            :microsoftsqlserver => {
+              :any_version => {
+                :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              },
+              8 => {
+                :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :oracle => {
+              :any_version => {
+                :primary_key => "number(10) PRIMARY KEY NOT NULL",
+                :has_autoincrement_col => false,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :progress => {
+              :any_version => {
+                :primary_key => "integer not null primary key",
+                :has_autoincrement_col => false,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :progress89 => {
+              :any_version => {
+                :primary_key => "integer not null unique",
+                :has_autoincrement_col => false,
+                :supports_migrations => true,
+                :supports_schema_names => false,
+                :supports_count_distinct => true
+              }
+            },
+            :sybase => {
+              :any_version => {
+                :primary_key => "int IDENTITY PRIMARY KEY",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            },
+            :virtuoso => {
+              :any_version => {
+                :primary_key => "int NOT NULL IDENTITY PRIMARY KEY",
+                :has_autoincrement_col => true,
+                :supports_migrations => true,
+                :supports_schema_names => true,
+                :supports_count_distinct => true
+              }
+            }
+          }
+          
+          def self.create
+            @@dbmsInfo = new unless @@dbmsInfo
+            @@dbmsInfo
+          end
+          
+          def get_info(dbms_name, dbms_major_ver, info_type)
+            if (val = @@dbms_lookup_tbl[dbms_name]) then
+              if (val = val[dbms_major_ver] || val = val[:any_version]) then 
+                val = val[info_type]        
+              end
+            end
+            if val.nil? then
+              raise ActiveRecordError, "Lookup for #{info_type} failed"
+            end
+            val
+          end
+        end # class DbmsInfo
+        
+        #---------------------------------------------------------------------
+        # DSInfo holds SQLGetInfo responses from the data source
+        class DSInfo # :nodoc: all
+          attr_reader :info
+          
+          # Specifies the miniminum information we need about the data source
+          @@baseInfo = 
+          [
+          ODBC::SQL_DBMS_NAME,
+          ODBC::SQL_DBMS_VER,
+          ODBC::SQL_IDENTIFIER_CASE,
+          ODBC::SQL_QUOTED_IDENTIFIER_CASE,
+          ODBC::SQL_IDENTIFIER_QUOTE_CHAR,
+          ODBC::SQL_MAX_IDENTIFIER_LEN,		
+          ODBC::SQL_MAX_TABLE_NAME_LEN,
+          ODBC::SQL_USER_NAME
+          ]
+          
+          def initialize(connection)
+            @connection = connection
+            @info = Hash.new
+            @@baseInfo.each { |i| @info[i] = nil }
+            getBaseInfo(@info)
+            # TODO: HACK! OpenLink's Progress ODBC driver reports 
+            # SQL_IDENTIFIER_CASE as SQL_IC_MIXED, but it should be 
+            # SQL_IC_UPPER. All the driver's ODBC catalog calls return 
+            # identifiers in uppercase.
+            @info[ODBC::SQL_IDENTIFIER_CASE] = ODBC::SQL_IC_UPPER if @info[ODBC::SQL_DBMS_NAME] =~ /progress/i
+          end
+          
+          private
+          def getBaseInfo(infoTypes)
+            infoTypes.each_key do |infoType|
+              begin
+                infoTypes[infoType] = @connection.get_info(infoType)
+              rescue ODBC::Error
+              end
+            end
+          end
+          
+        end # class DSInfo
+        
+        #---------------------------------------------------------------------
+        
+        # ODBC constants missing from Christian Werner's Ruby ODBC driver
+        SQL_NO_NULLS = 0           # :nodoc:
+        SQL_NULLABLE = 1           # :nodoc:
+        SQL_NULLABLE_UNKNOWN = 2   # :nodoc:
+        
+        # dbInfo: ref to DSInfo instance
+        attr_reader :dsInfo        # :nodoc:
+        
+        # The name of DBMS currently connected to.
+        #
+        # Different ODBC drivers might return different names for the same
+        # DBMS; so similar names are mapped to the same symbol. 
+        # _dbmsName_ is the SQL_DBMS_NAME returned by ODBC, downcased with
+        # whitespace removed. e.g. <tt>informix</tt>, <tt>ingres</tt>,
+        # <tt>microsoftsqlserver</tt> etc.      
+        attr_reader :dbmsName
+        
+        # Supports lookups of DBMS-dependent information/settings which
+        # cannot be derived satisfactorily through ODBC
+        @@dbmsLookups = DbmsInfo.create
+        
+        @@trace = nil
+        #--
+        
+        def initialize(connection, connection_options, trace, convert_numeric_literals, logger = nil)
+          @@trace = trace && logger if !@@trace
+          # Mixins in odbcext_xxx.rb included using Object#extend can't access
+          # @@trace. Why?
+          # (Error message "NameError: uninitialized class variable @@trace".)
+          # So create an equivalent instance variable
+          @trace = @@trace
+          
+          super(connection, logger)
+          
+          @logger.unknown("ODBCAdapter#initialize>") if @@trace
+          
+          @connection, @connection_options = connection, connection_options
+          @convert_numeric_literals = convert_numeric_literals
+          # Caches SQLGetInfo output
+          @dsInfo = DSInfo.new(connection)
+          # Caches SQLGetTypeInfo output
+          @typeInfo = nil 
+          # Caches mapping of Rails abstract data types to DBMS native types.
+          @abstract2NativeTypeMap = nil 
+          
+          # Set @dbmsName and @dbmsMajorVer from SQLGetInfo output.
+          # Each ODBCAdapter instance is associated with only one connection,
+          # so using ODBCAdapter instance variables for DBMS name and version
+          # is OK.
+          
+          @dbmsMajorVer = @dsInfo.info[ODBC::SQL_DBMS_VER].split('.')[0].to_i
+          @dbmsName = @dsInfo.info[ODBC::SQL_DBMS_NAME].downcase.gsub(/\s/,'')
+          # Different ODBC drivers might return different names for the same
+          # DBMS. So map similar names to the same symbol.
+          @dbmsName = dbmsNameToSym(@dbmsName, @dbmsMajorVer)
+                    
+          # Now we know which DBMS we're connected to, extend this ODBCAdapter 
+          # instance with the appropriate DBMS specific extensions
+          @odbcExtFile = "active_record/vendor/odbcext_#{@dbmsName}"
+          begin     
+            require "#{@odbcExtFile}"
+            self.extend ODBCExt
+          rescue MissingSourceFile
+            puts "ODBCAdapter#initialize> Couldn't find extension #{@odbcExtFile}.rb"        
+          end
+        end
+        
+        #--
+        # ABSTRACT ADAPTER OVERRIDES =======================================
+        #
+        # see abstract_adapter.rb
+        
+        # Returns the human-readable name of the adapter.
+        def adapter_name
+          @logger.unknown("ODBCAdapter#adapter_name>") if @@trace
+        'ODBC'
+        end
+        
+        # Does this adapter support migrations?
+        def supports_migrations?
+          @logger.unknown("ODBCAdapter#supports_migrations?>") if @@trace
+          @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :supports_migrations)
+        end
+        
+        # Does the database support COUNT(DISTINCT) queries?
+        # e.g. <tt>select COUNT(DISTINCT ArtistID) from CDs</tt>
+        def supports_count_distinct?
+          @logger.unknown("ODBCAdapter#supports_count_distinct?>") if @@trace
+          @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :supports_count_distinct)
+        end
+        
+        # Should primary key values be selected from their corresponding
+        # sequence before the insert statement?  If true, #next_sequence_value
+        # is called before each insert to set the record's primary key.
+        def prefetch_primary_key?(table_name = nil)
+          @logger.unknown("ODBCAdapter#prefetch_primary_key?>") if @@trace
+          # Return true for any DBMS which can't support #last_insert_id.
+          # i.e. doesn't support an autoincrement column type. An 
+          # implementation of #next_sequence_value must be provided for any
+          # such database.
+          !@@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :has_autoincrement_col)
+        end
+        
+        # Returns true if this connection active.
+        def active?
+          @logger.unknown("ODBCAdapter#active?>") if @@trace
+          @connection.connected?
+        end
+        
+        # Reconnects to the database.
+        def reconnect!
+          @logger.unknown("ODBCAdapter#reconnect!>") if @@trace
+          @connection.disconnect if @connection.connected?
+          @connection = ODBC::connect(*@connection_options)
+          # There's no need to refresh the data source info in @dsInfo because
+          # we're reconnecting to the same data source.
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Disconnects from the database.
+        def disconnect!
+          @logger.unknown("ODBCAdapter#disconnect!>") if @@trace
+          @connection.disconnect if @connection.connected?
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        #--
+        # QUOTING OVERRIDES ================================================
+        #
+        # see: abstract/quoting.rb
+        
+        # Quotes the column value
+        #--
+        # to help prevent {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+        #++
+        def quote(value, column = nil)
+          @logger.unknown("ODBCAdapter#quote>") if @@trace
+          @logger.unknown("args=[#{value}]") if @@trace
+          case value
+          when String
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "'#{quote_string(column.class.string_to_binary(value))}'"
+            elsif (column && [:integer, :float].include?(column.type)) ||
+             (column.nil? && @convert_numeric_literals && 
+             (value =~ /^[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?$/))
+              value
+            else
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
+          when NilClass then "NULL"
+          when TrueClass then (column && column.type == :integer ?
+							'1' : quoted_true)
+          when FalseClass then (column && column.type == :integer ? 
+							'0' : quoted_false)
+          when Float, Fixnum, Bignum then value.to_s
+          when Date then quoted_date(value)
+          when Time, DateTime then quoted_date(value)
+          else
+            super
+          end
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Quotes a string, escaping any ' (single quote) and \ (backslash)
+        # characters.
+        def quote_string(string)
+          @logger.unknown("ODBCAdapter#quote_string>") if @@trace
+          @logger.unknown("args=[#{string}]") if @@trace        
+          string.gsub(/\'/, "''")
+        end
+        
+        # Returns a quoted form of the column name.
+        def quote_column_name(name)
+          @logger.unknown("ODBCAdapter#quote_column_name>") if @@trace
+          @logger.unknown("args=[#{name}]") if @@trace        
+          name = name.to_s if name.class == Symbol                
+          idQuoteChar = @dsInfo.info[ODBC::SQL_IDENTIFIER_QUOTE_CHAR]
+          return name if !idQuoteChar || ((idQuoteChar = idQuoteChar.strip).length == 0)
+          idQuoteChar = idQuoteChar[0]
+          
+          # Avoid quoting any already quoted name
+          return name if name[0] == idQuoteChar && name[-1] == idQuoteChar
+          
+          # If DBMS's SQL_IDENTIFIER_CASE = SQL_IC_UPPER, only quote mixed 
+          # case names.
+          # See #dbmsIdentCase for the identifier case conventions used by this
+          # adapter.
+          if @dsInfo.info[ODBC::SQL_IDENTIFIER_CASE] == ODBC::SQL_IC_UPPER
+            return name unless (name =~ /([A-Z]+[a-z])|([a-z]+[A-Z])/)
+          end
+          
+          idQuoteChar.chr + name + idQuoteChar.chr
+        end
+        
+        def quoted_true
+          @logger.unknown("ODBCAdapter#quoted_true>") if @@trace
+				'1'
+        end
+        
+        def quoted_false
+          @logger.unknown("ODBCAdapter#quoted_false>") if @@trace
+				'0'
+        end
+        
+        def quoted_date(value)
+          @logger.unknown("ODBCAdapter#quoted_date>") if @@trace
+          @logger.unknown("args=[#{value}]") if @@trace        
+          # Ideally, we'd return an ODBC date or timestamp literal escape 
+          # sequence, but not all ODBC drivers support them.
+          case value
+          when Time, DateTime
+            #%Q!{ts #{value.strftime("%Y-%m-%d %H:%M:%S")}}!
+          %Q!'#{value.strftime("%Y-%m-%d %H:%M:%S")}'!
+          when Date
+            #%Q!{d #{value.strftime("%Y-%m-%d")}}!
+          %Q!'#{value.strftime("%Y-%m-%d")}'!
+          end
+        end
+        
+        #--
+        # DATABASE STATEMENTS OVERRIDES ====================================
+        #
+        # see: abstract/database_statements.rb
+        
+        # Begins a transaction (and turns off auto-committing).
+        def begin_db_transaction
+          @logger.unknown("ODBCAdapter#begin_db_transaction>") if @@trace
+          @connection.autocommit = false
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Commits the transaction (and turns on auto-committing).
+        def commit_db_transaction
+          @logger.unknown("ODBCAdapter#commit_db_transaction>") if @@trace
+          @connection.commit
+          # ODBC chains transactions. Turn autocommit on after commit to
+          # allow explicit transaction initiation.
+          @connection.autocommit = true
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Rolls back the transaction (and turns on auto-committing). 
+        def rollback_db_transaction
+          @logger.unknown("ODBCAdapter#rollback_db_transaction>") if @@trace
+          @connection.rollback
+          # ODBC chains transactions. Turn autocommit on after rollback to
+          # allow explicit transaction initiation.
+          @connection.autocommit = true
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Appends +LIMIT+ and/or +OFFSET+ options to a SQL statement.
+        # See DatabaseStatements#add_limit_offset!
+        #--
+        # Base class accepts only +LIMIT+ *AND* +OFFSET+      
+        def add_limit_offset!(sql, options)
+          @logger.unknown("ODBCAdapter#add_limit_offset!>") if @@trace
+          @logger.unknown("args=[#{sql}]") if @@trace        
+          if limit = options[:limit] then sql << " LIMIT #{limit}" end
+          if offset = options[:offset] then sql << " OFFSET #{offset}" end
+        end
+        
+        # Returns an array of record hashes with the column names as keys and
+        # column values as values.
+        def select_all(sql, name = nil)
+          @logger.unknown("ODBCAdapter#select_all>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}]") if @@trace
+          retVal = []
+          scrollableCursor = false
+          limit = 0
+          offset = 0
+          qry = sql.dup
+          
+          # Strip OFFSET and LIMIT from query if present, since ODBC doesn't
+          # support them in a generic form.
+          #
+          # TODO: Translate any OFFSET/LIMIT option to native SQL if DBMS supports it.
+          # This will perform much better than simulating them.
+          if qry =~ /(\bLIMIT\s+)(\d+)/i then
+            if (limit = $2.to_i) == 0 then return retVal end
+          end
+          
+          if qry =~ /(\bOFFSET\s+)(\d+)/i then offset = $2.to_i end
+          qry.gsub!(/(\bLIMIT\s+\d+|\bOFFSET\s+\d+)/i, '')
+          
+          # It's been assumed that it's quicker to support an offset and/or
+          # limit restriction using a forward-only cursor. A static cursor will 
+          # presumably take a snapshot of the whole result set, whereas when 
+          # using a forward-only cursor we only fetch the first offset+limit 
+          # rows.
+=begin        
+        if offset > 0 then
+          scrollableCursor = true
+          begin
+            # ODBCStatement::fetch_first requires a scrollable cursor
+            @connection.cursortype = ODBC::SQL_CURSOR_STATIC
+          rescue
+            # Assume ODBC driver doesn't support scrollable cursors
+            @connection.cursortype = ODBC::SQL_CURSOR_FORWARD_ONLY
+            scrollableCursor = false
+          end
+        end
+=end
+          
+          # Execute the query
+          begin
+            stmt = @connection.run(qry)
+          rescue Exception => e
+            stmt.drop unless stmt.nil?
+            @logger.unknown("exception=#{e}") if @@trace && name != :force_error
+            raise StatementInvalid, e.message
+          end
+          
+          rColDescs = stmt.columns(true)
+          
+          # Get the rows, handling any offset and/or limit stipulated
+          if scrollableCursor then
+            rRows = nil
+            # scrollableCursor == true => offset > 0
+            if stmt.fetch_scroll(ODBC::SQL_FETCH_ABSOLUTE, offset)
+              rRows = limit > 0 ? stmt.fetch_many(limit) : stmt.fetch_all
+            end
+          else
+            rRows = limit > 0 ? stmt.fetch_many(offset + limit) : stmt.fetch_all
+            # Enforce OFFSET
+            if offset > 0 then 
+              if rRows && rRows.length > offset then
+                rRows.slice!(0, offset)
+              else
+                rRows = nil
+              end
+            end
+            # Enforce LIMIT
+            if limit > 0 && rRows && rRows.length > limit then
+              rRows.slice!(limit..(rRows.length-1))
+            end
+          end
+          
+          # Convert rows from arrays to hashes					
+          if rRows
+            rRows.each do |row|
+              h = Hash.new
+               (0...row.length).each do |iCol|
+                h[activeRecIdentCase(rColDescs[iCol].name)] = 
+                convertOdbcValToGenericVal(row[iCol])
+              end
+              retVal << h
+            end
+          end
+          
+          stmt.drop
+          retVal
+        end
+        
+        # Returns a record hash with the column names as keys and column values
+        # as values.
+        def select_one(sql, name = nil)
+          @logger.unknown("ODBCAdapter#select_one>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}]") if @@trace
+          retVal = nil
+          scrollableCursor = false
+          offset = 0
+          qry = sql.dup
+          
+          # Strip OFFSET and LIMIT from query if present, since ODBC doesn't
+          # support them in a generic form.
+          #
+          # TODO: Translate any OFFSET/LIMIT option to native SQL if DBMS supports it.
+          # This will perform much better than simulating them.
+          if qry =~ /(\bLIMIT\s+)(\d+)/i then
+            # Check for 'LIMIT 0'	otherwise ignore LIMIT				
+            if $2.to_i == 0 then return retVal end
+          end
+          
+          if qry =~ /(\bOFFSET\s+)(\d+)/i then offset = $2.to_i end
+          qry.gsub!(/(\bLIMIT\s+\d+|\bOFFSET\s+\d+)/i, '')
+          
+          # It's been assumed that it's quicker to support an offset
+          # restriction using a forward-only cursor. A static cursor will 
+          # presumably take a snapshot of the whole result set, whereas when 
+          # using a forward-only cursor we only fetch the first offset+1 
+          # rows.
+=begin        
+        if offset > 0 then
+          scrollableCursor = true
+          begin
+            # ODBCStatement::fetch_first requires a scrollable cursor
+            @connection.cursortype = ODBC::SQL_CURSOR_STATIC
+          rescue
+            # Assume ODBC driver doesn't support scrollable cursors
+            @connection.cursortype = ODBC::SQL_CURSOR_FORWARD_ONLY
+            scrollableCursor = false
+          end
+        end
+=end        
+          # Execute the query
+          begin
+            stmt = @connection.run(qry)
+          rescue Exception => e
+            @logger.unknown("exception=#{e}") if @@trace
+            stmt.drop unless stmt.nil?
+            raise StatementInvalid, e.message
+          end
+          
+          # Get one row, handling any offset stipulated
+          rColDescs = stmt.columns(true)
+          if scrollableCursor then
+            # scrollableCursor == true => offset > 0
+            stmt.fetch_scroll(ODBC::SQL_FETCH_ABSOLUTE, offset)
+            row = stmt.fetch
+          else
+            row = nil
+            rRows = stmt.fetch_many(offset + 1)
+            if rRows && rRows.length > offset then 
+              row = rRows[offset]
+            end
+          end
+          
+          # Convert row from array to hash
+          if row then
+            retVal = h = Hash.new
+             (0...row.length).each do |iCol|
+              h[activeRecIdentCase(rColDescs[iCol].name)] = 
+              convertOdbcValToGenericVal(row[iCol])
+            end
+          end
+          
+          stmt.drop
+          retVal
+        end
+        
+        # Executes the SQL statement in the context of this connection.
+        # Returns the number of rows affected.
+        def execute(sql, name = nil)
+          @logger.unknown("ODBCAdapter#execute>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}]") if @@trace
+          if sql =~ /^\s*INSERT/i && 
+            [:microsoftsqlserver, :virtuoso, :sybase].include?(@dbmsName)
+            # Guard against IDENTITY insert problems caused by explicit inserts
+            # into autoincrementing id column.
+            insert(sql, name)
+          else
+            begin
+              @connection.do(sql)
+            rescue Exception => e
+              @logger.unknown("exception=#{e}") if @@trace
+              raise StatementInvalid, e.message
+            end
+          end
+        end
+        
+        alias_method :delete, :execute
+        alias_method :update, :execute
+        
+        # Returns the ID of the last inserted row.
+        def insert(sql, name = nil, pk = nil, id_value = nil, 
+                   sequence_name = nil)
+          @logger.unknown("ODBCAdapter#insert>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}|#{pk}|#{id_value}|#{sequence_name}]") if @@trace
+          # id_value ::= pre-assigned id
+          retry_count = 0
+          begin
+            pre_insert(sql, name, pk, id_value, sequence_name) if respond_to?("pre_insert")
+            stmt = @connection.run(sql)
+            table = sql.split(" ", 4)[2]
+            res = id_value || last_insert_id(table, sequence_name || 
+                                             default_sequence_name(table, pk), stmt)
+          rescue Exception => e
+            @logger.unknown("exception=#{e}") if @@trace
+            if @dbmsName == :virtuoso  && id_value.nil? && e.message =~ /sr197/i
+              # Error: Non unique primary key
+              # If id column is an autoincrementing IDENTITY column and there
+              # have been prior inserts using explicit id's, the sequence 
+              # associated with the id column could lag behind the id values
+              # inserted explicitly. In the course of subsequent inserts, if
+              # an explicit id isn't given, the autogenerated id may collide
+              # with a previously explicitly inserted value.
+              unless stmt.nil?
+                stmt.drop; stmt = nil
+              end
+              table_name = e.message =~/Non unique primary key on (\w+\.\w+\.\w+)/i ? $1 : nil
+              if table_name && retry_count == 0
+                retry_count += 1
+                # Set next sequence value to be greater than current max. pk value
+                set_sequence(table_name, pk)
+                retry
+              end
+            end
+            raise StatementInvalid, e.message
+          ensure
+            post_insert(sql, name, pk, id_value, sequence_name) if respond_to?("post_insert")
+            stmt.drop unless stmt.nil?
+          end
+          res
+        end
+        
+        # Returns the default sequence name for a table.
+        # Used for databases which don't support an autoincrementing column 
+        # type, but do support sequences.
+        def default_sequence_name(table, primary_key=nil)
+          @logger.unknown("ODBCAdapter#default_sequence_name>") if @@trace
+          @logger.unknown("args=[#{table}|#{primary_key}]") if @@trace
+        "#{table}_seq"
+        end
+        
+        # Set the sequence to the max value of the table�s column.
+        def reset_sequence!(table, column, sequence = nil)
+          @logger.unknown("ODBCAdapter#reset_sequence!>") if @@trace
+          @logger.unknown("args=[#{table}|#{column}|#{sequence}]") if @@trace
+          super(table, column, sequence)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        #--
+        # SCHEMA STATEMENTS OVERRIDES ======================================
+        #
+        # see: abstract/schema_statements.rb
+        
+        # Implemented by MySQL and SQL Server adapters
+        #def create_database(name)
+        #end
+        
+        # Implemented by MySQL, SQL Server and Oracle adapters
+        #def current_database
+        #end
+        
+        # Implemented by MySQL and SQL Server adapters
+        #drop_database(name)
+        #end
+        
+        # The maximum length a table alias can be.
+        def table_alias_length
+          maxIdentLen = @dsInfo.info[ODBC::SQL_MAX_IDENTIFIER_LEN]
+          maxTblNameLen = @dsInfo.info[ODBC::SQL_MAX_TABLE_NAME_LEN]
+          maxTblNameLen < maxIdentLen ? maxTblNameLen : maxIdentLen
+        end
+        
+        # Returns an array of table names, for database tables visible on the
+        # current connection.
+        def tables(name = nil)
+          @logger.unknown("ODBCAdapter#tables>") if @@trace
+          @logger.unknown("args=[#{name}]") if @@trace
+          tblNames = []
+          # TODO: ODBC::Connection#tables cannot filter on schema name
+          # Modify Werner's Ruby ODBC driver to allow this
+          currentUser = @dsInfo.info[ODBC::SQL_USER_NAME]
+          stmt = @connection.tables
+          resultSet = stmt.fetch_all || []
+          resultSet.each do |row| 
+            if @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :supports_schema_names)
+              tblNames << activeRecIdentCase(row[2]) if row[1].casecmp(currentUser) == 0
+            else
+              tblNames << activeRecIdentCase(row[2])
+            end
+          end
+          stmt.drop
+          tblNames
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Returns an array of Column objects for the table specified by +table_name+.
+        def columns(table_name, name = nil)
+          @logger.unknown("ODBCAdapter#columns>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{name}]") if @@trace
+          
+          table_name = table_name.to_s if table_name.class == Symbol
+          
+          getDbTypeInfo
+          cols = []
+          stmt = @connection.columns(dbmsIdentCase(table_name))
+          resultSet = stmt.fetch_all || []
+          resultSet.each do |col|
+            colName = col[3] # SQLColumns: COLUMN_NAME
+            colDefault = col[12] # SQLColumns: COLUMN_DEF
+            colSqlType = col[4] # SQLColumns: DATA_TYPE
+            colNativeType = col[5] # SQLColumns: TYPE_NAME
+            colLimit = col[6] # SQLColumns: COLUMN_SIZE
+            
+            odbcIsNullable = col[17] # SQLColumns: IS_NULLABLE
+            odbcNullable = col[10] # SQLColumns: NULLABLE
+            # isNotNullable == true  => *definitely not* nullable
+            #               == false => *may* be nullable
+            isNotNullable = (odbcIsNullable.match('NO') != nil)
+            # Assume column is nullable if odbcNullable == SQL_NULLABLE_UNKNOWN
+            colNullable = !(isNotNullable || odbcNullable == SQL_NO_NULLS)
+            
+            # HACK!
+            # MySQL native ODBC driver doesn't report nullability accurately.
+            # So force nullability of 'id' columns
+            colNullable = false if colName == 'id'
+            
+            # SQL Server ODBC drivers may wrap default value in parentheses
+            if colDefault =~ /^\('(.*)'\)$/ # SQL Server character default
+              colDefault = $1
+            elsif colDefault =~ /^\((.*)\)$/ # SQL Server numeric default
+              colDefault = $1
+              # ODBC drivers should return string column defaults in quotes
+              # Oracle also includes a trailing space.
+            elsif colDefault =~ /^'(.*)' *$/
+              colDefault = $1
+	        #TODO: HACKS for Progress
+            elsif @dbmsName == :progress || @dbmsName == :progress89
+              if colDefault =~ /^\?$/
+                colDefault = nil
+              elsif colSqlType == ODBC::SQL_BIT
+                if ["yes", "no"].include?(colDefault)
+                  colDefault = colDefault == "yes" ? 1 : 0
+                end
+              end
+            end
+            cols << ODBCColumn.new(activeRecIdentCase(colName), table_name, 
+            colDefault, colSqlType, colNativeType, colNullable, colLimit, 
+            @odbcExtFile+"_col", @typeInfo)
+          end
+          stmt.drop
+          cols
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Returns an array of indexes for the given table.
+        def indexes(table_name, name = nil)
+          @logger.unknown("ODBCAdapter#indexes>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{name}]") if @@trace
+          
+          indexes = []
+          indexCols = indexName = isUnique = nil
+          
+          stmt = @connection.indexes(dbmsIdentCase(table_name))
+          rs = stmt.fetch_all || []
+          rs.each_index do |iRow|
+            row = rs[iRow]
+            
+            # Skip table statistics
+            next if row[6] == 0 # SQLStatistics: TYPE
+            
+            if (row[7] == 1) # SQLStatistics: ORDINAL_POSITION
+              # Start of column descriptor block for next index
+              indexCols = Array.new
+              isUnique = (row[3] == 0) # SQLStatistics: NON_UNIQUE
+              indexName = String.new(row[5]) # SQLStatistics: INDEX_NAME
+            end
+
+            indexCols << activeRecIdentCase(row[8]) # SQLStatistics: COLUMN_NAME
+            
+            lastRow = (iRow == rs.length - 1)
+            if lastRow
+              lastColOfIndex = true
+            else
+              nextRow = rs[iRow + 1]
+              lastColOfIndex = (nextRow[6] == 0 || nextRow[7] == 1)
+            end
+
+            if lastColOfIndex
+              indexes << IndexDefinition.new(table_name, 
+                                             activeRecIdentCase(indexName), isUnique, indexCols)
+            end
+          end
+          indexes
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        ensure
+          stmt.drop unless stmt.nil?
+        end
+        
+        # Returns a Hash of mappings from Rails' abstract data types to the 
+        # native database types.  
+        # See TableDefinition#column for details of the abstract data types.
+        def native_database_types
+          @logger.unknown("ODBCAdapter#native_database_types>") if @@trace
+          
+          return {}.merge(@abstract2NativeTypeMap) unless @abstract2NativeTypeMap.nil?
+          
+          @abstract2NativeTypeMap = 
+          {
+            :primary_key => nil,
+            :string      => nil,
+            :text        => nil,
+            :integer     => nil,
+            :float       => nil,
+            :datetime    => nil,
+            :timestamp   => nil,
+            :time        => nil,
+            :date        => nil,
+            :binary      => nil,
+            :boolean     => nil
+          }
+          
+          getDbTypeInfo
+          
+          # hAbs2Sql = Hash of ActiveRecord abstract types to ODBC SQL types
+          hAbs2Sql = genericTypeToOdbcSqlTypesMap
+          
+          # hSql2Native = Hash of ODBC native data type descriptors from
+          #              SQLGetTypeInfo keyed on ODBC SQL type.
+          # The hash value is an array of all rows in the SQLGetTypeInfo result
+          # set for which DATA_TYPE matches the key.
+          hSql2Native = Hash.new
+          @typeInfo.each do |row|
+            sqlType = row[1] # SQLGetTypeInfo: DATA_TYPE
+            if (rNativeTypeDescs = hSql2Native[sqlType]) == nil
+              hSql2Native[sqlType] = rNativeTypeDescs = Array.new()
+            end
+            rNativeTypeDescs << row
+          end
+          
+          # For a particular abstract type, check if the DBMS supports one of
+          # the corresponding ODBC SQL types then, if so, find the native DBMS
+          # types corresponding to this ODBC SQL type and select the most
+          # suitable. (For each SQL type, SQLGetTypeInfo should return the
+          # closest match first).
+          @abstract2NativeTypeMap.each_key do |abstractType|
+            rCandidateSqlTypes = hAbs2Sql[abstractType]
+            isSupported = false
+            rCandidateSqlTypes.each do |sqlType|
+              if (rNativeTypeDescs = hSql2Native[sqlType])
+                @abstract2NativeTypeMap[abstractType] = 
+                nativeTypeMapping(abstractType, rNativeTypeDescs)
+                isSupported = true
+                break
+              end
+            end
+            @logger.unknown("WARNING: No suitable DBMS type for abstract type #{abstractType.to_s}") if !isSupported && @@trace
+          end
+          {}.merge(@abstract2NativeTypeMap)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Creates a new table. See SchemaStatements#create_table.
+        def create_table(name, options = {})
+          @logger.unknown("ODBCAdapter#create_table>") if @@trace
+          @logger.unknown("args=[#{name}]") if @@trace
+          super(name, options)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Renames a table.
+        def rename_table(name, new_name)
+          @logger.unknown("ODBCAdapter#rename_table>") if @@trace
+          @logger.unknown("args=[#{name}|#{new_name}]") if @@trace
+          # Base class raises NotImplementedError
+          super(name, new_name)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Drops a table from the database.
+        def drop_table(name)
+          @logger.unknown("ODBCAdapter#drop_table>") if @@trace
+          @logger.unknown("args=[#{name}]") if @@trace
+          super(name)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Adds a new column to the named table.
+        # See TableDefinition#column for details of the options you can use.      
+        def add_column(table_name, column_name, type, options = {})
+          @logger.unknown("ODBCAdapter#add_column>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}|#{type}]") if @@trace
+          super(table_name, column_name, type, options)				
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Removes the column from the table definition.
+        def remove_column(table_name, column_name)
+          @logger.unknown("ODBCAdapter#remove_column>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}]") if @@trace
+          super(table_name, column_name)								
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Changes the column�s definition according to the new options. 
+        # See TableDefinition#column for details of the options you can use.
+        def change_column(table_name, column_name, type, options = {})
+          @logger.unknown("ODBCAdapter#change_column>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}|#{type}]") if @@trace
+          # Base class raises NotImplementedError
+          super(table_name, column_name, type, options)            							
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Sets a new default value for a column.
+        def change_column_default(table_name, column_name, default)
+          @logger.unknown("ODBCAdapter#change_column_default>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}]") if @@trace
+          super(table_name, column_name, default)												
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        def rename_column(table_name, column_name, new_column_name)
+          @logger.unknown("ODBCAdapter#rename_column>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}|#{new_column_name}]") if @@trace
+          # Base class raises NotImplementedError
+          super(table_name, column_name, new_column_name)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        def remove_index(table_name, options = {})
+          @logger.unknown("ODBCAdapter#remove_index>") if @@trace
+          @logger.unknown("args=[#{table_name}]") if @@trace
+          super(table_name, options)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Not exercised by ActiveRecord test suite
+        def structure_dump # :nodoc:
+          @logger.unknown("ODBCAdapter#structure_dump>") if @@trace
+          raise NotImplementedError, "structure_dump is not implemented"
+        end
+        
+        #--
+        # WRAPPER METHODS FOR TRACING ======================================
+        
+        #--
+        # ------------------------------------------------------------------
+        # see: abstract/database_statements.rb
+        
+        # Returns a single value from a record
+        #--
+        # No need to implement beyond a tracing wrapper
+        def select_value(sql, name = nil)
+          @logger.unknown("ODBCAdapter#select_value>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}]") if @@trace
+          super(sql, name)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise StatementInvalid, e.message
+        end
+        
+        # Returns an array of the values of the first column in a select.
+        #--
+        # No need to implement beyond a tracing wrapper
+        def select_values(sql, name = nil)
+          @logger.unknown("ODBCAdapter#select_values>") if @@trace
+          @logger.unknown("args=[#{sql}|#{name}]") if @@trace        
+          super(sql, name)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise StatementInvalid, e.message
+        end
+        
+        # Wrap a block in a transaction. Returns result of block.
+        #--
+        # No need to implement beyond a tracing wrapper
+        def transaction(start_db_transaction = true)
+          @logger.unknown("ODBCAdapter#transaction>") if @@trace
+          super(start_db_transaction)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # Alias for #add_limit_offset!
+        #--
+        # No need to implement beyond a tracing wrapper
+        def add_limit!(sql, options)
+          @logger.unknown("ODBCAdapter#add_limit!>") if @@trace
+          @logger.unknown("args=[#{sql}]") if @@trace
+          super(sql, options)
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        #--
+        # ------------------------------------------------------------------
+        # see: abstract/schema_statements.rb
+        
+        # Adds a new index to the table.
+        # See SchemaStatements#add_index.
+        #--
+        # No need to implement beyond a tracing wrapper
+        def add_index(table_name, column_name, options = {})
+          @logger.unknown("ODBCAdapter#add_index>") if @@trace
+          @logger.unknown("args=[#{table_name}|#{column_name}]") if @@trace
+          super(table_name, column_name, options)																
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        #--
+        # Ensures index names constructed from the table name and a column
+        # name do not exceed the maximum index name length supported by the
+        # DBMS. It's assumed SQL_MAX_IDENTIFIER_LENGTH reflects the maximum
+        # index name length.
+        def index_name(table_name, options) # :nodoc:
+          @logger.unknown("ODBCAdapter#index_name>") if @@trace
+          @logger.unknown("args=[#{table_name}]") if @@trace
+          maxIndxNameLen = @dsInfo.info[ODBC::SQL_MAX_IDENTIFIER_LEN]
+          if Hash === options # legacy support
+            if options[:name]
+              return options[:name] # error if name length > max index length
+            elsif options[:column]
+              col_name = options[:column]
+            else
+              raise ArgumentError, "You must specify the index name"
+            end
+          else
+            col_name = options
+          end
+          idx_name = "#{table_name}_#{col_name}_index"
+          if idx_name.length > maxIndxNameLen
+            cMax = ((maxIndxNameLen - 5)/2).to_i
+            idx_name = "#{table_name.to_s[0,cMax]}_#{col_name.to_s[0,cMax]}_idx"
+          end
+          idx_name          
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        def type_to_sql(type, limit = nil) # :nodoc:
+          @logger.unknown("ODBCAdapter#type_to_sql>") if @@trace
+          @logger.unknown("args=[#{type}|#{limit}]") if @@trace
+          native = native_database_types[type]
+          column_type_sql = String.new(type == :primary_key ? native : native[:name])
+          # if there's no limit in the type definition, assume that the type 
+          # doesn't support a length qualifier
+          column_type_sql << "(#{limit || native[:limit]})" if native[:limit]
+          column_type_sql        																											
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # No need to implement beyond tracing wrapper
+        def add_column_options!(sql, options) # :nodoc:
+          @logger.unknown("ODBCAdapter#add_column_options!>") if @@trace
+          @logger.unknown("args=[#{sql}]") if @@trace
+          super(sql, options)																												
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise StatementInvalid, e.message
+        end
+        
+        # No need to implement beyond tracing wrapper
+        def dump_schema_information # :nodoc:
+          @logger.unknown("ODBCAdapter#dump_schema_information>") if @@trace
+          super																												
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @@trace
+          raise ActiveRecordError, e.message
+        end
+        
+        # ==================================================================
+        
+        private
+        
+        # Maps a DBMS name to a symbol.
+        #
+        # Different ODBC drivers might return different names for the same
+        # DBMS. So #dbmsNameToSym maps similar names to the same symbol.
+        #
+        # If adding an odbcext_xxx extension module for a particular DBMS,
+        # you should define a symbol here for the target DBMS.
+        #
+        # dbmsName is the SQL_DBMS_NAME returned by ODBC, downcased with
+        # whitespace removed.
+        def dbmsNameToSym(dbmsName, dbmsVer)
+          if dbmsName =~ /db2/i
+            symbl = :db2
+          elsif dbmsName =~ /informix/i
+            symbl = :informix
+          elsif dbmsName =~ /ingres/i
+            symbl = :ingres
+          elsif dbmsName =~ /my.*sql/i
+            symbl = :mysql
+          elsif dbmsName =~ /oracle/i
+            symbl = :oracle 
+          elsif dbmsName =~ /postgres/i
+            symbl = :postgresql
+          elsif dbmsName =~ /progress/i
+            # ODBC connections to Progress >= v9 are assumed to be to
+            # the SQL-92 engine. Connections to Progress <= v8 are
+            # assumed to be to the SQL-89 engine.
+            symbl = dbmsVer <= 8 ? :progress89 : :progress
+          elsif dbmsName =~ /sql.*server/i
+            symbl = :microsoftsqlserver
+          elsif dbmsName =~ /sybase/i
+            symbl = :sybase
+          elsif dbmsName =~ /virtuoso/i
+            symbl = :virtuoso 
+          else
+            raise ActiveRecord::ActiveRecordError, "ODBCAdapter: Unsupported database (#{dbmsName})"
+          end
+          symbl
+        end
+        
+        # Returns a Hash of mappings for each ActiveRecord abstract data type to 
+        # one or more ODBC SQL types
+        #
+        # Where more than one ODBC SQL type is associated with an abstract type,
+        # the SQL types in the value array are in order of preference.
+        def genericTypeToOdbcSqlTypesMap
+          map = 
+          {
+            :primary_key => [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+            :string => [ODBC::SQL_VARCHAR],
+            :text => [ODBC::SQL_LONGVARCHAR, ODBC::SQL_VARCHAR],
+            :integer => [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+            :float => [ODBC::SQL_DOUBLE, ODBC::SQL_REAL],
+            :datetime => [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+            :timestamp => [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+            :time => [ODBC::SQL_TYPE_TIME, ODBC::SQL_TIME, 
+            ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+            :date => [ODBC::SQL_TYPE_DATE, ODBC::SQL_DATE,
+            ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+            :binary => [ ODBC::SQL_LONGVARBINARY, ODBC::SQL_VARBINARY],          
+            :boolean => [ODBC::SQL_BIT, ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT,
+            ODBC::SQL_INTEGER]         
+          }
+          
+          # MySQL:                       
+          # Mapping of :boolean to ODBC::SQL_BIT is removed because it does not
+          # work with the BIT datatype in MySQL 5.0.3 or later.
+          # - Prior to MySQL 5.0.3: BIT was a synonym for TINYINT(1).
+          # - MySQL 5.0.3: BIT datatype is supported only for MyISAM tables,
+          #   not InnoDB tables (which ActiveRecord requires for transaction 
+          #   support).
+          # - Ruby ODBC Bridge attempts to fetch SQL_BIT column to SQL_C_LONG.
+          #   With MySQL ODBC driver (3.51.12)
+          #   - 'select b from ...' returns 0 for a bit value of 0x1
+          #   - 'select hex(b) from ...' returns 1 for a bit value of 0x1                    
+          if @dbmsName == :mysql  
+            map[:boolean].delete(ODBC::SQL_BIT) { raise ActiveRecordError, "SQL_BIT not found" }
+          end
+          
+          map
+        end
+        
+        # Creates a Hash describing a mapping from an abstract type to a
+        # DBMS native type for use by #native_database_types
+        #
+        # rNativeTypeDescs = array of rows from SQLGetTypeInfo result set
+        #                   all mapping to the same ODBC SQL type
+        def nativeTypeMapping (abstractType, rNativeTypeDescs)
+          res = {}
+          if abstractType == :primary_key
+            # The appropriate SQL for :primary_key is hard to derive as
+            # ODBC doesn't provide any info on a DBMS's native syntax for
+            # autoincrement columns. So we use a lookup instead.
+            val = @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :primary_key)
+            res = val 
+          else
+            nativeTypeDesc = rNativeTypeDescs[0]
+            # If more than one native type corresponds to the SQL type we're
+            # handling, the type in the first descriptor should be the
+            # best match, because the ODBC specification states that
+            # SQLGetTypeInfo returns the results ordered by SQL type and then by 
+            # how closely the native type maps to that SQL type.
+            # But, for :text and :binary, select the native type with the
+            # largest capacity.
+            if [:text, :binary].include?(abstractType)
+              rNativeTypeDescs.each do |ntd|
+                # Compare SQLGetTypeInfo:COLUMN_SIZE values
+                nativeTypeDesc = ntd if nativeTypeDesc[2] < ntd[2]
+              end
+            end
+            
+            res[:name] = nativeTypeDesc[0] # SQLGetTypeInfo: TYPE_NAME
+            createParams = nativeTypeDesc[5]
+            # CREATE_PARAMS is assumed to be a max_length specification.
+            # The abstract types don't map to SQL_DECIMAL, SQL_NUMERIC or
+            # SQL_FLOAT (#see genericTypeToOdbcSqlTypesMap), so we needn't worry
+            # about these SQL types which take a precision and maybe a scale
+            # creation parameter.
+            if (createParams && createParams.strip.length > 0)
+              unless @dbmsName == :db2 && ["BLOB", "CLOB"].include?(res[:name])
+                # HACK: 
+                # Omit the :limit option for DB2's CLOB and BLOB types, as the
+                # :limit value set from SQLGetTypeInfo(COL_SIZE) is 2GB.
+                # The max. length for these types defaults to 1MB if the
+                # length specifier is omitted.
+                res[:limit] = nativeTypeDesc[2] # SQLGetTypeInfo: COL_SIZE
+              end
+              
+              # The max row length in Ingres is typically around 2008 bytes,
+              # depending on the default page size.
+              # Limit the reported max length of the native type which maps to
+              # :string to 255, instead of the actual max length of 2000.
+              # This is done to reduce the chances of add_column() exceeding 
+              # the maximum row length and Ingres returning an error.
+              # 
+              # Similarly with DB2. The max row length is typically around 4005
+              # bytes.
+              # 
+              # Similarly with Sybase, reduce the max. :string length from 2000
+              # to 255, to avoid add_index exceeding the max. allowed index size
+              # of 1250 bytes when creating a composite index.
+              res[:limit] = 255 if [:ingres, :sybase, :db2, :progress, :progress89].include?(@dbmsName) && abstractType == :string
+            end					
+          end
+          res
+        end
+        
+        def last_insert_id(table, sequence_name, stmt = nil)
+          # This method must be overridden in module ODBCExt.
+          # Each DBMS supported by this ODBCAdapter supplies its own version in 
+          # file vendor/odbcext_#{dbmsName}.rb        
+          raise NotImplementedError, "last_insert_id is an abstract method"
+        end
+        
+        # Converts a result set value from an ODBC type to an ActiveRecord
+        # generic type.
+        def convertOdbcValToGenericVal(value)
+          # When fetching a result set, the Ruby ODBC driver converts all ODBC 
+          # SQL types to an equivalent Ruby type; with the exception of
+          # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
+          #
+          # The conversions below are consistent with the mappings in
+          # ODBCColumn#mapOdbcSqlTypeToGenericType and Column#klass.
+          res = value
+          case value
+          when ODBC::TimeStamp
+            res = Time.gm(value.year, value.month, value.day, value.hour, 
+                          value.minute, value.second)
+          when ODBC::Time
+            now = DateTime.now
+            res = Time.gm(now.year, now.month, now.day, value.hour, 
+                          value.minute, value.second)
+          when ODBC::Date
+            res = Date.new(value.year, value.month, value.day)
+          end
+          res
+        end
+        
+        # In general, ActiveRecord uses lowercase attribute names. This may
+        # conflict with the database's data dictionary case.
+        #
+        # The ODBCAdapter uses the following conventions for databases 
+        # which report SQL_IDENTIFIER_CASE = SQL_IC_UPPER:
+        # * if a name is returned from the DBMS in all uppercase, convert it
+        #   to lowercase before returning it to ActiveRecord.
+        # * if a name is returned from the DBMS in lowercase or mixed case, 
+        #   assume the underlying schema object's name was quoted when 
+        #   the schema object was created. Leave the name untouched before 
+        #   returning it to ActiveRecord.
+        # * before making an ODBC catalog call, if a supplied identifier is all
+        #   lowercase, convert it to uppercase. Leave mixed case or all 
+        #   uppercase identifiers unchanged.
+        # * columns created with quoted lowercase names are not supported. 
+        
+        # Converts an identifier to the case conventions used by the DBMS.
+        def dbmsIdentCase(identifier)
+          # Assume received identifier is in ActiveRecord case.
+          case @dsInfo.info[ODBC::SQL_IDENTIFIER_CASE]
+          when ODBC::SQL_IC_UPPER
+            identifier =~ /[A-Z]/ ? identifier : identifier.upcase
+          else
+            identifier
+          end
+        end
+        
+        # Converts an identifier to the case conventions used by ActiveRecord.
+        def activeRecIdentCase(identifier)
+          # Assume received identifier is in DBMS's data dictionary case.        
+          case @dsInfo.info[ODBC::SQL_IDENTIFIER_CASE]
+          when ODBC::SQL_IC_UPPER
+            identifier =~ /[a-z]/ ? identifier : identifier.downcase
+          else
+            identifier
+          end
+        end
+        
+        # Gets ODBCColumn descriptor for specified column
+        def getODBCColumnDesc(table_name, column_name)
+          col = nil
+          columns(table_name, column_name).each do |colDesc|
+            if colDesc.name == column_name
+              col = colDesc
+              break
+            end
+          end
+          col
+        end
+        
+        # Gets and caches SQLGetTypeInfo result set
+        def getDbTypeInfo
+          return @typeInfo if @typeInfo
+          
+          begin
+            stmt = @connection.types
+            @typeInfo = stmt.fetch_all
+          rescue Exception => e
+            @logger.unknown("exception=#{e}") if @@trace
+            raise ActiveRecordError, e.message
+          ensure
+            stmt.drop unless stmt.nil?
+          end
+          @typeInfo
+        end
+        
+        # Simulating sequences
+        def create_sequence(name, start_val = 1) end
+        def drop_sequence(name) end
+        def next_sequence_value(name) end
+        def ensure_sequences_table() end
+        
+      end # class ODBCAdapter
+      
+      #---------------------------------------------------------------------
+      
+      class ODBCColumn < Column #:nodoc:
+        
+        def initialize (name, tableName, default, odbcSqlType, nativeType, 
+                        null = true, limit = nil, dbExt = nil, typeInfo = nil)
+          
+          begin
+            require "#{dbExt}"
+            self.extend ODBCColumnExt
+          rescue MissingSourceFile
+            # Assume the current DBMS doesn't require extensions to ODBCColumn
+          end
+          
+          @name, @null = name, null
+          
+          # Only set @limit if native type takes a creation parameter
+          nativeTypeTakesCreateParams = false
+          if typeInfo
+            typeInfo.each do |row|
+              dbmsType = row[0] #SQLGetTypeInfo: TYPE_NAME
+              if dbmsType.casecmp(nativeType) == 0
+                createParams = row[5]
+                nativeTypeTakesCreateParams = (createParams && createParams.strip.length > 0)
+                break;
+              end
+            end        
+          end
+          @limit = nativeTypeTakesCreateParams ? limit : nil
+          
+          # nativeType is DBMS type used for column definition
+          # sql_type assigned here excludes any length specification
+          @sql_type = @nativeType = String.new(nativeType)
+          @type = mapOdbcSqlTypeToGenericType(odbcSqlType)
+          # type_cast uses #type so @type must be set first
+          
+          # The MS SQL Native Client ODBC driver wraps defaults in parentheses 
+          # (contrary to the ODBC spec). 
+          # e.g. '(1)' instead of '1', '(null)' instead of 'null'
+          if default =~ /^\((.+)\)$/ then default = $1 end
+          
+          if self.respond_to?(:default_preprocess, true)
+            default_preprocess(nativeType, default)
+          end
+          
+          @default = type_cast(default)
+          @table = tableName
+          @text = [:string, :text].include? @type
+          @number = [:float, :integer].include? @type
+          @primary = nil
+          @autounique = self.respond_to?(:autoUnique?, true) ? autoUnique? : false
+        end
+        
+        # Casts a value to the Ruby class corresponding to the ActiveRecord 
+        # abstract type associated with the column.
+        #
+        # See Column#klass for the Ruby class corresponding to each 
+        # ActiveRecord abstract type.
+        #
+        # This method is not just called by the ODBCColumn constructor, so
+        # value may be something other than a String.
+        #
+        # When casting a column's default value:
+        #   nil => no default value specified
+        #   "'<value>'" => string default value
+        #   "NULL" => default value of NULL
+        #   "TRUNCATED" => default value can't be represented without truncation
+        #
+        # Microsoft's SQL Native Client ODBC driver may return '(null)'
+        # as a column default, instead of NULL, contrary to the ODBC spec'
+        # It also wraps other default values in parentheses.
+        def type_cast(value)
+          return nil if value.nil? || value =~ 
+						/(^\s*[(]*\s*null\s*[)]*\s*$)|(^\s*truncated\s*$)/i
+          case type
+          when :string then value.to_s
+          when :text then value.to_s
+          when :integer then value.to_i
+          when :float then value.to_f
+          when :boolean then self.class.value_to_boolean(value)
+          when :binary then value.to_s
+          when :datetime then self.class.value_to_time(value)
+          when :timestamp then self.class.value_to_time(value)        
+          when :time then self.class.value_to_time(value)
+          when :date then self.class.value_to_date(value)
+          else
+            raise  ActiveRecordError, "Unknown ActiveRecord abstract type"
+          end
+        end
+        
+        def self.value_to_time(value)
+          # If we received a time literal without a date component, pad the 
+          # resulting array with dummy date information.
+          #
+          # See Column#string_to_dummy_time and 
+          # BasicsTest#test_attributes_on_dummy_time. Both assume the dummy 
+          # date component will be 2000-01-01.
+          if value.is_a?(Time)
+            if value.year != 0 and value.month != 0 and value.day != 0
+              return value
+            else
+              return Time.mktime(2000, 1, 1, value.hour, value.min, value.sec) rescue nil
+            end
+          elsif value.is_a?(String)
+            time = ParseDate.parsedate(value)
+            if time[0].nil? && time[1].nil? && time[2].nil?
+              time[0] = 2000; time[1] = 1; time[2] = 1;
+            end
+            Time.send(Base.default_timezone, *time) rescue nil
+          else
+            raise  ActiveRecordError, "Unexpected type (#{value.class})"
+          end
+        end
+        
+        def self.value_to_date(value)
+          if value.is_a?(Date)
+            return value
+          elsif value.is_a?(String)
+            begin
+              date = ParseDate.parsedate(value)
+              Date.new(date[0], date[1], date[2])        
+            rescue
+              raise ActiveRecordError, "Cannot convert supplied String value to Date (#{value})"
+            end
+          elsif value.is_a?(Time)
+            begin
+              Date.new(value.year, value.month, value.day)
+            rescue
+              raise ActiveRecordError, "Cannot convert supplied Time value to Date (#{value})"
+            end
+          else
+            raise  ActiveRecordError, "Unexpected type (#{value.class})"
+          end
+        end
+        
+        private
+        
+        # Maps an ODBC SQL type to an ActiveRecord abstract data type
+        #
+        # c.f. Mappings in ConnectionAdapters::Column#simplified_type based on
+        # native column type declaration
+        #
+        # See also:
+        # Column#klass (schema_definitions.rb) for the Ruby class corresponding
+        # to each abstract data type.
+        def mapOdbcSqlTypeToGenericType (odbcSqlType)
+          case odbcSqlType
+          when ODBC::SQL_BIT then :boolean
+            
+          when ODBC::SQL_CHAR, ODBC::SQL_VARCHAR then :string
+          when ODBC::SQL_LONGVARCHAR then :text
+
+          when ODBC::SQL_WCHAR, ODBC::SQL_WVARCHAR then :string
+          when ODBC::SQL_WLONGVARCHAR then :text
+            
+          when ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT, ODBC::SQL_INTEGER, 
+            ODBC::SQL_BIGINT then :integer
+            
+          when ODBC::SQL_REAL, ODBC::SQL_FLOAT, ODBC::SQL_DOUBLE then :float
+            
+          when ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC then :float 
+            # SQL_DECIMAL & SQL_NUMERIC are both exact types.
+            # Possible loss of precision if retrieved to :float
+            
+          when ODBC::SQL_BINARY, ODBC::SQL_VARBINARY, 
+            ODBC::SQL_LONGVARBINARY then :binary
+            
+            # SQL_DATETIME is an alias for SQL_DATE in ODBC's sql.h & sqlext.h
+          when ODBC::SQL_DATE, ODBC::SQL_TYPE_DATE, 
+            ODBC::SQL_DATETIME then :date
+          when ODBC::SQL_TIME, ODBC::SQL_TYPE_TIME then :time
+          when ODBC::SQL_TIMESTAMP, ODBC::SQL_TYPE_TIMESTAMP then :timestamp
+            
+          when ODBC::SQL_GUID then :string					
+            
+          else
+            # when SQL_UNKNOWN_TYPE
+            # (ruby-odbc driver doesn't support following ODBC SQL types:
+            #  SQL_WCHAR, SQL_WVARCHAR, SQL_WLONGVARCHAR, SQL_INTERVAL_xxx)
+            msg = "Unsupported ODBC SQL type [" << odbcSqlType.to_s << "]"
+            raise ActiveRecordError, msg
+          end
+        end
+        
+      end # class ODBCColumn
+      
+    end # module ConnectionAdapters
+  end # module ActiveRecord
+  
+  #-------------------------------------------------------------------------
+rescue LoadError
+  module ActiveRecord # :nodoc:
+    class Base
+      def self.odbc_connection(config) # :nodoc:
+        raise LoadError, "The Ruby ODBC module could not be loaded."
+      end
+    end
+  end
+end