odbc_adapter 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a82f638f836342da6b1ef70597ad205ad869e796
-  data.tar.gz: e2f9e57124fa42ebd816ba4e3446d68c2fc06d74
+  metadata.gz: f5157fd72c8b51e81109ffbc557706d5164e52ea
+  data.tar.gz: 07045f2ee0d6f4a8c61f0566e9a2ed4af6a88565
 SHA512:
-  metadata.gz: c1766ac63ef69f279469a25c47c18495e8e2aac3c9dce4a73c0b2ca73987446fef18fb91492231a8c60dd5b1ca30613744576c6f93ccd6dcb4dc41944bf04fe2
-  data.tar.gz: dc416dc3d4d359f7a6e5e5bac66fec0f08b567ffa576bbf56446d51d20dfa85836236a58cfb05811114a1d56f6fcf63ae43528d4eac4f5f697308fffea881e4a
+  metadata.gz: 5ac83f350948348b7f0e36bc68881b2b401f47ebd449f615abee9f5650d1c1bda3fb6fb5de7519e3af5d5d4efbc5b2d61b67bacd96795eb96b3fcdbe77b0e1cb
+  data.tar.gz: 7263035cff902e1776abc8000b961d55779d1c6e9084cbaea24561d3ea2aef85bc9331bfbceee3885d85ad2dfa8909150edc8dee275652566cd25a51f645c129

data/README.md

@@ -2,10 +2,16 @@
 
 [![Build Status](https://travis-ci.com/localytics/odbc_adapter.svg?token=kQUiABmGkzyHdJdMnCnv&branch=master)](https://travis-ci.com/localytics/odbc_adapter)
 
-An ActiveRecord ODBC adapter.
+An ActiveRecord ODBC adapter. Master branch is working off of edge Rails. Previous work has been done to make it compatible with Rails 3.2 and 4.2; for those versions use the 3.2.x or 4.2.x gem releases.
+
+This adapter will work for basic queries for most DBMSs out of the box, without support for migrations. Full support is built-in for MySQL 5 and PostgreSQL 9 databases. You can register your own adapter to get more support for your DBMS using the `ODBCAdapter.register` function.
+
+A lot of this work is based on [OpenLink's ActiveRecord adapter](http://odbc-rails.rubyforge.org/) which works for earlier versions of Rails.
 
 ## Installation
 
+Ensure you have the ODBC driver installed on your machine. You will also need the driver for whichever database to which you want ODBC to connect.
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -22,11 +28,27 @@ Or install it yourself as:
 
 ## Usage
 
-## Development
+Configure your `database.yml` by either using the `dsn` option to point to a DSN that corresponds to a valid entry in your `~/.odbc.ini` file:
+
+```
+development:
+  adapter:  odbc
+  dsn: MyDatabaseDSN
+```
+
+or by using the `conn_str` option and specifying the entire connection string:
+
+```
+development:
+  adapter: odbc
+  conn_str: "DRIVER={PostgreSQL ANSI};SERVER=localhost;PORT=5432;DATABASE=my_database;UID=postgres;"
+```
+
+ActiveRecord models that use this connection will now be connecting to the configured database using the ODBC driver.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Testing
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To run the tests, you'll need the ODBC driver as well as the connection adapter for each database against which you're trying to test. Then run `DSN=MyDatabaseDSN bundle exec rake test` and the test suite will be run by connecting to your database.
 
 ## Contributing
 

data/bin/console

@@ -3,5 +3,10 @@
 require 'bundler/setup'
 require 'odbc_adapter'
 
+options = { adapter: 'odbc' }
+options[:dsn]      = ENV['DSN']      if ENV['DSN']
+options[:conn_str] = ENV['CONN_STR'] if ENV['CONN_STR']
+ActiveRecord::Base.establish_connection(options) if options.any?
+
 require 'irb'
 IRB.start

data/lib/active_record/connection_adapters/odbc_adapter.rb

@@ -2,22 +2,23 @@ require 'active_record'
 require 'arel/visitors/bind_visitor'
 require 'odbc'
 
-require 'odbc_adapter'
 require 'odbc_adapter/database_limits'
 require 'odbc_adapter/database_statements'
+require 'odbc_adapter/error'
 require 'odbc_adapter/quoting'
 require 'odbc_adapter/schema_statements'
 
 require 'odbc_adapter/column'
 require 'odbc_adapter/column_metadata'
-require 'odbc_adapter/dbms'
+require 'odbc_adapter/database_metadata'
+require 'odbc_adapter/registry'
 require 'odbc_adapter/type_caster'
 require 'odbc_adapter/version'
 
 module ActiveRecord
   class Base
     class << self
-      def odbc_connection(config) # :nodoc:
+      def odbc_connection(config)
         config = config.symbolize_keys
 
         connection, options =
@@ -29,8 +30,8 @@ module ActiveRecord
             raise ArgumentError, "No data source name (:dsn) or connection string (:conn_str) specified."
           end
 
-        dbms = ::ODBCAdapter::DBMS.new(connection)
-        dbms.adapter_class.new(connection, logger, dbms)
+        database_metadata = ::ODBCAdapter::DatabaseMetadata.new(connection)
+        database_metadata.adapter_class.new(connection, logger, database_metadata)
       end
 
       private
@@ -75,14 +76,16 @@ module ActiveRecord
 
       ADAPTER_NAME = 'ODBC'.freeze
       BOOLEAN_TYPE = 'BOOLEAN'.freeze
+
       ERR_DUPLICATE_KEY_VALUE = 23505
+      ERR_QUERY_TIMED_OUT = /Query has timed out/
 
-      attr_reader :dbms
+      attr_reader :database_metadata
 
-      def initialize(connection, logger, dbms)
+      def initialize(connection, logger, database_metadata)
         super(connection, logger)
-        @connection = connection
-        @dbms       = dbms
+        @connection        = connection
+        @database_metadata = database_metadata
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one
@@ -165,9 +168,11 @@ module ActiveRecord
       end
 
       def translate_exception(exception, message)
-        case exception.message[/^\d+/].to_i
-        when ERR_DUPLICATE_KEY_VALUE
+        case
+        when exception.message[/^\d+/].to_i == ERR_DUPLICATE_KEY_VALUE
           ActiveRecord::RecordNotUnique.new(message, exception)
+        when exception.message =~ ERR_QUERY_TIMED_OUT
+          ::ODBCAdapter::QueryTimeoutError.new(message, exception)
         else
           super
         end

data/lib/odbc_adapter.rb

@@ -1,17 +1,2 @@
 # Requiring with this pattern to mirror ActiveRecord
 require 'active_record/connection_adapters/odbc_adapter'
-
-module ODBCAdapter
-  class << self
-    def dbms_registry
-      @dbms_registry ||= {
-        /my.*sql/i => :MySQL,
-        /postgres/i => :PostgreSQL
-      }
-    end
-
-    def register(pattern, superclass, &block)
-      dbms_registry[pattern] = Class.new(superclass, &block)
-    end
-  end
-end

data/lib/odbc_adapter/adapters/mysql_odbc_adapter.rb

@@ -1,7 +1,7 @@
 module ODBCAdapter
   module Adapters
     # Overrides specific to MySQL. Mostly taken from
-    # ActiveRecord::ConnectionAdapters::MySQLAdapter
+    # ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
     class MySQLODBCAdapter < ActiveRecord::ConnectionAdapters::ODBCAdapter
       PRIMARY_KEY = 'INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY'.freeze
 
@@ -27,27 +27,6 @@ module ODBCAdapter
         execute("TRUNCATE TABLE #{quote_table_name(table_name)}", name)
       end
 
-      def limited_update_conditions(where_sql, _quoted_table_name, _quoted_primary_key)
-        where_sql
-      end
-
-      # Taken from ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
-      def join_to_update(update, select) #:nodoc:
-        if select.limit || select.offset || select.orders.any?
-          subsubselect = select.clone
-          subsubselect.projections = [update.key]
-
-          subselect = Arel::SelectManager.new(select.engine)
-          subselect.project Arel.sql(update.key.name)
-          subselect.from subsubselect.as('__active_record_temp')
-
-          update.where update.key.in(subselect)
-        else
-          update.table select.source
-          update.wheres = select.constraints
-        end
-      end
-
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(string)
@@ -70,7 +49,7 @@ module ODBCAdapter
         0
       end
 
-      def disable_referential_integrity(&block) #:nodoc:
+      def disable_referential_integrity(&block)
         old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
 
         begin
@@ -81,13 +60,14 @@ module ODBCAdapter
         end
       end
 
-      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
-      # Charset defaults to utf8.
+      # Create a new MySQL database with optional <tt>:charset</tt> and
+      # <tt>:collation</tt>. Charset defaults to utf8.
       #
       # Example:
-      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
-      #   create_database 'matt_development'
-      #   create_database 'matt_development', :charset => :big5
+      #   create_database 'charset_test', charset: 'latin1',
+      #                                   collation: 'latin1_bin'
+      #   create_database 'rails_development'
+      #   create_database 'rails_development', charset: :big5
       def create_database(name, options = {})
         if options[:collation]
           execute("CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`")
@@ -99,8 +79,8 @@ module ODBCAdapter
       # Drops a MySQL database.
       #
       # Example:
-      #   drop_database('sebastian_development')
-      def drop_database(name) #:nodoc:
+      #   drop_database('rails_development')
+      def drop_database(name)
         execute("DROP DATABASE IF EXISTS `#{name}`")
       end
 
@@ -114,9 +94,8 @@ module ODBCAdapter
       end
 
       def change_column(table_name, column_name, type, options = {})
-        # column_name.to_s used in case column_name is a symbol
         unless options_include_default?(options)
-          options[:default] = columns(table_name).find { |c| c.name == column_name.to_s }.default
+          options[:default] = column_for(table_name, column_name).default
         end
 
         change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
@@ -124,26 +103,36 @@ module ODBCAdapter
         execute(change_column_sql)
       end
 
-      def change_column_default(table_name, column_name, default)
-        col = columns(table_name).detect { |c| c.name == column_name.to_s }
-        change_column(table_name, column_name, col.type,
-          default: default, limit: col.limit, precision: col.precision, scale: col.scale)
+      def change_column_default(table_name, column_name, default_or_changes)
+        default = extract_new_default_value(default_or_changes)
+        column = column_for(table_name, column_name)
+        change_column(table_name, column_name, column.sql_type, default: default)
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        column = column_for(table_name, column_name)
+
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+        change_column(table_name, column_name, column.sql_type, null: null)
       end
 
       def rename_column(table_name, column_name, new_column_name)
-        col = columns(table_name).detect { |c| c.name == column_name.to_s }
-        current_type = col.native_type
-        current_type << "(#{col.limit})" if col.limit
+        column = column_for(table_name, column_name)
+        current_type = column.native_type
+        current_type << "(#{column.limit})" if column.limit
         execute("ALTER TABLE #{table_name} CHANGE #{column_name} #{new_column_name} #{current_type}")
       end
 
+      # Skip primary key indexes
       def indexes(table_name, name = nil)
-        # Skip primary key indexes
-        super(table_name, name).delete_if { |i| i.unique && i.name =~ /^PRIMARY$/ }
+        super(table_name, name).reject { |i| i.unique && i.name =~ /^PRIMARY$/ }
       end
 
+      # MySQL 5.x doesn't allow DEFAULT NULL for first timestamp column in a
+      # table
       def options_include_default?(options)
-        # MySQL 5.x doesn't allow DEFAULT NULL for first timestamp column in a table
         if options.include?(:default) && options[:default].nil?
           if options.include?(:column) && options[:column].native_type =~ /timestamp/i
             options.delete(:default)
@@ -152,14 +141,6 @@ module ODBCAdapter
         super(options)
       end
 
-      def structure_dump
-        select_all("SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'").map do |table|
-          table.delete('Table_type')
-          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
-          exec_query(sql).first['Create Table'] + ";\n\n"
-        end.join
-      end
-
       protected
 
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)

data/lib/odbc_adapter/adapters/null_odbc_adapter.rb

@@ -0,0 +1,31 @@
+module ODBCAdapter
+  module Adapters
+    # A default adapter used for databases that are no explicitly listed in the
+    # registry. This allows for minimal support for DBMSs for which we don't
+    # have an explicit adapter.
+    class NullODBCAdapter < ActiveRecord::ConnectionAdapters::ODBCAdapter
+      class BindSubstitution < Arel::Visitors::ToSql
+        include Arel::Visitors::BindVisitor
+      end
+
+      # Using a BindVisitor so that the SQL string gets substituted before it is
+      # sent to the DBMS (to attempt to get as much coverage as possible for
+      # DBMSs we don't support).
+      def arel_visitor
+        BindSubstitution.new(self)
+      end
+
+      # Explicitly turning off prepared_statements in the null adapter because
+      # there isn't really a standard on which substitution character to use.
+      def prepared_statements
+        false
+      end
+
+      # Turning off support for migrations because there is no information to
+      # go off of for what syntax the DBMS will expect.
+      def supports_migrations?
+        false
+      end
+    end
+  end
+end

data/lib/odbc_adapter/adapters/postgresql_odbc_adapter.rb

@@ -6,6 +6,8 @@ module ODBCAdapter
       BOOLEAN_TYPE = 'bool'.freeze
       PRIMARY_KEY  = 'SERIAL PRIMARY KEY'.freeze
 
+      alias :create :insert
+
       # Override to handle booleans appropriately
       def native_database_types
         @native_database_types ||= super.merge(boolean: { name: 'bool' })
@@ -25,34 +27,14 @@ module ODBCAdapter
         exec_query("TRUNCATE TABLE #{quote_table_name(table_name)}", name)
       end
 
-      # Returns the sequence name for a table's primary key or some other specified key.
-      def default_sequence_name(table_name, pk = nil) #:nodoc:
+      # Returns the sequence name for a table's primary key or some other
+      # specified key.
+      def default_sequence_name(table_name, pk = nil)
         serial_sequence(table_name, pk || 'id').split('.').last
       rescue ActiveRecord::StatementInvalid
         "#{table_name}_#{pk || 'id'}_seq"
       end
 
-      # Returns the current ID of a table's sequence.
-      def last_insert_id(sequence_name)
-        r = exec_query("SELECT currval('#{sequence_name}')", 'SQL')
-        Integer(r.rows.first.first)
-      end
-
-      # Executes an INSERT query and returns the new record's ID
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        unless pk
-          table_ref = extract_table_ref_from_insert_sql(sql)
-          pk = primary_key(table_ref) if table_ref
-        end
-
-        if pk
-          select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-        else
-          super
-        end
-      end
-      alias :create :insert
-
       def sql_for_insert(sql, pk, id_value, sequence_name, binds)
         unless pk
           table_ref = extract_table_ref_from_insert_sql(sql)
@@ -81,20 +63,21 @@ module ODBCAdapter
         string.gsub(/\\/, '\&\&').gsub(/'/, "''")
       end
 
-      def disable_referential_integrity #:nodoc:
+      def disable_referential_integrity
         execute(tables.map { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(';'))
         yield
       ensure
         execute(tables.map { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(';'))
       end
 
-      # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
-      # <tt>:encoding</tt>, <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL
-      # uses <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
+      # Create a new PostgreSQL database. Options include <tt>:owner</tt>,
+      # <tt>:template</tt>, <tt>:encoding</tt>, <tt>:tablespace</tt>, and
+      # <tt>:connection_limit</tt> (note that MySQL uses <tt>:charset</tt>
+      # while PostgreSQL uses <tt>:encoding</tt>).
       #
       # Example:
       #   create_database config[:database], config
-      #   create_database 'foo_development', :encoding => 'unicode'
+      #   create_database 'foo_development', encoding: 'unicode'
       def create_database(name, options = {})
         options = options.reverse_merge(encoding: 'utf8')
 
@@ -121,8 +104,8 @@ module ODBCAdapter
       # Drops a PostgreSQL database.
       #
       # Example:
-      #   drop_database 'matt_development'
-      def drop_database(name) #:nodoc:
+      #   drop_database 'rails_development'
+      def drop_database(name)
         execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
       end
 
@@ -152,17 +135,19 @@ module ODBCAdapter
         execute("ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}")
       end
 
-      # Returns a SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+      # Returns a SELECT DISTINCT clause for a given set of columns and a given
+      # ORDER BY clause.
       #
-      # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
-      # requires that the ORDER BY include the distinct column.
+      # PostgreSQL requires the ORDER BY columns in the select list for
+      # distinct queries, and requires that the ORDER BY include the distinct
+      # column.
       #
       #   distinct("posts.id", "posts.created_at desc")
       def distinct(columns, orders)
         return "DISTINCT #{columns}" if orders.empty?
 
-        # Construct a clean list of column names from the ORDER BY clause, removing
-        # any ASC/DESC modifiers
+        # Construct a clean list of column names from the ORDER BY clause,
+        # removing any ASC/DESC modifiers
         order_columns = orders.map { |s| s.gsub(/\s+(ASC|DESC)\s*(NULLS\s+(FIRST|LAST)\s*)?/i, '') }
         order_columns.reject! { |c| c.blank? }
         order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
@@ -170,6 +155,28 @@ module ODBCAdapter
         "DISTINCT #{columns}, #{order_columns * ', '}"
       end
 
+      protected
+
+      # Executes an INSERT query and returns the new record's ID
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        unless pk
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          pk = primary_key(table_ref) if table_ref
+        end
+
+        if pk
+          select_value("#{sql} RETURNING #{quote_column_name(pk)}")
+        else
+          super
+        end
+      end
+
+      # Returns the current ID of a table's sequence.
+      def last_insert_id(sequence_name)
+        r = exec_query("SELECT currval('#{sequence_name}')", 'SQL')
+        Integer(r.rows.first.first)
+      end
+
       private
 
       def serial_sequence(table, column)

data/lib/odbc_adapter/database_limits.rb

@@ -2,8 +2,8 @@ module ODBCAdapter
   module DatabaseLimits
     # Returns the maximum length of a table name.
     def table_alias_length
-      max_identifier_length = dbms.field_for(ODBC::SQL_MAX_IDENTIFIER_LEN)
-      max_table_name_length = dbms.field_for(ODBC::SQL_MAX_TABLE_NAME_LEN)
+      max_identifier_length = database_metadata.max_identifier_len
+      max_table_name_length = database_metadata.max_table_name_len
       [max_identifier_length, max_table_name_length].max
     end
   end

data/lib/odbc_adapter/database_metadata.rb

@@ -0,0 +1,44 @@
+module ODBCAdapter
+  # Caches SQLGetInfo output
+  class DatabaseMetadata
+    FIELDS = %i[
+      SQL_DBMS_NAME
+      SQL_DBMS_VER
+      SQL_IDENTIFIER_CASE
+      SQL_QUOTED_IDENTIFIER_CASE
+      SQL_IDENTIFIER_QUOTE_CHAR
+      SQL_MAX_IDENTIFIER_LEN
+      SQL_MAX_TABLE_NAME_LEN
+      SQL_USER_NAME
+      SQL_DATABASE_NAME
+    ]
+
+    attr_reader :values
+
+    def initialize(connection)
+      @values = Hash[FIELDS.map { |field| [field, connection.get_info(ODBC.const_get(field))] }]
+    end
+
+    def adapter_class
+      ODBCAdapter.adapter_for(dbms_name)
+    end
+
+    def upcase_identifiers?
+      @upcase_identifiers ||= (identifier_case == ODBC::SQL_IC_UPPER)
+    end
+
+    # A little bit of metaprogramming magic here to create accessors for each of
+    # the fields reported on by the DBMS.
+    FIELDS.each do |field|
+      define_method(field.to_s.downcase.gsub('sql_', '')) do
+        value_for(field)
+      end
+    end
+
+    private
+
+    def value_for(field)
+      values[field]
+    end
+  end
+end

data/lib/odbc_adapter/database_statements.rb

@@ -87,8 +87,7 @@ module ODBCAdapter
 
     # Assume received identifier is in DBMS's data dictionary case.
     def format_case(identifier)
-      case dbms.field_for(ODBC::SQL_IDENTIFIER_CASE)
-      when ODBC::SQL_IC_UPPER
+      if database_metadata.upcase_identifiers?
         identifier =~ /[a-z]/ ? identifier : identifier.downcase
       else
         identifier
@@ -114,8 +113,7 @@ module ODBCAdapter
     # Converts an identifier to the case conventions used by the DBMS.
     # Assume received identifier is in ActiveRecord case.
     def native_case(identifier)
-      case dbms.field_for(ODBC::SQL_IDENTIFIER_CASE)
-      when ODBC::SQL_IC_UPPER
+      if database_metadata.upcase_identifiers?
         identifier =~ /[A-Z]/ ? identifier : identifier.upcase
       else
         identifier

data/lib/odbc_adapter/error.rb

@@ -0,0 +1,4 @@
+module ODBCAdapter
+  class QueryTimeoutError < ActiveRecord::StatementInvalid
+  end
+end

data/lib/odbc_adapter/quoting.rb

@@ -8,7 +8,7 @@ module ODBCAdapter
     # Returns a quoted form of the column name.
     def quote_column_name(name)
       name = name.to_s
-      quote_char = dbms.field_for(ODBC::SQL_IDENTIFIER_QUOTE_CHAR).to_s.strip
+      quote_char = database_metadata.identifier_quote_char.to_s.strip
 
       return name if quote_char.length.zero?
       quote_char = quote_char[0]
@@ -16,9 +16,8 @@ module ODBCAdapter
       # Avoid quoting any already quoted name
       return name if name[0] == quote_char && name[-1] == quote_char
 
-      # If DBMS's SQL_IDENTIFIER_CASE = SQL_IC_UPPER, only quote mixed
-      # case names.
-      if dbms.field_for(ODBC::SQL_IDENTIFIER_CASE) == ODBC::SQL_IC_UPPER
+      # If upcase identifiers, only quote mixed case names.
+      if database_metadata.upcase_identifiers?
         return name unless (name =~ /([A-Z]+[a-z])|([a-z]+[A-Z])/)
       end
 

data/lib/odbc_adapter/registry.rb

@@ -0,0 +1,50 @@
+module ODBCAdapter
+  class Registry
+    attr_reader :dbs
+
+    def initialize
+      @dbs = {
+        /my.*sql/i  => :MySQL,
+        /postgres/i => :PostgreSQL
+      }
+    end
+
+    def adapter_for(reported_name)
+      reported_name = reported_name.downcase.gsub(/\s/, '')
+      found =
+        dbs.detect do |pattern, adapter|
+          adapter if reported_name =~ pattern
+        end
+
+      normalize_adapter(found && found.last || :Null)
+    end
+
+    def register(pattern, superclass = Object, &block)
+      dbs[pattern] = Class.new(superclass, &block)
+    end
+
+    private
+
+    def normalize_adapter(adapter)
+      return adapter unless adapter.is_a?(Symbol)
+      require "odbc_adapter/adapters/#{adapter.downcase}_odbc_adapter"
+      Adapters.const_get(:"#{adapter}ODBCAdapter")
+    end
+  end
+
+  class << self
+    def adapter_for(reported_name)
+      registry.adapter_for(reported_name)
+    end
+
+    def register(pattern, superclass = Object, &block)
+      registry.register(pattern, superclass, &block)
+    end
+
+    private
+
+    def registry
+      @registry ||= Registry.new
+    end
+  end
+end

data/lib/odbc_adapter/schema_statements.rb

@@ -51,7 +51,7 @@ module ODBCAdapter
         next_row = result[row_idx + 1]
 
         if (row_idx == result.length - 1) || (next_row[6] == 0 || next_row[7] == 1)
-          indices << IndexDefinition.new(table_name, format_case(index_name), unique, index_cols)
+          indices << ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, format_case(index_name), unique, index_cols)
         end
       end
     end
@@ -95,15 +95,34 @@ module ODBCAdapter
       result[0] && result[0][3]
     end
 
+    def foreign_keys(table_name)
+      stmt   = @connection.foreign_keys(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+
+      result.map do |key|
+        fk_from_table      = key[2]  # PKTABLE_NAME
+        fk_to_table        = key[6]  # FKTABLE_NAME
+
+        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(fk_from_table, fk_to_table,
+          name:        key[11], # FK_NAME
+          column:      key[3],  # PKCOLUMN_NAME
+          primary_key: key[7],  # FKCOLUMN_NAME
+          on_delete:   key[10], # DELETE_RULE
+          on_update:   key[9]   # UPDATE_RULE
+        )
+      end
+    end
+
     # Ensure it's shorter than the maximum identifier length for the current
     # dbms
     def index_name(table_name, options)
-      maximum = dbms.field_for(ODBC::SQL_MAX_IDENTIFIER_LEN) || 255
+      maximum = database_metadata.max_identifier_len || 255
       super(table_name, options)[0...maximum]
     end
 
     def current_database
-      dbms.field_for(ODBC::SQL_DATABASE_NAME).strip
+      database_metadata.database_name.strip
     end
   end
 end

data/lib/odbc_adapter/version.rb

@@ -1,3 +1,3 @@
 module ODBCAdapter
-  VERSION = '5.0.0'
+  VERSION = '5.0.1'
 end

data/odbc_adapter.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.13'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'simplecov', '~> 0.12'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: odbc_adapter
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.0.1
 platform: ruby
 authors:
 - Localytics
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-odbc
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
 description: 
 email:
 - oss@localytics.com
@@ -85,13 +99,16 @@ files:
 - lib/active_record/connection_adapters/odbc_adapter.rb
 - lib/odbc_adapter.rb
 - lib/odbc_adapter/adapters/mysql_odbc_adapter.rb
+- lib/odbc_adapter/adapters/null_odbc_adapter.rb
 - lib/odbc_adapter/adapters/postgresql_odbc_adapter.rb
 - lib/odbc_adapter/column.rb
 - lib/odbc_adapter/column_metadata.rb
 - lib/odbc_adapter/database_limits.rb
+- lib/odbc_adapter/database_metadata.rb
 - lib/odbc_adapter/database_statements.rb
-- lib/odbc_adapter/dbms.rb
+- lib/odbc_adapter/error.rb
 - lib/odbc_adapter/quoting.rb
+- lib/odbc_adapter/registry.rb
 - lib/odbc_adapter/schema_statements.rb
 - lib/odbc_adapter/type_caster.rb
 - lib/odbc_adapter/version.rb

data/lib/odbc_adapter/dbms.rb

@@ -1,50 +0,0 @@
-module ODBCAdapter
-  # Caches SQLGetInfo output
-  class DBMS
-    FIELDS = [
-      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,
-      ODBC::SQL_DATABASE_NAME
-    ]
-
-    attr_reader :fields
-
-    def initialize(connection)
-      @fields = Hash[FIELDS.map { |field| [field, connection.get_info(field)] }]
-    end
-
-    def adapter_class
-      return adapter unless adapter.is_a?(Symbol)
-      require "odbc_adapter/adapters/#{adapter.downcase}_odbc_adapter"
-      Adapters.const_get(:"#{adapter}ODBCAdapter")
-    end
-
-    def field_for(field)
-      fields[field]
-    end
-
-    private
-
-    # Maps a DBMS name to a symbol
-    # Different ODBC drivers might return different names for the same DBMS
-    def adapter
-      @adapter ||=
-        begin
-          reported = field_for(ODBC::SQL_DBMS_NAME).downcase.gsub(/\s/, '')
-          found =
-            ODBCAdapter.dbms_registry.detect do |pattern, adapter|
-              adapter if reported =~ pattern
-            end
-
-          raise ArgumentError, "ODBCAdapter: Unsupported database (#{reported})" if found.nil?
-          found.last
-        end
-    end
-  end
-end