odbc-rails 1.3 → 1.4

data/ChangeLog

@@ -1,3 +1,21 @@
+2007-02-27 15:28  source
+
+	* Set version 1.4 for final release
+
+2007-02-27 12:53  source
+
+	* Small rdoc fix
+
+2007-02-27 11:05  source
+
+	* Added small diff for rake unit testing
+
+2007-02-27 11:00  source
+
+	* Changes for Rails 1.2.x / ActiveRecord 1.15.x
+	* Added support for :decimal type
+	* Added :emulate_booleans connection option
+
 2007-01-09 10:18  source
 
 	* Updated version number to 1.3

data/NEWS

@@ -1,3 +1,8 @@
+February 27, 2007, V1.4:
+  * Changes for Rails 1.2.x / ActiveRecord 1.15.x
+  * Added support for :decimal type
+  * Added :emulate_booleans connection option
+
 January 9, 2007, V1.3:
   * Added support for PostgreSQL
 

data/README

@@ -2,11 +2,21 @@
 
 (C) 2006 OpenLink Software
 
-09-Jan-2007
-
 
 == Status
 
+23-Feb-2007
+
+The adapter has been updated to support Rails 1.2.x / ActiveRecord 1.15.x.
+The new adapter (v1.4) is not recommended for use with Rails 1.1 / ActiveRecord
+1.14.x. Please use v1.3 of the adapter with Rails 1.1.
+
+The driver now supports the new ActiveRecord :decimal type and an
+:emulate_booleans connection option. See http://odbc-rails.rubyforge.org for
+more information about this option.
+
+09-Jan-2007
+
 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].
 
@@ -18,7 +28,7 @@ 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, Progress v8/9/10 and PostgreSQL 8.2.
+SQL Server 2000/2005, Sybase ASE 15, DB2 v9, Progress v8/9/10 and PostgreSQL 8.2.
 
 Testing to date has been limited to the ROR 'Expenses' sample
 application described at http://developer.apple.com/tools/rubyonrails.html
@@ -71,18 +81,21 @@ 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
+Only one of the patches is really necessary. In adapter release 1.3 or
+earlier, the diff file includes a patch to:
 
     lib/active_record/connection_adapters/abstract/schema_definitions.rb
 
-This fixes what appears to be a bug in Active Record.
+This fixes what appears to be a bug in Active Record 1.14. The patch
+is unnecessary for AR 1.15 and consequently not included in adapter
+release 1.4
 
 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.
+databases. The patched versions of files touched by odbc_rails.diff can
+be found in support/lib and support/test.
 
 == Installation
 

data/lib/active_record/connection_adapters/odbc_adapter.rb

@@ -1,5 +1,5 @@
 #
-#  $Id: odbc_adapter.rb,v 1.3 2007/01/09 10:11:40 source Exp $
+#  $Id: odbc_adapter.rb,v 1.5 2007/02/27 12:53:51 source Exp $
 #
 #  OpenLink ODBC Adapter for Ruby on Rails
 #  Copyright (C) 2006 OpenLink Software
@@ -41,12 +41,16 @@ begin
         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
+        trace = config[:trace].nil? ? false : config[:trace]
+        conv_num_lits = config[:convert_numeric_literals].nil? ? false : config[:convert_numeric_literals]
+        emulate_bools = config[:emulate_booleans].nil? ? false : config[:emulate_booleans]
+        
         conn = ODBC::connect(dsn, username, password)      
         conn.autocommit = true
-        ConnectionAdapters::ODBCAdapter.new(conn, [dsn, username, password],
-                                            trace, conv_num_lits, logger)
+        
+        ConnectionAdapters::ODBCAdapter.new(conn, {:dsn => dsn, :username => username, 
+        :password => password, :trace => trace, :conv_num_lits => conv_num_lits, 
+        :emulate_booleans => emulate_bools}, logger)
       end
     end # class Base
     
@@ -57,7 +61,15 @@ begin
       # 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 09-Jan-2007
+      # == Status
+      #
+      # === 27-Feb-2007
+      #
+      # Adapter updated to support Rails 1.2.x / ActiveRecord 1.15.x.
+      # Support added for AR :decimal type and :emulate_booleans connection
+      # option introduced.
+      #
+      # === 09-Jan-2007
       #
       # The current adapter supports Ingres r3, Informix 9.3 or later, 
       # Virtuoso (Open-Source Edition) 4.5, Oracle 10g, MySQL 5, 
@@ -109,6 +121,11 @@ begin
       #   If set to <tt>true</tt>, suppresses quoting of numeric literals.
       #   If omitted, <tt>:convert_numeric_literals</tt> defaults to 
       #   <tt>false</tt>.
+      # <tt>:emulate_booleans</tt>::
+      #   Instructs the adapter to interpret certain numeric column types as
+      #   holding boolean, rather than numeric, data. It is intended for use 
+      #   with databases which do not have a native boolean data type. 
+      #   If omitted, <tt>:emulate_booleans</tt> defaults to <tt>false</tt>.
       #   
       # == Usage Notes
       # === Informix
@@ -187,115 +204,144 @@ begin
             # 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",
+                :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
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "DECIMAL(1)"
               }
             },
             :informix => {
               :any_version => {
-                :primary_key => "serial primary key",
+                :primary_key => "SERIAL PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                # This data adapter automatically maps ODBC::SQL_BIT to 
+                # :boolean. So, the following is unnecessary if the ODBC
+                # driver maps the native BOOLEAN type available in 
+                # Informix 9.x to ODBC::SQL_BIT in SQLGetTypeInfo.
+                :boolean_col_surrogate => "SMALLINT"
               }
             },
             :ingres => {
               :any_version => {
-                :primary_key => "integer primary key not null",
+                :primary_key => "INTEGER PRIMARY KEY NOT NULL",
                 :has_autoincrement_col => false,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "INTEGER1"
               }
             },
-            :mysql => {
+            :microsoftsqlserver => {
               :any_version => {
-                :primary_key => "int(11) not null auto_increment primary key",
+                :primary_key => "INT NOT NULL IDENTITY(1, 1) PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
-                :supports_schema_names => false,
-                :supports_count_distinct => true
+                :supports_schema_names => true,
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # SQL Server's BIT data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil
               },
-              5 => {
-                :primary_key => "int(11) not null auto_increment primary key",
+              8 => {
+                :primary_key => "INT NOT NULL IDENTITY(1, 1) PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
-                :supports_schema_names => false,
-                :supports_count_distinct => true
+                :supports_schema_names => true,
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # SQL Server's BIT data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil
               }
             },
-            :microsoftsqlserver => {
+            :mysql => {
               :any_version => {
-                :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+                :primary_key => "INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
-                :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_schema_names => false,
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "TINYINT"                                
               },
-              8 => {
-                :primary_key => "int NOT NULL IDENTITY(1, 1) PRIMARY KEY",
+              5 => {
+                :primary_key => "INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
-                :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_schema_names => false,
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "TINYINT"
               }
             },
             :oracle => {
               :any_version => {
-                :primary_key => "number(10) PRIMARY KEY NOT NULL",
+                :primary_key => "NUMBER(10) PRIMARY KEY NOT NULL",
                 :has_autoincrement_col => false,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "NUMBER(1)"
               }
             },
             :postgresql => {
               :any_version => {
-                :primary_key => "serial primary key",
+                :primary_key => "SERIAL PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
                 :supports_schema_names => false,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # PostgreSQL's BOOL data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil                
               }
             },
             :progress => {
               :any_version => {
-                :primary_key => "integer not null primary key",
+                :primary_key => "INTEGER NOT NULL PRIMARY KEY",
                 :has_autoincrement_col => false,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # Progress SQL-92's BIT data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil
               }
             },
             :progress89 => {
               :any_version => {
-                :primary_key => "integer not null unique",
+                :primary_key => "INTEGER NOT NULL UNIQUE",
                 :has_autoincrement_col => false,
                 :supports_migrations => true,
                 :supports_schema_names => false,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # Progress SQL-89's LOGICAL data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil                
               }
             },
             :sybase => {
               :any_version => {
-                :primary_key => "int IDENTITY PRIMARY KEY",
+                :primary_key => "INT IDENTITY PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                # boolean_col_surrogate not necessary. 
+                # Sybase's BIT data type is mapped to ODBC::SQL_BIT/:boolean.
+                :boolean_col_surrogate => nil                                
               }
             },
             :virtuoso => {
               :any_version => {
-                :primary_key => "int NOT NULL IDENTITY PRIMARY KEY",
+                :primary_key => "INT NOT NULL IDENTITY PRIMARY KEY",
                 :has_autoincrement_col => true,
                 :supports_migrations => true,
                 :supports_schema_names => true,
-                :supports_count_distinct => true
+                :supports_count_distinct => true,
+                :boolean_col_surrogate => "SMALLINT"
               }
             }
           }
@@ -333,7 +379,8 @@ begin
           ODBC::SQL_IDENTIFIER_QUOTE_CHAR,
           ODBC::SQL_MAX_IDENTIFIER_LEN,		
           ODBC::SQL_MAX_TABLE_NAME_LEN,
-          ODBC::SQL_USER_NAME
+          ODBC::SQL_USER_NAME,
+          ODBC::SQL_DATABASE_NAME
           ]
           
           def initialize(connection)
@@ -376,9 +423,12 @@ begin
         # 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.      
+        # <tt>microsoftsqlserver</tt> etc.              
         attr_reader :dbmsName
         
+        # Emulate boolean columns if the database doesn't have a native BOOLEAN type.
+        attr_reader :emulate_booleans
+        
         # Supports lookups of DBMS-dependent information/settings which
         # cannot be derived satisfactorily through ODBC
         @@dbmsLookups = DbmsInfo.create
@@ -386,8 +436,8 @@ begin
         @@trace = nil
         #--
         
-        def initialize(connection, connection_options, trace, convert_numeric_literals, logger = nil)
-          @@trace = trace && logger if !@@trace
+        def initialize(connection, connection_options, logger = nil)
+          @@trace = connection_options[: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".)
@@ -399,7 +449,9 @@ begin
           @logger.unknown("ODBCAdapter#initialize>") if @@trace
           
           @connection, @connection_options = connection, connection_options
-          @convert_numeric_literals = convert_numeric_literals
+          @convert_numeric_literals = connection_options[:conv_num_lits]
+          @emulate_booleans = connection_options[:emulate_booleans]
+          
           # Caches SQLGetInfo output
           @dsInfo = DSInfo.new(connection)
           # Caches SQLGetTypeInfo output
@@ -437,7 +489,7 @@ begin
         # Returns the human-readable name of the adapter.
         def adapter_name
           @logger.unknown("ODBCAdapter#adapter_name>") if @@trace
-        'ODBC'
+          'ODBC'
         end
         
         # Does this adapter support migrations?
@@ -505,11 +557,14 @@ begin
           @logger.unknown("ODBCAdapter#quote>") if @@trace
           @logger.unknown("args=[#{value}]") if @@trace
           case value
-          when String
+          when String, ActiveSupport::Multibyte::Chars          
+            value = value.to_s
             if column && column.type == :binary && self.respond_to?(:string_to_binary)
               "'#{string_to_binary(value)}'"
-            elsif (column && [:integer, :float].include?(column.type)) ||
-             (column.nil? && @convert_numeric_literals && 
+            elsif (column && [:integer, :float].include?(column.type))
+              value = column.type == :integer ? value.to_i : value.to_f
+              value.to_s            
+            elsif (column.nil? && @convert_numeric_literals && 
              (value =~ /^[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?$/))
               value
             else
@@ -564,12 +619,12 @@ begin
         
         def quoted_true
           @logger.unknown("ODBCAdapter#quoted_true>") if @@trace
-				'1'
+		  '1'
         end
         
         def quoted_false
           @logger.unknown("ODBCAdapter#quoted_false>") if @@trace
-				'0'
+		  '0'
         end
         
         def quoted_date(value)
@@ -580,10 +635,10 @@ begin
           case value
           when Time, DateTime
             #%Q!{ts #{value.strftime("%Y-%m-%d %H:%M:%S")}}!
-          %Q!'#{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")}'!
+            %Q!'#{value.strftime("%Y-%m-%d")}'!
           end
         end
         
@@ -876,7 +931,7 @@ begin
         def default_sequence_name(table, column)
           @logger.unknown("ODBCAdapter#default_sequence_name>") if @@trace
           @logger.unknown("args=[#{table}|#{column}]") if @@trace
-        "#{table}_seq"
+          "#{table}_seq"
         end
         
         # Set the sequence to the max value of the table�s column.
@@ -894,18 +949,41 @@ begin
         #
         # see: abstract/schema_statements.rb
         
-        # Implemented by MySQL and SQL Server adapters
-        #def create_database(name)
-        #end
+        def create_database(name)
+          @logger.unknown("ODBCAdapter#create_database>") if @trace
+          @logger.unknown("args=[#{name}]") if @trace            
+          raise NotImplementedError, "create_database is not implemented"
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @trace
+          raise
+        end
         
-        # Implemented by MySQL, SQL Server and Oracle adapters
-        #def current_database
-        #end
+        def drop_database(name)
+          @logger.unknown("ODBCAdapter#drop_database>") if @trace
+          @logger.unknown("args=[#{name}]") if @trace            
+          raise NotImplementedError, "drop_database is not implemented"
+        rescue Exception => e
+          @logger.unknown("exception=#{e}") if @trace
+          raise
+        end
         
-        # Implemented by MySQL and SQL Server adapters
-        #drop_database(name)
-        #end
+        #--
+        # Required by db:test:purge Rake task (see databases.rake)
+        def recreate_database(name, fail_quietly = false)
+          @logger.unknown("ODBCAdapter#recreate_database>") if @@trace
+          @logger.unknown("args=[#{name}|#{fail_quietly}]") if @@trace
+          begin
+            drop_database(name)
+            create_database(name)
+          rescue Exception => e
+            raise unless fail_quietly
+          end
+        end
         
+        def current_database
+          @dsInfo.info[ODBC::SQL_DATABASE_NAME].strip
+        end
+
         # The maximum length a table alias can be.
         def table_alias_length
           maxIdentLen = @dsInfo.info[ODBC::SQL_MAX_IDENTIFIER_LEN]
@@ -950,6 +1028,13 @@ begin
           table_name = table_name.to_s if table_name.class == Symbol
           
           getDbTypeInfo
+          begin
+            booleanColSurrogate = @emulate_booleans ? @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :boolean_col_surrogate) : nil
+          rescue Exception
+            # No boolean column surrogate defined for target database in lookup table
+            booleanColSurrogate = nil
+            @emulate_booleans = false
+          end  
           cols = []
           stmt = @connection.columns(dbmsIdentCase(table_name))
           resultSet = stmt.fetch_all || []
@@ -959,6 +1044,7 @@ begin
             colSqlType = col[4] # SQLColumns: DATA_TYPE
             colNativeType = col[5] # SQLColumns: TYPE_NAME
             colLimit = col[6] # SQLColumns: COLUMN_SIZE
+            colScale = col[8] # SQLColumns: DECIMAL_DIGITS
             
             odbcIsNullable = col[17] # SQLColumns: IS_NULLABLE
             odbcNullable = col[10] # SQLColumns: NULLABLE
@@ -979,9 +1065,10 @@ begin
             elsif colDefault =~ /^\((.*)\)$/ # SQL Server numeric default
               colDefault = $1
               # ODBC drivers should return string column defaults in quotes
-              # - Oracle includes a trailing space.
+              # - strip off the quotes
+              # - Oracle may include a trailing space.
               # - PostgreSQL may return '<default>::character varying'
-            elsif colDefault =~ /^'(.*)'[ :].*$/
+            elsif colDefault =~ /^'(.*)'([ :].*)*$/
               colDefault = $1
 	        #TODO: HACKS for Progress
             elsif @dbmsName == :progress || @dbmsName == :progress89
@@ -995,7 +1082,7 @@ begin
             end
             cols << ODBCColumn.new(activeRecIdentCase(colName), table_name, 
             colDefault, colSqlType, colNativeType, colNullable, colLimit, 
-            @odbcExtFile+"_col", @typeInfo)
+            colScale, @odbcExtFile+"_col", booleanColSurrogate, native_database_types())
           end
           stmt.drop
           cols
@@ -1012,7 +1099,7 @@ begin
           indexes = []
           indexCols = indexName = isUnique = nil
           
-          stmt = @connection.indexes(dbmsIdentCase(table_name))
+          stmt = @connection.indexes(dbmsIdentCase(table_name.to_s))
           rs = stmt.fetch_all || []
           rs.each_index do |iRow|
             row = rs[iRow]
@@ -1064,6 +1151,7 @@ begin
             :string      => nil,
             :text        => nil,
             :integer     => nil,
+            :decimal     => nil,
             :float       => nil,
             :datetime    => nil,
             :timestamp   => nil,
@@ -1109,6 +1197,16 @@ begin
             end
             @logger.unknown("WARNING: No suitable DBMS type for abstract type #{abstractType.to_s}") if !isSupported && @@trace
           end
+
+          begin                    
+            booleanColSurrogate = @emulate_booleans ? @@dbmsLookups.get_info(@dbmsName, @dbmsMajorVer, :boolean_col_surrogate) : nil
+          rescue Exception
+            # No boolean column surrogate defined for target database in lookup table
+            booleanColSurrogate = nil
+            @emulate_booleans = false              
+          end
+          @abstract2NativeTypeMap[:boolean] = {:name => booleanColSurrogate} if booleanColSurrogate
+          
           {}.merge(@abstract2NativeTypeMap)
         rescue Exception => e
           @logger.unknown("exception=#{e}") if @@trace
@@ -1137,10 +1235,10 @@ begin
         end
         
         # Drops a table from the database.
-        def drop_table(name)
+        def drop_table(name, options = {})
           @logger.unknown("ODBCAdapter#drop_table>") if @@trace
           @logger.unknown("args=[#{name}]") if @@trace
-          super(name)
+          super(name, options)
         rescue Exception => e
           @logger.unknown("exception=#{e}") if @@trace
           raise ActiveRecordError, e.message
@@ -1252,8 +1350,8 @@ begin
           @logger.unknown("ODBCAdapter#transaction>") if @@trace
           super(start_db_transaction)
         rescue Exception => e
-          @logger.unknown("exception=#{e}") if @@trace
-          raise ActiveRecordError, e.message
+          @logger.unknown("#{e.class}: #{e}") if @@trace
+          raise
         end
         
         # Alias for #add_limit_offset!
@@ -1286,45 +1384,43 @@ begin
         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.
+        # If the index is not explicitly named using the :name option, 
+        # there's a risk the generated index name could exceed the maximum
+        # length supported by the database. 
+        # i.e. dsInfo.info[ODBC::SQL_MAX_IDENTIFIER_LEN]
         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          
+          super
         rescue Exception => e
           @logger.unknown("exception=#{e}") if @@trace
           raise ActiveRecordError, e.message
         end
         
-        def type_to_sql(type, limit = nil) # :nodoc:
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil) # :nodoc:
           @logger.unknown("ODBCAdapter#type_to_sql>") if @@trace
-          @logger.unknown("args=[#{type}|#{limit}]") if @@trace
+          @logger.unknown("args=[#{type}|#{limit}|#{precision}|#{scale}]") 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        																											
+          column_type_sql = String.new(native.is_a?(Hash) ? native[:name] : native)
+          if type == :decimal # ignore limit, use precision and scale
+            precision ||= native[:precision]
+            scale ||= native[:scale]
+            if precision
+              if scale
+                column_type_sql << "(#{precision},#{scale})"
+              else
+                column_type_sql << "(#{precision})"
+              end
+            else
+              raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified" if scale
+            end
+            column_type_sql          
+          else
+            # 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        																											
+          end
         rescue Exception => e
           @logger.unknown("exception=#{e}") if @@trace
           raise ActiveRecordError, e.message
@@ -1350,7 +1446,7 @@ begin
         end
         
         # ==================================================================
-        
+
         private
         
         # Maps a DBMS name to a symbol.
@@ -1405,6 +1501,7 @@ begin
             :string => [ODBC::SQL_VARCHAR],
             :text => [ODBC::SQL_LONGVARCHAR, ODBC::SQL_VARCHAR],
             :integer => [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+            :decimal => [ ODBC::SQL_NUMERIC, ODBC::SQL_DECIMAL],
             :float => [ODBC::SQL_DOUBLE, ODBC::SQL_REAL],
             :datetime => [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
             :timestamp => [ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
@@ -1466,12 +1563,10 @@ begin
             
             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)
+            # Depending on the column type, the CREATE_PARAMS keywords can
+            # include length, precision or scale.
+            if (createParams && createParams.strip.length > 0 &&
+                ![:decimal].include?(abstractType))
               unless @dbmsName == :db2 && ["BLOB", "CLOB"].include?(res[:name])
                 # HACK: 
                 # Omit the :limit option for DB2's CLOB and BLOB types, as the
@@ -1515,7 +1610,7 @@ begin
           # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
           #
           # The conversions below are consistent with the mappings in
-          # ODBCColumn#mapOdbcSqlTypeToGenericType and Column#klass.
+          # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
           res = value
           case value
           when ODBC::TimeStamp
@@ -1610,8 +1705,8 @@ begin
       class ODBCColumn < Column #:nodoc:
         
         def initialize (name, tableName, default, odbcSqlType, nativeType, 
-                        null = true, limit = nil, dbExt = nil, typeInfo = nil)
-          
+                        null = true, limit = nil, scale = nil, dbExt = nil, 
+                        booleanColSurrogate = nil, nativeTypes = nil)          
           begin
             require "#{dbExt}"
             self.extend ODBCColumnExt
@@ -1621,24 +1716,15 @@ begin
           
           @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
+          @precision = extract_precision(odbcSqlType, limit)
+          @scale = extract_scale(odbcSqlType, scale)          
+          @limit = limit
           
           # 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 = mapSqlTypeToGenericType(odbcSqlType, @nativeType, @scale, booleanColSurrogate, limit,
+                      nativeTypes)
           # type_cast uses #type so @type must be set first
           
           # The MS SQL Native Client ODBC driver wraps defaults in parentheses 
@@ -1652,21 +1738,17 @@ begin
           
           @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.
+        # Casts a value (which is a String) 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
@@ -1679,67 +1761,9 @@ begin
         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
+          super
         end
-        
+                
         private
         
         # Maps an ODBC SQL type to an ActiveRecord abstract data type
@@ -1750,36 +1774,39 @@ begin
         # See also:
         # Column#klass (schema_definitions.rb) for the Ruby class corresponding
         # to each abstract data type.
-        def mapOdbcSqlTypeToGenericType (odbcSqlType)
+        def mapSqlTypeToGenericType (odbcSqlType, nativeType, scale, 
+            booleanColSurrogate, rawPrecision, nativeTypes)
+          if booleanColSurrogate && booleanColSurrogate.upcase.index(nativeType.upcase)
+            fullType = nativeType.dup
+            if booleanColSurrogate =~ /\(\d+(,\d+)?\)/ && rawPrecision
+              fullType << "(#{rawPrecision}"
+              fullType << ",#{scale}" if $1 && scale
+              fullType << ")"
+            end
+            return :boolean if fullType.casecmp(booleanColSurrogate) == 0
+          end
+          
           case odbcSqlType
-          when ODBC::SQL_BIT then :boolean
-            
+          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_WLONGVARCHAR then :text            
           when ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT, ODBC::SQL_INTEGER, 
-            ODBC::SQL_BIGINT then :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
-            
+          # If SQLGetTypeInfo output of ODBC driver doesn't include a mapping 
+          # to a native type from SQL_DECIMAL/SQL_NUMERIC, map to :float
+          when ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC then scale.nil? || scale == 0 ? :integer : 
+            nativeTypes[:decimal].nil? ? :float : :decimal             
           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
+            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					
-            
+          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:
@@ -1788,6 +1815,22 @@ begin
             raise ActiveRecordError, msg
           end
         end
+
+        def extract_precision(odbcSqlType, odbcPrecision)
+          # Ignore the ODBC precision of SQL types which don't take
+          # an explicit precision when defining a column
+          case odbcSqlType
+            when ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC then odbcPrecision
+          end
+        end
+
+        def extract_scale(odbcSqlType, odbcScale)
+          # Ignore the ODBC scale of SQL types which don't take
+          # an explicit scale when defining a column
+          case odbcSqlType
+            when ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC then odbcScale ? odbcScale : 0
+          end
+        end
         
       end # class ODBCColumn