odbc_adapter 3.2.0

data/lib/odbc_adapter/adapters/postgresql_odbc_adapter.rb

@@ -0,0 +1,230 @@
+module ODBCAdapter
+  module Adapters
+    # Overrides specific to PostgreSQL. Mostly taken from
+    # ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+    class PostgreSQLODBCAdapter < ActiveRecord::ConnectionAdapters::ODBCAdapter
+      class BindSubstitution < Arel::Visitors::PostgreSQL
+        include Arel::Visitors::BindVisitor
+      end
+
+      class PostgreSQLColumn < Column
+        def initialize(name, default, sql_type, native_type, null = true, scale = nil, native_types = nil, limit = nil)
+          super
+          @default = extract_default
+        end
+
+        private
+
+        def extract_default
+          case @default
+          when NilClass
+            nil
+          # Numeric types
+          when /\A\(?(-?\d+(\.\d*)?\)?(::bigint)?)\z/ then $1
+          # Character types
+          when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m then $1
+          # Binary data types
+          when /\A'(.*)'::bytea\z/m then $1
+          # Date/time types
+          when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/ then $1
+          when /\A'(.*)'::interval\z/ then $1
+          # Boolean type
+          when 'true' then true
+          when 'false' then false
+          # Geometric types
+          when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/ then $1
+          # Network address types
+          when /\A'(.*)'::(?:cidr|inet|macaddr)\z/ then $1
+          # Bit string types
+          when /\AB'(.*)'::"?bit(?: varying)?"?\z/ then $1
+          # XML type
+          when /\A'(.*)'::xml\z/m then $1
+          # Arrays
+          when /\A'(.*)'::"?\D+"?\[\]\z/ then $1
+          # Object identifier types
+          when /\A-?\d+\z/ then $1
+          else
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            nil
+          end
+        end
+      end
+
+      PRIMARY_KEY = 'SERIAL PRIMARY KEY'
+
+      # Override the default column class
+      def column_class
+        PostgreSQLColumn
+      end
+
+      # Filter for ODBCAdapter#tables
+      # Omits table from #tables if table_filter returns true
+      def table_filter(schema_name, table_type)
+        %w[information_schema pg_catalog].include?(schema_name) || table_type !~ /TABLE/i
+      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:
+        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)
+          pk = primary_key(table_ref) if table_ref
+        end
+
+        sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
+        [sql, binds]
+      end
+
+      def type_cast(value, column)
+        return super unless column
+
+        case value
+        when String
+          return super unless 'bytea' == column.sql_type
+          { value: value, format: 1 }
+        else
+          super
+        end
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(string)
+        string.gsub(/\\/, '\&\&').gsub(/'/, "''")
+      end
+
+      def quoted_true
+        "'t'"
+      end
+
+      def quoted_false
+        "'f'"
+      end
+
+      def disable_referential_integrity #:nodoc:
+        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>).
+      #
+      # Example:
+      #   create_database config[:database], config
+      #   create_database 'foo_development', :encoding => 'unicode'
+      def create_database(name, options = {})
+        options = options.reverse_merge(encoding: 'utf8')
+
+        option_string = options.symbolize_keys.sum do |key, value|
+          case key
+          when :owner
+            " OWNER = \"#{value}\""
+          when :template
+            " TEMPLATE = \"#{value}\""
+          when :encoding
+            " ENCODING = '#{value}'"
+          when :tablespace
+            " TABLESPACE = \"#{value}\""
+          when :connection_limit
+            " CONNECTION LIMIT = #{value}"
+          else
+            ""
+          end
+        end
+
+        execute("CREATE DATABASE #{quote_table_name(name)}#{option_string}")
+      end
+
+      # Drops a PostgreSQL database.
+      #
+      # Example:
+      #   drop_database 'matt_development'
+      def drop_database(name) #:nodoc:
+        execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
+      end
+
+      # Renames a table.
+      def rename_table(name, new_name)
+        execute("ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}")
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        execute("ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
+        change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+      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 rename_column(table_name, column_name, new_column_name)
+        execute("ALTER TABLE #{table_name} RENAME #{column_name} TO #{new_column_name}")
+      end
+
+      def remove_index!(_table_name, index_name)
+        execute("DROP INDEX #{quote_table_name(index_name)}")
+      end
+
+      def rename_index(table_name, old_name, new_name)
+        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.
+      #
+      # 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
+        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}" }
+
+        "DISTINCT #{columns}, #{order_columns * ', '}"
+      end
+
+      private
+
+      def serial_sequence(table, column)
+        result = exec_query(<<-eosql, 'SCHEMA')
+          SELECT pg_get_serial_sequence('#{table}', '#{column}')
+        eosql
+        result.rows.first.first
+      end
+    end
+  end
+end

data/lib/odbc_adapter/column.rb

@@ -0,0 +1,67 @@
+module ODBCAdapter
+  class Column < ActiveRecord::ConnectionAdapters::Column
+    def initialize(name, default, sql_type, native_type, null = true, scale = nil, native_types = nil, limit = nil)
+      @name        = name
+      @default     = default
+      @sql_type    = native_type.to_s
+      @native_type = native_type.to_s
+      @null        = null
+      @precision   = extract_precision(sql_type, limit)
+      @scale       = extract_scale(sql_type, scale)
+      @type        = genericize(sql_type, @scale, native_types)
+      @primary     = nil
+    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 genericize(sql_type, scale, native_types)
+      case sql_type
+      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
+      # 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 numeric_type(scale, native_types)
+      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)
+        raise ArgumentError, "Unsupported ODBC SQL type [#{odbcSqlType}]"
+      end
+    end
+
+    # Ignore the ODBC precision of SQL types which don't take
+    # an explicit precision when defining a column
+    def extract_precision(sql_type, precision)
+      precision if [ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC].include?(sql_type)
+    end
+
+    # Ignore the ODBC scale of SQL types which don't take
+    # an explicit scale when defining a column
+    def extract_scale(sql_type, scale)
+      scale || 0 if [ODBC::SQL_DECIMAL, ODBC::SQL_NUMERIC].include?(sql_type)
+    end
+
+    def numeric_type(scale, native_types)
+      scale.nil? || scale == 0 ? :integer : (native_types[:decimal].nil? ? :float : :decimal)
+    end
+  end
+end

data/lib/odbc_adapter/column_metadata.rb

@@ -0,0 +1,77 @@
+module ODBCAdapter
+  class ColumnMetadata
+    GENERICS = {
+      primary_key: [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+      string:      [ODBC::SQL_VARCHAR],
+      text:        [ODBC::SQL_LONGVARCHAR, ODBC::SQL_VARCHAR],
+      integer:     [ODBC::SQL_INTEGER, ODBC::SQL_SMALLINT],
+      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],
+      time:        [ODBC::SQL_TYPE_TIME, ODBC::SQL_TIME, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      date:        [ODBC::SQL_TYPE_DATE, ODBC::SQL_DATE, ODBC::SQL_TYPE_TIMESTAMP, ODBC::SQL_TIMESTAMP],
+      binary:      [ODBC::SQL_LONGVARBINARY, ODBC::SQL_VARBINARY],
+      boolean:     [ODBC::SQL_BIT, ODBC::SQL_TINYINT, ODBC::SQL_SMALLINT, ODBC::SQL_INTEGER]
+    }
+
+    attr_reader :adapter
+
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    # TODO: implement boolean column surrogates
+    def native_database_types
+      grouped = reported_types.group_by { |row| row[1] }
+
+      GENERICS.each_with_object({}) do |(abstract, candidates), mapped|
+        candidates.detect do |candidate|
+          next unless grouped[candidate]
+          mapped[abstract] = native_type_mapping(abstract, grouped[candidate])
+        end
+      end
+    end
+
+    private
+
+    # Creates a Hash describing a mapping from an abstract type to a
+    # DBMS native type for use by #native_database_types
+    def native_type_mapping(abstract, rows)
+      # The appropriate SQL for :primary_key is hard to derive as
+      # ODBC doesn't provide any info on a DBMS's native syntax for
+      # autoincrement columns. So we use a lookup instead.
+      return adapter.class::PRIMARY_KEY if abstract == :primary_key
+      selected_row = rows[0]
+
+      # If more than one native type corresponds to the SQL type we're
+      # handling, the type in the first descriptor should be the
+      # best match, because the ODBC specification states that
+      # SQLGetTypeInfo returns the results ordered by SQL type and then by
+      # how closely the native type maps to that SQL type.
+      # But, for :text and :binary, select the native type with the
+      # largest capacity. (Compare SQLGetTypeInfo:COLUMN_SIZE values)
+      selected_row = rows.max_by { |row| row[2] } if [:text, :binary].include?(abstract)
+      result = { name: selected_row[0] } # SQLGetTypeInfo: TYPE_NAME
+
+      create_params = selected_row[5]
+      # Depending on the column type, the CREATE_PARAMS keywords can
+      # include length, precision or scale.
+      if create_params && create_params.strip.length > 0 && abstract != :decimal
+        result[:limit] = selected_row[2] # SQLGetTypeInfo: COL_SIZE
+      end
+
+      result
+    end
+
+    def reported_types
+      @reported_types ||=
+        begin
+          stmt = adapter.raw_connection.types
+          stmt.fetch_all
+        ensure
+          stmt.drop unless stmt.nil?
+        end
+    end
+  end
+end

data/lib/odbc_adapter/database_limits.rb

@@ -0,0 +1,10 @@
+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, max_table_name_length].max
+    end
+  end
+end

data/lib/odbc_adapter/database_statements.rb

@@ -0,0 +1,254 @@
+module ODBCAdapter
+  module DatabaseStatements
+    # ODBC constants missing from Christian Werner's Ruby ODBC driver
+    SQL_NO_NULLS = 0
+    SQL_NULLABLE = 1
+    SQL_NULLABLE_UNKNOWN = 2
+
+    # Returns an array of arrays containing the field values.
+    # Order is the same as that returned by #columns.
+    def select_rows(sql, name = nil)
+      log(sql, name) do
+        stmt   = @connection.run(sql)
+        result = stmt.fetch_all
+        stmt.drop
+        result
+      end
+    end
+
+    # Executes the SQL statement in the context of this connection.
+    # Returns the number of rows affected.
+    def execute(sql, name = nil)
+      log(sql, name) do
+        @connection.do(sql)
+      end
+    end
+
+    # Executes +sql+ statement in the context of this connection using
+    # +binds+ as the bind substitutes. +name+ is logged along with
+    # the executed +sql+ statement.
+    def exec_query(sql, name = 'SQL', binds = [])
+      log(sql, name) do
+        stmt    = @connection.run(sql)
+        columns = stmt.columns
+        values  = stmt.to_a
+        stmt.drop
+
+        casters = TypeCaster.build_from(columns.values)
+        if casters.any?
+          values.each do |row|
+            casters.each { |caster| row[caster.idx] = caster.cast(row[caster.idx]) }
+          end
+        end
+
+        values = dbms_type_cast(columns.values, values)
+        column_names = columns.keys.map { |key| format_case(key) }
+        result = ActiveRecord::Result.new(column_names, values)
+      end
+    end
+
+    # Begins the transaction (and turns off auto-committing).
+    def begin_db_transaction
+      @connection.autocommit = false
+    end
+
+    # Commits the transaction (and turns on auto-committing).
+    def commit_db_transaction
+      @connection.commit
+      @connection.autocommit = true
+    end
+
+    # Rolls back the transaction (and turns on auto-committing). Must be
+    # done if the transaction block raises an exception or returns false.
+    def rollback_db_transaction
+      @connection.rollback
+      @connection.autocommit = true
+    end
+
+    # Returns the default sequence name for a table.
+    # Used for databases which don't support an autoincrementing column
+    # type, but do support sequences.
+    def default_sequence_name(table, _column)
+      "#{table}_seq"
+    end
+
+    def recreate_database(name, options = {})
+      drop_database(name)
+      create_database(name, options)
+    end
+
+    def current_database
+      dbms.field_for(ODBC::SQL_DATABASE_NAME).strip
+    end
+
+    # Returns an array of table names, for database tables visible on the
+    # current connection.
+    def tables(_name = nil)
+      stmt   = @connection.tables
+      result = stmt.fetch_all || []
+      stmt.drop
+
+      result.each_with_object([]) do |row, table_names|
+        schema_name, table_name, table_type = row[1..3]
+        next if respond_to?(:table_filtered?) && table_filtered?(schema_name, table_type)
+        table_names << format_case(table_name)
+      end
+    end
+
+    # The class of the column to instantiate
+    def column_class
+      ::ODBCAdapter::Column
+    end
+
+    # Returns an array of Column objects for the table specified by +table_name+.
+    def columns(table_name, name = nil)
+      stmt   = @connection.columns(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop
+
+      result.each_with_object([]) do |col, cols|
+        col_name        = col[3]  # SQLColumns: COLUMN_NAME
+        col_default     = col[12] # SQLColumns: COLUMN_DEF
+        col_sql_type    = col[4]  # SQLColumns: DATA_TYPE
+        col_native_type = col[5]  # SQLColumns: TYPE_NAME
+        col_limit       = col[6]  # SQLColumns: COLUMN_SIZE
+        col_scale       = col[8]  # SQLColumns: DECIMAL_DIGITS
+
+        # SQLColumns: IS_NULLABLE, SQLColumns: NULLABLE
+        col_nullable = nullability(col_name, col[17], col[10])
+
+        cols << column_class.new(format_case(col_name), col_default, col_sql_type, col_native_type, col_nullable, col_scale, native_database_types, col_limit)
+      end
+    end
+
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, name = nil)
+      stmt   = @connection.indexes(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+
+      index_cols = []
+      index_name = nil
+      unique     = nil
+
+      result.each_with_object([]).with_index do |(row, indices), row_idx|
+        # 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
+          index_cols = []
+          unique     = row[3].zero? # SQLStatistics: NON_UNIQUE
+          index_name = String.new(row[5]) # SQLStatistics: INDEX_NAME
+        end
+
+        index_cols << format_case(row[8]) # SQLStatistics: COLUMN_NAME
+        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)
+        end
+      end
+    end
+
+    # Returns just a table's primary key
+    def primary_key(table_name)
+      stmt   = @connection.primary_keys(native_case(table_name.to_s))
+      result = stmt.fetch_all || []
+      stmt.drop unless stmt.nil?
+      result[0] && result[0][3]
+    end
+
+    ERR_DUPLICATE_KEY_VALUE = 23505
+
+    def translate_exception(exception, message)
+      case exception.message[/^\d+/].to_i
+      when ERR_DUPLICATE_KEY_VALUE
+        ActiveRecord::RecordNotUnique.new(message, exception)
+      else
+        super
+      end
+    end
+
+    protected
+
+    # Returns an array of record hashes with the column names as keys and
+    # column values as values.
+    def select(sql, name = nil, binds = [])
+      exec_query(sql, name, binds).to_a
+    end
+
+    # Returns the last auto-generated ID from the affected table.
+    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      begin
+        stmt  = log(sql, name) { @connection.run(sql) }
+        table = extract_table_ref_from_insert_sql(sql)
+
+        seq   = sequence_name || default_sequence_name(table, pk)
+        res   = id_value || last_insert_id(table, seq, stmt)
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+      res
+    end
+
+    private
+
+    def dbms_type_cast(columns, values)
+      values
+    end
+
+    def extract_table_ref_from_insert_sql(sql)
+      sql[/into\s+([^\(]*).*values\s*\(/i]
+      $1.strip if $1
+    end
+
+    # 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
+        identifier =~ /[a-z]/ ? identifier : identifier.downcase
+      else
+        identifier
+      end
+    end
+
+    # In general, ActiveRecord uses lowercase attribute names. This may
+    # conflict with the database's data dictionary case.
+    #
+    # The ODBCAdapter uses the following conventions for databases
+    # which report SQL_IDENTIFIER_CASE = SQL_IC_UPPER:
+    # * if a name is returned from the DBMS in all uppercase, convert it
+    #   to lowercase before returning it to ActiveRecord.
+    # * if a name is returned from the DBMS in lowercase or mixed case,
+    #   assume the underlying schema object's name was quoted when
+    #   the schema object was created. Leave the name untouched before
+    #   returning it to ActiveRecord.
+    # * before making an ODBC catalog call, if a supplied identifier is all
+    #   lowercase, convert it to uppercase. Leave mixed case or all
+    #   uppercase identifiers unchanged.
+    # * columns created with quoted lowercase names are not supported.
+    #
+    # Converts an identifier to the case conventions used by the DBMS.
+    # Assume received identifier is in ActiveRecord case.
+    def native_case(identifier)
+      case dbms.field_for(ODBC::SQL_IDENTIFIER_CASE)
+      when ODBC::SQL_IC_UPPER
+        identifier =~ /[A-Z]/ ? identifier : identifier.upcase
+      else
+        identifier
+      end
+    end
+
+    # Assume column is nullable if nullable == SQL_NULLABLE_UNKNOWN
+    def nullability(col_name, is_nullable, nullable)
+      not_nullable = (!is_nullable || nullable.to_s.match('NO') != nil)
+      result = !(not_nullable || nullable == SQL_NO_NULLS)
+
+      # HACK!
+      # MySQL native ODBC driver doesn't report nullability accurately.
+      # So force nullability of 'id' columns
+      col_name == 'id' ? false : result
+    end
+  end
+end