activerecord-mimer 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Fredrik Ålund <fredrik.alund@mimer.se>
+Copyright (c) 2006 Ola Bini <ola@ologix.com>
+
+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/README

@@ -0,0 +1,70 @@
+= ActiveRecord Mimer
+
+This project is basically an ActiveRecord connector for the Mimer SQL
+database. It uses ODBC to communicate with the database, and supports
+most regular operations and migrations.
+
+== Dependencies
+
+unixODBC 2.2.8 or later 
+ A good installation instruction can be found
+ at http://developer.mimer.com/howto/howto_57.htm 
+
+Ruby-ODBC
+ http://www.ch-werner.de/rubyodbc/
+
+== Using ActiveRecord Mimer
+
+=== Standalone, with ActiveRecord
+
+Using this adapter is very simple, but requires that you manually add the
+adapter. So, to use it in a script, add this to the requires':
+  RAILS_CONNECTION_ADAPTERS = ['mimer']
+  require 'active_record'
+
+After this you can establish a JDBC connection like this:
+
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'mimer',
+    :dsn => 'yourODBCdsn',
+    :username => 'username',
+    :password => 'pwd'
+  )
+
+If provided, password and username will be used. After the connection is established
+Active Record can be used as usual.
+
+=== Inside Rails
+
+Using the adapter inside Rails is slightly more complicated, since we
+don't have control over the load process. The easiest way to add
+Mimer support is to manually edit your environment.rb, and add this line:
+
+  require 'mimer_adapter'
+
+between
+
+  require File.join(File.dirname(__FILE__), 'boot')
+
+and 
+
+  Rails::Initializer.run do |config|
+
+The head of my environment.rb after these modifications look like this:
+
+  RAILS_GEM_VERSION = '1.1.6'
+
+  # Bootstrap the Rails environment, frameworks, and default configuration
+  require File.join(File.dirname(__FILE__), 'boot')
+
+  require 'mimer_adapter'
+
+  Rails::Initializer.run do |config|
+    # Settings in config/environments/* take precedence those specified here
+
+== Authors
+This project was written by:
+Fredrik Ålund and Ola Bini with some code from rails-odbc.
+
+== License
+ActiveRecord-Mimer is released under an MIT license.

data/lib/active_record/connection_adapters/mimer_adapter.rb

@@ -0,0 +1,783 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'active_record/connection_adapters/abstract_adapter'
+
+begin
+  require_library_or_gem 'odbc' unless self.class.const_defined?(:ODBC)
+
+  module ActiveRecord
+    class Base
+      # Establishes a connection to the database that's used by all Active Record objects
+      def self.mimer_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
+        conn = ODBC::connect(dsn, username, password)
+        conn.autocommit = true
+        ConnectionAdapters::MimerAdapter.new(conn, [dsn, username, password],logger)
+      end
+    end
+
+    module ConnectionAdapters
+      class MimerAdapter < AbstractAdapter
+        SQL_NO_NULLS = 0           # :nodoc:
+        SQL_NULLABLE = 1           # :nodoc:
+        SQL_NULLABLE_UNKNOWN = 2   # :nodoc:
+      
+        def initialize(connection, connection_options, logger = nil)
+          super(connection, logger)
+          @connection, @connection_options = connection, connection_options
+        end
+
+        def adapter_name; 'Mimer'; end
+
+        def supports_migrations?
+          true
+        end
+        
+        # Does the database support COUNT(DISTINCT) queries?
+        # e.g. <tt>select COUNT(DISTINCT ArtistID) from CDs</tt>
+        def supports_count_distinct?
+          true
+        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)
+          true
+        end
+        
+        def next_sequence_value(sequence_name)
+          select_one("select next_value of #{sequence_name} AS id from system.onerow")['id']
+        end
+
+        # Returns true if this connection active.
+        def active?
+          @connection.connected?
+        end
+        
+        # Reconnects to the database.
+        def reconnect!
+          @connection.disconnect if @connection.connected?
+          @connection = ODBC::connect(*@connection_options)
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        # Disconnects from the database.
+        def disconnect!
+          @connection.disconnect if @connection.connected?
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        def quote(value, column = nil)
+          case value
+          when String
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "#{column.class.string_to_binary(value)}"
+            elsif (column && [:integer, :float].include?(column.type)) ||
+             (column.nil? &&
+             (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
+            if column.type == :time
+              quoted_time(value)
+            else
+              quoted_date(value)
+            end
+          when DateTime
+              quoted_date(value)
+          else
+            super
+          end
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        # Quotes a string, escaping any ' (single quote) and \ (backslash)
+        # characters.
+        def quote_string(string)
+          string.gsub(/\'/, "''")
+        end
+        
+        # Returns a quoted form of the column name.
+        def quote_column_name(name)
+          name = name.to_s if name.class == Symbol
+          name
+        end
+        
+        def quoted_true
+          '1'
+        end
+        
+        def quoted_false
+          '0'
+        end
+        
+        def quoted_date(value)
+          # 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!TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'!
+          when Date
+            %Q!DATE '#{value.strftime("%Y-%m-%d")}'!
+          end
+        end
+        
+        def quoted_time(value)
+          %Q!TIME '#{value.strftime("%H:%M:%S")}'!
+        end
+
+        # Begins a transaction (and turns off auto-committing).
+        def begin_db_transaction
+          @connection.autocommit = false
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        # Commits the transaction (and turns on auto-committing).
+        def commit_db_transaction
+          @connection.commit
+          # ODBC chains transactions. Turn autocommit on after commit to
+          # allow explicit transaction initiation.
+          @connection.autocommit = true
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        # Rolls back the transaction (and turns on auto-committing). 
+        def rollback_db_transaction
+          @connection.rollback
+          # ODBC chains transactions. Turn autocommit on after rollback to
+          # allow explicit transaction initiation.
+          @connection.autocommit = true
+        rescue Exception => e
+          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)
+          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)
+          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.
+          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.
+          # Execute the query
+          begin
+            stmt = @connection.run(qry)
+          rescue Exception => e
+            stmt.drop unless stmt.nil?
+            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)
+          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.
+          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.
+          # Execute the query
+          begin
+            stmt = @connection.run(qry)
+          rescue Exception => e
+            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)
+          begin
+            @connection.do(sql)
+          rescue Exception => e
+            raise StatementInvalid, e.message
+          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)
+          # 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
+            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.
+        def default_sequence_name(table, primary_key=nil)
+          "#{table}_seq"
+        end
+        
+        # Set the sequence to the max value of the table's column.
+        def reset_sequence!(table, column, sequence = nil)
+          super(table, column, sequence)
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        def table_alias_length
+          maxIdentLen = @connection.get_info(ODBC::SQL_MAX_IDENTIFIER_LEN)
+          maxTblNameLen = @connection.get_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)
+          tblNames = []
+          currentUser = @connection.get_info(ODBC::SQL_USER_NAME)
+          stmt = @connection.tables
+          resultSet = stmt.fetch_all || []
+          resultSet.each do |row| 
+            tblNames << activeRecIdentCase(row[2]) if row[1].casecmp(currentUser) == 0
+          end
+          stmt.drop
+          tblNames
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+        
+        # Returns an array of Column objects for the table specified by +table_name+.
+        def columns(table_name, name = nil)
+          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)
+            
+            # 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
+            end
+            cols << MimerColumn.new(activeRecIdentCase(colName), table_name, 
+            colDefault, colSqlType, colNativeType, colNullable, colLimit,@typeInfo)
+          end
+          stmt.drop
+          cols
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+
+        # Returns an array of indexes for the given table.
+        def indexes(table_name, name = nil)
+          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
+          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
+          return {}.merge(@abstract2NativeTypeMap) unless @abstract2NativeTypeMap.nil?
+          @abstract2NativeTypeMap = 
+          {
+            :primary_key => "integer not null primary key",
+            :string      => {:name => "VARCHAR", :limit => 255},
+            :text        => {:name => "CLOB"},
+            :integer     => {:name => "INTEGER"},
+            :float       => {:name => "FLOAT"},
+            :datetime    => {:name => "TIMESTAMP"},
+            :timestamp   => {:name => "TIMESTAMP"},
+            :time        => {:name => "TIME"},
+            :date        => {:name => "DATE"},
+            :binary      => {:name => "BLOB"},
+            :boolean     => {:name => "SMALLINT"}
+          }
+
+          {}.merge(@abstract2NativeTypeMap)
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+      
+        def add_column(table_name, column_name, type, options = {})
+          super(table_name, column_name, type, options)				
+        rescue Exception => e
+          raise ActiveRecordError, e.message
+        end
+
+        def remove_column(table_name, column_name)
+          execute "ALTER TABLE #{table_name} DROP COLUMN #{quote_column_name(column_name)}"
+        end
+
+        def change_column(table_name, column_name, type, options = {})
+          execute "ALTER TABLE #{table_name} ALTER  #{column_name} #{type_to_sql(type,options[:limit])}"
+          change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
+        end
+  
+        def change_column_default(table_name, column_name, default)
+          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{quote(default)}"
+        end
+  
+        def remove_index(table_name, options = {})
+          execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+        end
+          
+        def create_table(name, options = {})
+          super(name, options)
+          execute "CREATE UNIQUE SEQUENCE #{name}_seq" unless options[:id] == false          
+        end
+    
+        def drop_table(name)
+          super(name)
+          execute "DROP SEQUENCE #{name}_seq"          
+        rescue Exception => e
+          if e.message !~ /ORA-02289/i
+            raise
+          end
+        end
+
+        def type_to_sql(type, limit = nil) # :nodoc:
+          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
+          raise ActiveRecordError, e.message
+        end
+
+        def getDbTypeInfo
+          return @typeInfo if @typeInfo
+          
+          begin
+            stmt = @connection.types
+            @typeInfo = stmt.fetch_all
+          rescue Exception => e
+            raise ActiveRecordError, e.message
+          ensure
+            stmt.drop unless stmt.nil?
+          end
+          @typeInfo
+        end
+        
+        def dbmsIdentCase(identifier)
+          # Assume received identifier is in ActiveRecord case.
+          case @connection.get_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 @connection.get_info(ODBC::SQL_IDENTIFIER_CASE)
+          when ODBC::SQL_IC_UPPER
+            identifier =~ /[a-z]/ ? identifier : identifier.downcase
+          else
+            identifier
+          end
+        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
+      end
+      
+      class MimerColumn < Column #:nodoc:
+        
+        def initialize (name, tableName, default, odbcSqlType, nativeType, 
+                        null = true, limit = nil, typeInfo = nil)
+          @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 MimerColumn 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
+        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.string_to_binary(value)
+          return "X'#{value.unpack("C*").collect {|v| v.to_s(16)}.join}'"
+        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 MimerColumn
+    end
+  end
+rescue LoadError
+  module ActiveRecord # :nodoc:
+    class Base
+      def self.mimer_connection(config) # :nodoc:
+        raise LoadError, "The Ruby Mimer module could not be loaded."
+      end
+    end
+  end
+end

data/lib/mimer_adapter.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'active_record/connection_adapters/mimer_adapter'

data/test/basic_test.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rubygems'
+require 'active_record'
+require 'mimer_adapter'
+
+ActiveRecord::Base.establish_connection(:adapter=>'mimer',
+                                        :dsn => 'ar-mimer-testdb1',
+                                        :username=>'test_ar',
+                                        :password=>'test_ar')
+
+
+ActiveRecord::Schema.define do
+  drop_table :authors rescue nil
+  
+  create_table :authors, :force => true do |t|
+    t.column :name, :string, :null => false
+  end
+
+  # Exercise all types, and add_column
+  add_column :authors, :description, :text
+  add_column :authors, :descr, :string, :limit => 50
+  add_column :authors, :age, :integer, :null => false, :default => 17
+  add_column :authors, :weight, :float
+  add_column :authors, :born, :datetime
+  add_column :authors, :died, :timestamp
+  add_column :authors, :wakeup_time, :time
+  add_column :authors, :birth_date, :date
+  add_column :authors, :private_key, :binary
+  add_column :authors, :female, :boolean, :default => true
+
+  change_column :authors, :descr, :string, :limit => 100
+  change_column_default :authors, :female, false
+  remove_column :authors, :died
+
+  add_index :authors, :name, :unique
+  add_index :authors, [:age,:female], :name => :is_age_female
+ 
+  remove_index :authors, :name
+  remove_index :authors, :name => :is_age_female
+  
+  create_table :products, :force => true do |t|
+    t.column :title,       :string
+    t.column :description, :text
+    t.column :image_url,   :string
+  end
+
+  add_column :products, :price, :float, :default => 0.0
+  
+  create_table :orders, :force => true do |t|
+    t.column :name, :string
+    t.column :address, :text
+    t.column :email, :string
+    t.column :pay_type, :string, :limit => 10
+  end
+  create_table :line_items, :force => true do |t|
+    t.column :product_id,  :integer, :null => false
+    t.column :order_id,    :integer, :null => false
+    t.column :quantity,    :integer, :null => false
+    t.column :total_price, :float, :null => false
+  end
+end
+
+class Author < ActiveRecord::Base; end
+
+class Order < ActiveRecord::Base
+  has_many :line_items
+end
+
+class Product < ActiveRecord::Base
+  has_many :orders, :through => :line_items
+  has_many :line_items
+  
+  def self.find_products_for_sale
+    find(:all, :order => "title")
+  end
+end
+
+class LineItem < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :product
+end
+
+Product.create(:title => 'Pragmatic Project Automation',
+               :description => 
+   %{<p>
+       <em>Pragmatic Project Automation</em> shows you how to improve the 
+       consistency and repeatability of your projects procedures using 
+       automation to reduce risk and errors.
+      </p>
+      <p>
+        Simply put, were going to put this thing called a computer to work 
+        for you doing the mundane (but important) project stuff. That means 
+        youll have more time and energy to do the really 
+        exciting---and difficult---stuff, like writing quality code.
+      </p>},
+               :image_url =>   '/images/auto.jpg',    
+               :price => 29.95)
+
+
+Product.create(:title => 'Pragmatic Version Control',
+               :description =>
+      %{<p>
+         This book is a recipe-based approach to using Subversion that will 
+         get you up and 
+         running quickly---and correctly. All projects need version control: 
+         its a foundational piece of any projects infrastructure. Yet half 
+         of all project teams in the U.S. dont use any version control at all. 
+         Many others dont use it well, and end up experiencing time-consuming problems.
+      </p>},
+               :image_url => '/images/svn.jpg',
+               :price => 28.50)
+    
+Product.create(:title => 'Pragmatic Unit Testing (C#)',
+               :description => 
+    %{<p>
+        Pragmatic programmers use feedback to drive their development and 
+        personal processes. The most valuable feedback you can get while 
+        coding comes from unit testing.
+      </p>
+      <p>
+        Without good tests in place, coding can become a frustrating game of 
+        "whack-a-mole." Thats the carnival game where the player strikes at a 
+        mechanical mole; it retreats and another mole pops up on the opposite side 
+        of the field. The moles pop up and down so fast that you end up flailing 
+        your mallet helplessly as the moles continue to pop up where you least 
+        expect them.
+      </p>},
+               :image_url => '/images/utc.jpg',
+               :price => 27.75)
+
+Author.destroy_all
+Author.create(:name => "Arne Svensson", :age => 30)
+Author.create(:name => "Pelle Gogolsson", :age => 15, :wakeup_time => Time.now, :private_key => "afbafddsfgsdfg")
+Author.find(:first)
+Author.find(:all)
+arne = Author.find(:first)
+arne.destroy
+pelle = Author.find(:first)
+pelle.name = "Pelle Sweitchon"
+pelle.description = "dfsssdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+pelle.descr = "adsfasdf"
+pelle.age = 79
+pelle.weight = 57.6
+pelle.born = Time.gm(1982,8,13,10,15,3,0)
+pelle.female = false
+pelle.save
+
+prods = Product.find_all
+order = Order.new(:name => "Dalai Lama", :address => "Great Road 32", :email => "abc@dot.com", :pay_type => "cash")
+order.line_items << LineItem.new(:product => prods[0], :quantity => 3, :total_price => (prods[0].price * 3))
+order.line_items << LineItem.new(:product => prods[2], :quantity => 1, :total_price => (prods[2].price))
+order.save
+order.line_items.first.order.line_items.first.product.orders.first
+
+#puts "order: #{order.line_items.inspect}, with id: #{order.id} and name: #{order.name}"
+
+ActiveRecord::Schema.define do 
+  drop_table :line_items
+  drop_table :orders
+  drop_table :products
+  drop_table :authors
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: activerecord-mimer
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-11-08 00:00:00 +01:00
+summary: Mimer support for ActiveRecord.
+require_paths: 
+- lib
+email: ola@ologix.com
+homepage: http://ar-mimer.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: mimer_adapter
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ola Bini
+files: 
+- lib/active_record
+- lib/mimer_adapter.rb
+- lib/active_record/connection_adapters
+- lib/active_record/connection_adapters/mimer_adapter.rb
+- test/basic_test.rb
+- LICENSE
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+