activerecord-fb-adapter 0.9.1 → 1.0.0

data/README.md

@@ -1,5 +1,6 @@
 # ActiveRecord Firebird Adapter
 [![Gem Version](https://badge.fury.io/rb/activerecord-fb-adapter.svg)](http://badge.fury.io/rb/activerecord-fb-adapter)
+[![Build Status](https://travis-ci.org/rowland/activerecord-fb-adapter.png?branch=master)](https://travis-ci.org/rowland/activerecord-fb-adapter)
 
 <img src="/project_logo.png" align="left" hspace="10">
 This is the ActiveRecord adapter for working with the [Firebird SQL Server](http://firebirdsql.org/). It currently supports Rails 3.2.x and 4.x. Although this adapter may not yet have feature parity with the 1st tier databases supported by Rails, it has been used in production by different people for several months without issues and may be considered stable. It uses under the hood the [Ruby Firebird Extension Library](https://github.com/rowland/fb).
@@ -30,10 +31,10 @@ gem 'activerecord-fb-adapter'
 Then run:
 
 ```
-bundle update
+bundle install
 ```
 
-which will make bundler to get the gem with it's only dependency: the Fb gem which is "native" (has C code) and will be compiled the first time. Be sure you have a Firebird installation with access to the "ibase.h" file for this to succeed.
+Bundler will install the gem and it's dependency, Fb, which is "native" (has C code) and will be compiled the first time. Be sure you have a Firebird installation with access to the "ibase.h" file for this to succeed.
 
 4) Edit the **database.yml** for configuring your database connection:
 
@@ -50,7 +51,7 @@ development:
 
 The default Firebird administrator username and password are **SYSDBA** and **masterkey**, you may have to adjust this to your installation.
 
-Currently the adapter does not supports the "rake db:create" task, so in order to create the database you must add the "create: true" option; with this switch the first time the adapter tries to connect to the database it will be created if it doesn't exists.
+With the "create: true" option, a database will be created the first time the adapter tries to connect if it doesn't exist. Alternatively, if you're using Rails 4 or greater, you can use the "rake db:create" task.
 
 5) Start the rails server in development mode
 

data/lib/active_record/connection_adapters/fb/database_statements.rb

@@ -8,16 +8,9 @@ module ActiveRecord
           exec_query(sql, name, binds).to_a.map(&:values)
         end
 
-        # Executes the SQL statement in the context of this connection.
-        def execute(sql, name = nil, skip_logging = false)
-          translate(sql) do |translated, args|
-            if (name == :skip_logging) || skip_logging
-              @connection.execute(translated, *args)
-            else
-              log(sql, args, name) do
-                @connection.execute(translated, *args)
-              end
-            end
+        def execute(sql, name = nil)
+          translate_and_log(sql, [], name) do |args|
+            @connection.execute(*args)
           end
         end
 
@@ -25,15 +18,13 @@ module ActiveRecord
         # +binds+ as the bind substitutes. +name+ is logged along with
         # the executed +sql+ statement.
         def exec_query(sql, name = 'SQL', binds = [])
-          translate(sql, binds) do |translated, args|
-            log(expand(translated, args), name) do
-              result, rows = @connection.execute(translated, *args) do |cursor|
-                [cursor.fields, cursor.fetchall]
-              end
-              next result unless result.respond_to?(:map)
-              cols = result.map { |col| col.name }
-              ActiveRecord::Result.new(cols, rows)
+          translate_and_log(sql, binds, name) do |args|
+            result, rows = @connection.execute(*args) do |cursor|
+              [cursor.fields, cursor.fetchall]
             end
+            next result unless result.respond_to?(:map)
+            cols = result.map { |col| col.name }
+            ActiveRecord::Result.new(cols, rows)
           end
         end
 
@@ -41,54 +32,38 @@ module ActiveRecord
           to_sql(arel, binds)
         end
 
-        # Checks whether there is currently no transaction active. This is done
-        # by querying the database driver, and does not use the transaction
-        # house-keeping information recorded by #increment_open_transactions and
-        # friends.
-        #
-        # Returns true if there is no transaction active, false if there is a
-        # transaction active, and nil if this information is unknown.
-        def outside_transaction?
-          !@connection.transaction_started
-        end
-
         # Begins the transaction (and turns off auto-committing).
         def begin_db_transaction
-          @connection.transaction('READ COMMITTED')
+          log('begin transaction', nil) do
+            begin_isolated_db_transaction(default_transaction_isolation)
+          end
+        end
+
+        # Default isolation levels for transactions. This method exists
+        # in 4.0.2+, so it's here for backward compatibility with AR 3
+        def transaction_isolation_levels
+          {
+            read_committed:   "READ COMMITTED",
+            repeatable_read:  "REPEATABLE READ",
+            serializable:     "SERIALIZABLE"
+          }
+        end
+
+        # Allows providing the :transaction option to ActiveRecord::Base.transaction
+        # in 4.0.2+. Can accept verbatim isolation options like 'WAIT READ COMMITTED'
+        def begin_isolated_db_transaction(isolation)
+          @connection.transaction transaction_isolation_levels.fetch(isolation, isolation)
         end
 
         # Commits the transaction (and turns on auto-committing).
         def commit_db_transaction
-          @connection.commit
+          log('commit transaction', nil) { @connection.commit }
         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
-        end
-
-        # Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
-        # fragment that has the same semantics as LIMIT and OFFSET.
-        #
-        # +options+ must be a Hash which contains a +:limit+ option
-        # and an +:offset+ option.
-        #
-        # This method *modifies* the +sql+ parameter.
-        #
-        # ===== Examples
-        #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
-        # generates
-        #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
-        def add_limit_offset!(sql, options) # :nodoc:
-          if limit = options[:limit]
-            if offset = options[:offset]
-              sql << " ROWS #{offset.to_i + 1} TO #{offset.to_i + limit.to_i}"
-            else
-              sql << " ROWS #{limit.to_i}"
-            end
-          end
-          sql
+          log('rollback transaction', nil) { @connection.rollback }
         end
 
         def default_sequence_name(table_name, _column = nil)
@@ -113,7 +88,7 @@ module ActiveRecord
         # column values as values. ActiveRecord >= 4 returns an ActiveRecord::Result.
         def select(sql, name = nil, binds = [])
           result = exec_query(sql, name, binds)
-          ActiveRecord::VERSION::MAJOR > 3 ? result : result.to_a
+          ::ActiveRecord::VERSION::MAJOR > 3 ? result : result.to_a
         end
 
         # Since the ID is prefetched and passed to #insert, this method is useless.
@@ -121,6 +96,30 @@ module ActiveRecord
         def last_inserted_id(_result)
           nil
         end
+
+        private
+
+        def translate_and_log(sql, binds = [], name = nil)
+          if ActiveRecord::VERSION::STRING < "4.2.0"
+            values = binds.map { |b| type_cast(*b.reverse) }
+          else
+            values = []
+          end
+
+          if sql =~ /(CREATE TABLE|ALTER TABLE)/
+            sql.gsub!(/(\@BINDDATE|BINDDATE\@)/m, '\'')
+          else
+            sql.gsub!(/\@BINDBINARY(.*?)BINDBINARY\@/m) do |extract|
+              values << decode(extract[11...-11]) and '?'
+            end
+
+            sql.gsub!(/\@BINDDATE(.*?)BINDDATE\@/m) do |extract|
+              values << extract[9...-9] and '?'
+            end
+          end
+
+          log(sql, name, binds) { yield [sql, *values] }
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/fb/quoting.rb

@@ -3,7 +3,6 @@ module ActiveRecord
     module Fb
       module Quoting
         def quote(value, column = nil)
-          # records are quoted as their primary key
           return value.quoted_id if value.respond_to?(:quoted_id)
           type = column && column.type
 
@@ -11,81 +10,66 @@ module ActiveRecord
           when String, ActiveSupport::Multibyte::Chars
             value = value.to_s
             if [:integer, :float].include?(type)
-              value = type == :integer ? value.to_i : value.to_f
-              value.to_s
-            elsif type && type != :binary && value.size < 256 && !value.include?('@')
-              "'#{quote_string(value)}'"
-            else
-              "@#{Base64.encode64(value).chop}@"
-            end
-          when nil                   then "NULL"
-          when true                  then quoted_true
-          when false                 then quoted_false
-          when Numeric, ActiveSupport::Duration then value.to_s
-          # BigDecimals need to be output in a non-normalized form and quoted.
-          when BigDecimal            then value.to_s('F')
-          when Symbol                then "'#{quote_string(value.to_s)}'"
-          when Class                 then "'#{value}'"
-          else
-            if value.acts_like?(:date)
-              quote_date(value)
-            elsif value.acts_like?(:time)
-              quote_timestamp(value)
+              (type == :integer ? value.to_i : value.to_f).to_s
+            elsif type && type == :binary
+              "@BINDBINARY#{Base64.encode64(value.to_s)}BINDBINARY@"
             else
-              quote_object(value)
+              "'#{quote_string(value)}'"
             end
-          end
-        end
-
-        def quote_date(value)
-          "@#{Base64.encode64(value.strftime('%Y-%m-%d')).chop}@"
-        end
-
-        def quote_timestamp(value)
-          get = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-          value = value.respond_to?(get) ? value.send(get) : value
-          "@#{Base64.encode64(value.strftime('%Y-%m-%d %H:%M:%S')).chop}@"
-        end
-
-        def quote_string(string) # :nodoc:
-          string.gsub(/'/, "''")
-        end
-
-        def quote_object(obj)
-          if obj.respond_to?(:to_str)
-            "@#{Base64.encode64(obj.to_str).chop}@"
+          when Date, Time
+            "@BINDDATE#{quoted_date(value)}BINDDATE@"
           else
-            "@#{Base64.encode64(obj.to_yaml).chop}@"
+            super
           end
-        end
+        end if ActiveRecord::VERSION::STRING < "4.2.0"
 
         def quote_column_name(column_name) # :nodoc:
-          if @connection.dialect == 1
-            %Q(#{ar_to_fb_case(column_name.to_s)})
-          else
-            %Q("#{ar_to_fb_case(column_name.to_s)}")
-          end
+          name = ar_to_fb_case(column_name.to_s).gsub('"', '')
+          @connection.dialect == 1 ? %Q(#{name}) : %Q("#{name}")
         end
 
         def quote_table_name_for_assignment(_table, attr)
           quote_column_name(attr)
         end if ::ActiveRecord::VERSION::MAJOR >= 4
 
+        def unquoted_true
+          boolean_domain[:true]
+        end
+
         def quoted_true # :nodoc:
-          quote(boolean_domain[:true])
+          quote unquoted_true
+        end
+
+        def unquoted_false
+          boolean_domain[:false]
         end
 
         def quoted_false # :nodoc:
-          quote(boolean_domain[:false])
+          quote unquoted_false
         end
 
         def type_cast(value, column)
-          return super unless value == true || value == false
-          value ? quoted_true : quoted_false
+          if [true, false].include?(value)
+            value ? quoted_true : quoted_false
+          else
+            super
+          end
         end
 
         private
 
+        # Types that are bind parameters will not be quoted
+        def _quote(value)
+          case value
+          when Type::Binary::Data
+            "@BINDBINARY#{Base64.encode64(value.to_s)}BINDBINARY@"
+          when Date, Time
+            "@BINDDATE#{quoted_date(value)}BINDDATE@"
+          else
+            super
+          end
+        end
+
         # Maps uppercase Firebird column names to lowercase for ActiveRecord;
         # mixed-case columns retain their original case.
         def fb_to_ar_case(column_name)
@@ -97,6 +81,16 @@ module ActiveRecord
         def ar_to_fb_case(column_name)
           column_name =~ /[[:upper:]]/ ? column_name : column_name.upcase
         end
+
+        if defined? Encoding
+          def decode(s)
+            Base64.decode64(s).force_encoding(@connection.encoding)
+          end
+        else
+          def decode(s)
+            Base64.decode64(s)
+          end
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/fb/schema_statements.rb

@@ -29,66 +29,69 @@ module ActiveRecord
         # Returns an array of indexes for the given table.
         def indexes(table_name, _name = nil)
           @connection.indexes.values.map { |ix|
-            if ix.table_name == table_name && ix.index_name !~ /^rdb\$/
+            if ix.table_name == table_name.to_s && ix.index_name !~ /^rdb\$/
               IndexDefinition.new(table_name, ix.index_name, ix.unique, ix.columns)
             end
           }.compact
         end
 
         def primary_key(table_name) #:nodoc:
-          sql = <<-END_SQL
+          row = @connection.query(<<-end_sql)
             SELECT s.rdb$field_name
             FROM rdb$indices i
             JOIN rdb$index_segments s ON i.rdb$index_name = s.rdb$index_name
             LEFT JOIN rdb$relation_constraints c ON i.rdb$index_name = c.rdb$index_name
-            WHERE i.rdb$relation_name = '#{ar_to_fb_case(table_name)}' and c.rdb$constraint_type = 'PRIMARY KEY';
-          END_SQL
-          row = select_one(sql)
-          row && fb_to_ar_case(row.values.first.rstrip)
+            WHERE i.rdb$relation_name = '#{ar_to_fb_case(table_name)}'
+            AND c.rdb$constraint_type = 'PRIMARY KEY';
+          end_sql
+
+          row.first && fb_to_ar_case(row.first[0].rstrip)
         end
 
         # Returns an array of Column objects for the table specified by +table_name+.
         # See the concrete implementation for details on the expected parameter values.
-        def columns(table_name, name = nil)
-          sql = <<-END_SQL
-            SELECT r.rdb$field_name, r.rdb$field_source, f.rdb$field_type, f.rdb$field_sub_type,
-                   f.rdb$field_length, f.rdb$field_precision, f.rdb$field_scale,
-                   COALESCE(r.rdb$default_source, f.rdb$default_source) rdb$default_source,
-                   COALESCE(r.rdb$null_flag, f.rdb$null_flag) rdb$null_flag
-            FROM rdb$relation_fields r
-            JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name
-            WHERE r.rdb$relation_name = '#{ar_to_fb_case(table_name)}'
-            ORDER BY r.rdb$field_position
-          END_SQL
-          select_rows(sql, name).map do |field|
-            FbColumn.new(*field.map { |value|
-              value.is_a?(String) ? value.rstrip : value
-            })
+        def columns(table_name, _name = nil)
+          column_definitions(table_name).map do |field|
+            field.symbolize_keys!.each { |k, v| v.rstrip! if v.is_a?(String) }
+            properties = field.values_at(:name, :default_source)
+            properties += column_type_for(field)
+            properties << !field[:null_flag]
+            FbColumn.new(*properties, field.slice(:domain, :sub_type))
           end
         end
 
         def create_table(name, options = {}) # :nodoc:
+          if options.key? :temporary
+            fail ActiveRecordError, 'Firebird does not support temporary tables'
+          end
+
+          if options.key? :as
+            fail ActiveRecordError, 'Firebird does not support creating tables with a select'
+          end
+
           needs_sequence = options[:id] != false
           while_ensuring_boolean_domain do
-            super(name, options) do |table_def|
+            super name, options do |table_def|
               yield table_def if block_given?
               needs_sequence ||= table_def.needs_sequence
             end
           end
+
           return if options[:sequence] == false || !needs_sequence
           create_sequence(options[:sequence] || default_sequence_name(name))
         end
 
-        # Unfortunately, this is a limitation of Firebird.
         def rename_table(name, new_name)
-          fail 'Firebird does not support renaming tables.'
+          fail ActiveRecordError, 'Firebird does not support renaming tables.'
         end
 
         def drop_table(name, options = {}) # :nodoc:
-          super(name)
-          return if options[:sequence] == false
-          sequence_name = options[:sequence] || default_sequence_name(name)
-          drop_sequence(sequence_name) if sequence_exists?(sequence_name)
+          unless options[:sequence] == false
+            sequence_name = options[:sequence] || default_sequence_name(name)
+            drop_sequence(sequence_name) if sequence_exists?(sequence_name)
+          end
+
+          super
         end
 
         # Creates a sequence
@@ -108,16 +111,29 @@ module ActiveRecord
         # Adds a new column to the named table.
         # See TableDefinition#column for details of the options you can use.
         def add_column(table_name, column_name, type, options = {})
-          add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          add_column_options!(add_column_sql, options)
-          while_ensuring_boolean_domain { execute(add_column_sql) }
+          while_ensuring_boolean_domain { super }
+
           if type == :primary_key && options[:sequence] != false
             create_sequence(options[:sequence] || default_sequence_name(table_name))
           end
+
           return unless options[:position]
           # position is 1-based but add 1 to skip id column
-          alter_position_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} POSITION #{options[:position] + 1}"
-          execute(alter_position_sql)
+          execute(squish_sql(<<-end_sql))
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER COLUMN #{quote_column_name(column_name)}
+            POSITION #{options[:position] + 1}
+          end_sql
+        end
+
+        def remove_column(table_name, column_name, type = nil, options = {})
+          indexes(table_name).each do |i|
+            if i.columns.any? { |c| c == column_name.to_s }
+              remove_index! i.table, i.name
+            end
+          end
+
+          super
         end
 
         # Changes the column's definition according to the new options.
@@ -126,10 +142,15 @@ module ActiveRecord
         #  change_column(:suppliers, :name, :string, :limit => 80)
         #  change_column(:accounts, :description, :text)
         def change_column(table_name, column_name, type, options = {})
-          sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          execute(sql)
+          type_sql = type_to_sql(type, *options.values_at(:limit, :precision, :scale))
+
+          execute(squish_sql(<<-end_sql))
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_sql}
+          end_sql
+
           change_column_null(table_name, column_name, !!options[:null]) if options.key?(:null)
-          change_column_default(table_name, column_name, options[:default]) if options[:default]
+          change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
         end
 
         # Sets a new default value for a column. If you want to set the default
@@ -139,23 +160,39 @@ module ActiveRecord
         #  change_column_default(:suppliers, :qualification, 'new')
         #  change_column_default(:accounts, :authorized, 1)
         def change_column_default(table_name, column_name, default)
-          execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}")
+          execute(squish_sql(<<-end_sql))
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER #{quote_column_name(column_name)}
+            SET DEFAULT #{quote(default)}
+          end_sql
         end
 
         def change_column_null(table_name, column_name, null, default = nil)
-          fail 'Firebird cannot change the nullability of a column using ALTER COLUMN.'
+          change_column_default(table_name, column_name, default) if default
+
+          execute(squish_sql(<<-end_sql))
+            UPDATE RDB$RELATION_FIELDS
+            SET RDB$NULL_FLAG=#{quote(null ? nil : 1)}
+            WHERE RDB$FIELD_NAME='#{ar_to_fb_case(column_name)}'
+            AND RDB$RELATION_NAME='#{ar_to_fb_case(table_name)}'
+          end_sql
         end
 
         # Renames a column.
         # ===== Example
         #  rename_column(:suppliers, :description, :name)
         def rename_column(table_name, column_name, new_column_name)
-          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+          execute(squish_sql(<<-end_sql))
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER #{quote_column_name(column_name)}
+            TO #{quote_column_name(new_column_name)}
+          end_sql
+
           rename_column_indexes(table_name, column_name, new_column_name)
         end
 
         def remove_index!(_table_name, index_name) #:nodoc:
-          execute("DROP INDEX #{quote_column_name(index_name)}")
+          execute "DROP INDEX #{quote_column_name(index_name)}"
         end
 
         def index_name(table_name, options) #:nodoc:
@@ -175,23 +212,44 @@ module ActiveRecord
         def type_to_sql(type, limit = nil, precision = nil, scale = nil)
           case type
           when :integer then integer_to_sql(limit)
-          when :float then float_to_sql(limit)
+          when :float   then float_to_sql(limit)
           else super
           end
         end
 
-        # Deprecated in Rails 4.1. Backports functionality.
-        def add_column_options!(sql, options)
-          if options_include_default?(options)
-            sql << " DEFAULT #{quote(options[:default], options[:column])}"
-          end
-          # must explicitly check for :null to allow change_column to work on migrations
-          sql << ' NOT NULL' if options[:null] == false
-        end if ActiveRecord::VERSION::MAJOR > 3
-
         private
 
-        if ActiveRecord::VERSION::MAJOR > 3
+        def column_definitions(table_name)
+          exec_query(squish_sql(<<-end_sql), 'SCHEMA')
+            SELECT
+              r.rdb$field_name name,
+              r.rdb$field_source domain,
+              f.rdb$field_type type,
+              f.rdb$field_sub_type sub_type,
+              f.rdb$field_length "limit",
+              f.rdb$field_precision "precision",
+              f.rdb$field_scale "scale",
+              COALESCE(r.rdb$default_source, f.rdb$default_source) default_source,
+              COALESCE(r.rdb$null_flag, f.rdb$null_flag) null_flag
+            FROM rdb$relation_fields r
+            JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name
+            WHERE r.rdb$relation_name = '#{ar_to_fb_case(table_name)}'
+            ORDER BY r.rdb$field_position
+          end_sql
+        end
+
+        # We need to be very precise about our sql types.
+        def column_type_for(field)
+          sql_type = FbColumn.sql_type_for(field)
+
+          if ActiveRecord::VERSION::STRING < "4.2.0"
+            [sql_type]
+          else
+            [lookup_cast_type(sql_type), sql_type]
+          end
+        end
+
+        if ::ActiveRecord::VERSION::MAJOR > 3
           def create_table_definition(*args)
             TableDefinition.new(native_database_types, *args)
           end
@@ -209,33 +267,33 @@ module ActiveRecord
           when 3..4 then 'integer'
           when 5..8 then 'bigint'
           else
-            fail ActiveRecordError, "No integer type has byte size #{limit}. Use a NUMERIC with PRECISION 0 instead."
+            fail ActiveRecordError, "No integer type has byte size #{limit}. "\
+                                    "Use a NUMERIC with PRECISION 0 instead."
           end
         end
 
         def float_to_sql(limit)
-          if limit.nil? || limit <= 4
-            'float'
-          else
-            'double precision'
-          end
+          (limit.nil? || limit <= 4) ? 'float' : 'double precision'
         end
 
         # Creates a domain for boolean fields as needed
         def while_ensuring_boolean_domain(&block)
           block.call
-        rescue ActiveRecord::StatementInvalid => e
+        rescue ActiveRecordError => e
           raise unless e.message =~ /Specified domain or source column \w+ does not exist/
           create_boolean_domain
           block.call
         end
 
+        def squish_sql(sql)
+          sql.strip.gsub(/\s+/, ' ')
+        end
+
         def create_boolean_domain
-          sql = <<-end_sql
+          execute(squish_sql(<<-end_sql))
             CREATE DOMAIN #{boolean_domain[:name]} AS #{boolean_domain[:type]}
             CHECK (VALUE IN (#{quoted_true}, #{quoted_false}) OR VALUE IS NULL)
           end_sql
-          execute(sql)
         end
 
         def sequence_exists?(sequence_name)

data/lib/active_record/connection_adapters/fb_adapter.rb

@@ -1,10 +1,18 @@
+
 # Rails 3 & 4 specific database adapter for Firebird (http://firebirdsql.org)
 # Author: Brent Rowland <rowland@rowlandresearch.com>
 # Based originally on FireRuby extension by Ken Kunz <kennethkunz@gmail.com>
 
+require 'fb'
 require 'base64'
 require 'arel'
-require 'arel/visitors/fb'
+
+if Arel::VERSION < "6.0.0"
+  require 'arel/visitors/fb'
+else
+  require 'arel/visitors/fb_collector'
+end
+
 require 'arel/visitors/bind_visitor'
 require 'active_record'
 require 'active_record/base'
@@ -125,11 +133,19 @@ module ActiveRecord
       include Fb::SchemaStatements
 
       @@boolean_domain = { :true => 1, :false => 0, :name => 'BOOLEAN', :type => 'integer' }
-      cattr_accessor :boolean_domain
+      cattr_reader :boolean_domain
+
+      def self.boolean_domain=(domain)
+        FbColumn::TRUE_VALUES << domain[:true]
+        @@boolean_domain = domain
+      end
+
+      @@default_transaction_isolation = :read_committed
+      cattr_accessor :default_transaction_isolation
 
       class BindSubstitution < Arel::Visitors::Fb # :nodoc:
         include Arel::Visitors::BindVisitor
-      end
+      end if ActiveRecord::VERSION::STRING < "4.2.0"
 
       def initialize(connection, logger, config=nil)
         super(connection, logger)
@@ -137,10 +153,6 @@ module ActiveRecord
         @visitor = Arel::Visitors::Fb.new(self)
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        Arel::Visitors::Fb.new(pool)
-      end
-
       # Returns the human-readable name of the adapter.  Use mixed case - one
       # can always use downcase if needed.
       def adapter_name
@@ -170,7 +182,11 @@ module ActiveRecord
       # CREATE TABLE or ALTER TABLE get rolled back by a transaction?  PostgreSQL,
       # SQL Server, and others support this.  MySQL and others do not.
       def supports_ddl_transactions?
-        false
+        true
+      end
+
+      def supports_transaction_isolation?
+        true
       end
 
       # Does this adapter support savepoints? FirebirdSQL does
@@ -249,31 +265,11 @@ module ActiveRecord
 
       protected
 
-      if defined?(Encoding)
-        def decode(s)
-          Base64.decode64(s).force_encoding(@connection.encoding)
-        end
-      else
-        def decode(s)
-          Base64.decode64(s)
-        end
-      end
-
-      def translate(sql, binds = [])
-        sql.gsub!(/\sIN\s+\([^\)]*\)/mi) do |m|
-          m.gsub(/\(([^\)]*)\)/m) do |n|
-            n.gsub(/\@(.*?)\@/m) do |o|
-              "'#{quote_string(decode(o[1..-1]))}'"
-            end
-          end
-        end
-        args = binds.map { |col, val| type_cast(val, col) }
-        sql.gsub!(/\@(.*?)\@/m) { |m| args << decode(m[1..-1]); '?' }
-        yield(sql, args) if block_given?
-      end
-
-      def expand(sql, args)
-        ([sql] + args) * ', '
+      # Maps SQL types to ActiveRecord 4.2+ type objects
+      def initialize_type_map(m)
+        super
+        m.register_type %r(timestamp)i, Type::DateTime.new
+        m.alias_type    %r(blob sub_type text)i, 'text'
       end
 
       def translate_exception(e, message)
@@ -282,6 +278,8 @@ module ActiveRecord
           InvalidForeignKey.new(message, e)
         when /violation of PRIMARY or UNIQUE KEY constraint/, /attempt to store duplicate value/
           RecordNotUnique.new(message, e)
+        when /This operation is not defined for system tables/
+          ActiveRecordError.new(message)
         else
           super
         end

data/lib/active_record/connection_adapters/fb_column.rb

@@ -1,72 +1,56 @@
 module ActiveRecord
   module ConnectionAdapters
     class FbColumn < Column # :nodoc:
-      def initialize(name, domain, type, sub_type, length, precision, scale, default_source, null_flag)
-        @firebird_type = ::Fb::SqlType.from_code(type, sub_type || 0)
-        super(name.downcase, nil, @firebird_type, !null_flag)
-        @default = parse_default(default_source) if default_source
-        case @firebird_type
-        when 'VARCHAR', 'CHAR'
-          @limit = length
-        when 'DECIMAL', 'NUMERIC'
-          @precision, @scale = precision, scale.abs
-        end
-        @domain, @sub_type = domain, sub_type
-      end
+      class << self
+        delegate :boolean_domain, to: 'ActiveRecord::ConnectionAdapters::FbAdapter'
 
-      def type
-        if @domain =~ /BOOLEAN/
-          :boolean
-        elsif @type == :binary and @sub_type == 1
-          :text
-        else
-          @type
-        end
-      end
+        # When detecting types, ActiveRecord expects strings in a certain format.
+        # In 4.2, these strings are converted to ActiveRecord::Type::Value objects
+        # using the type_map (see #initialize_type_map). Prior to 4.2, the sql_type
+        # could be coerced to a certain ActiveRecord type in Column#simplified_type.
+        def sql_type_for(field)
+          type, sub_type, domain = field.values_at(:type, :sub_type, :domain)
+          sql_type = ::Fb::SqlType.from_code(type, sub_type || 0).downcase
 
-      # Submits a _CAST_ query to the database, casting the default value to the specified SQL type.
-      # This enables Firebird to provide an actual value when context variables are used as column
-      # defaults (such as CURRENT_TIMESTAMP).
-      def default
-        if @default
-          sql = "SELECT CAST(#{@default} AS #{column_def}) FROM RDB$DATABASE"
-          connection = ActiveRecord::Base.connection
-          if connection
-            value = connection.raw_connection.query(:hash, sql)[0]['cast']
-            return nil if value.acts_like?(:date) || value.acts_like?(:time)
-            type_cast(value)
-          else
-            raise ConnectionNotEstablished, "No Firebird connections established."
+          case sql_type
+          when /(numeric|decimal)/
+            sql_type << "(#{field[:precision]},#{field[:scale].abs})"
+          when /(int|float|double|char|varchar)/
+            sql_type << "(#{field[:limit]})"
           end
+
+          sql_type << ' sub_type text' if sql_type =~ /blob/ && sub_type == 1
+          sql_type = 'boolean' if domain =~ %r(#{boolean_domain[:name]})i
+          sql_type
         end
       end
 
-      def self.value_to_boolean(value)
-        %W(#{FbAdapter.boolean_domain[:true]} true t 1).include? value.to_s.downcase
+      attr_reader :sub_type, :domain
+
+      if ActiveRecord::VERSION::STRING < "4.2.0"
+        def initialize(name, default, sql_type = nil, null = true, fb_options = {})
+          @domain, @sub_type = fb_options.values_at(:domain, :sub_type)
+          super(name.downcase, parse_default(default), sql_type, null)
+        end
+      else
+        def initialize(name, default, cast_type, sql_type = nil, null = true, fb_options = {})
+          @domain, @sub_type = fb_options.values_at(:domain, :sub_type)
+          super(name.downcase, parse_default(default), cast_type, sql_type, null)
+        end
       end
 
       private
 
-      def parse_default(default_source)
-        default_source =~ /^\s*DEFAULT\s+(.*)\s*$/i
-        return $1 unless $1.upcase == "NULL"
-      end
-
-      def column_def
-        case @firebird_type
-        when 'CHAR', 'VARCHAR'    then "#{@firebird_type}(#{@limit})"
-        when 'NUMERIC', 'DECIMAL' then "#{@firebird_type}(#{@precision},#{@scale.abs})"
-        #when 'DOUBLE'             then "DOUBLE PRECISION"
-        else @firebird_type
-        end
+      def parse_default(default)
+        return if default.nil? || default =~ /null/i
+        default.gsub(/^\s*DEFAULT\s+/i, '').gsub(/(^'|'$)/, '')
       end
 
+      # Type conversion prior to 4.2
       def simplified_type(field_type)
-        if field_type == 'TIMESTAMP'
-          :datetime
-        else
-          super
-        end
+        return :datetime if field_type =~ /timestamp/
+        return :text if field_type =~ /blob sub_type text/
+        super
       end
     end
   end

data/lib/active_record/fb_base.rb

@@ -18,7 +18,7 @@ module ActiveRecord
     end
 
     def self.fb_connection_config(config)
-      config = config.symbolize_keys.reverse_merge(:downcase_names => true, :port => 3050)
+      config = config.symbolize_keys.dup.reverse_merge(:downcase_names => true, :port => 3050)
       fail ArgumentError, 'No database specified. Missing argument: database.' if !config[:database]
       if config[:host].nil? || config[:host] =~ /localhost/i
         config[:database] = File.expand_path(config[:database], defined?(Rails) && Rails.root)

data/lib/active_record/tasks/fb_database_tasks.rb

@@ -0,0 +1,75 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class FbDatabaseTasks # :nodoc:
+      delegate :fb_connection_config, :establish_connection, to: ::ActiveRecord::Base
+
+      def initialize(configuration, root = ::ActiveRecord::Tasks::DatabaseTasks.root)
+        @root, @configuration = root, fb_connection_config(configuration)
+      end
+
+      def create
+        fb_database.create
+        establish_connection configuration
+      rescue ::Fb::Error => e
+        raise unless e.message.include?('database or file exists')
+        raise DatabaseAlreadyExists
+      end
+
+      def drop
+        fb_database.drop
+      rescue ::Fb::Error => e
+        raise ::ActiveRecord::ConnectionNotEstablished, e.message
+      end
+
+      def purge
+        drop
+        create
+      end
+
+      def structure_dump(filename)
+        isql :extract, output: filename
+      end
+
+      def structure_load(filename)
+        isql input: filename
+      end
+
+      private
+
+      def fb_database
+        ::Fb::Database.new(configuration)
+      end
+
+      # Executes isql commands to load/dump the schema.
+      # The generated command might look like this:
+      #   isql db/development.fdb -user SYSDBA -password masterkey -extract
+      def isql(*args)
+        opts = args.extract_options!
+        user, pass = configuration.values_at(:username, :password)
+        user ||= configuration[:user]
+        opts.reverse_merge!(user: user, password: pass)
+        cmd = [isql_executable, configuration[:database]]
+        cmd += opts.map { |name, val| "-#{name} #{val}" }
+        cmd += args.map { |flag| "-#{flag}" }
+        cmd = cmd.join(' ')
+        raise "Error running: #{cmd}" unless Kernel.system(cmd)
+      end
+
+      # Finds the isql command line utility from the PATH
+      # Many linux distros call this program isql-fb, instead of isql
+      def isql_executable
+        require 'mkmf'
+        exe = ['isql-fb', 'isql'].detect { |c| find_executable0(c) }
+        exe || abort("Unable to find isql or isql-fb in your $PATH")
+      end
+
+      def configuration
+        @configuration
+      end
+
+      def root
+        @root
+      end
+    end
+  end
+end

data/lib/activerecord-fb-adapter.rb

@@ -0,0 +1,14 @@
+require 'active_record/connection_adapters/fb_adapter'
+
+module ActiveRecordFbAdapter
+
+  if defined?(::Rails::Railtie) && ::ActiveRecord::VERSION::MAJOR > 3
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load 'active_record/tasks/fb_database_tasks.rb'
+        ActiveRecord::Tasks::DatabaseTasks.register_task /fb/, ActiveRecord::Tasks::FbDatabaseTasks
+      end
+    end
+  end
+
+end

data/lib/arel/visitors/fb_collector.rb

@@ -0,0 +1,96 @@
+module Arel
+  module Visitors
+    class Fb < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_SelectStatement o, collector
+        collector << "SELECT "
+        collector = visit o.offset, collector if o.offset && !o.limit
+
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        }
+
+        unless o.orders.empty?
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index { |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          }
+        end
+
+        if o.limit && o.offset
+          collector = limit_with_rows o, collector
+        elsif o.limit && !o.offset
+          collector = visit o.limit, collector
+        end
+
+        collector = maybe_visit o.lock, collector
+        collector
+      end
+
+      def visit_Arel_Nodes_SelectCore o, collector
+        if o.set_quantifier
+          collector = visit o.set_quantifier, collector
+          collector << SPACE
+        end
+
+        unless o.projections.empty?
+          len = o.projections.length - 1
+          o.projections.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          end
+        end
+
+        if o.source && !o.source.empty?
+          collector << " FROM "
+          collector = visit o.source, collector
+        end
+
+        unless o.wheres.empty?
+          collector << WHERE
+          len = o.wheres.length - 1
+          o.wheres.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << AND unless len == i
+          end
+        end
+
+        unless o.groups.empty?
+          collector << GROUP_BY
+          len = o.groups.length - 1
+          o.groups.each_with_index do |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          end
+        end
+
+        collector = maybe_visit o.having, collector
+        collector
+      end
+
+      def visit_Arel_Nodes_Limit o, collector
+        collector << " ROWS "
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_Offset o, collector
+        collector << " SKIP "
+        visit o.expr, collector
+        collector << SPACE
+      end
+
+      # Firebird helper
+      def limit_with_rows o, collector
+        collector << " ROWS "
+        visit o.offset.expr + 1, collector
+        collector << " TO "
+        visit o.offset.expr + o.limit.expr.expr, collector
+      end
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['fb'] = Arel::Visitors::Fb

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-fb-adapter
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 1.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Brent Rowland
@@ -13,31 +14,99 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: fb
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.7.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.7.4
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-spec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: rowland@rowlandresearch.com
 executables: []
@@ -53,30 +122,34 @@ files:
 - lib/active_record/connection_adapters/fb_adapter.rb
 - lib/active_record/connection_adapters/fb_column.rb
 - lib/active_record/fb_base.rb
+- lib/active_record/tasks/fb_database_tasks.rb
+- lib/activerecord-fb-adapter.rb
 - lib/arel/visitors/fb.rb
+- lib/arel/visitors/fb_collector.rb
 homepage: http://github.com/rowland/activerecord-fb-adapter
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
 - Firebird library fb
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: ActiveRecord Firebird Adapter for Rails 3 and 4 with support for migrations.
 test_files: []

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: fd91257c22642692e91cfd7a15de3bc0684d3148
-  data.tar.gz: 28371fa7615afc66fcbf322ea08b77810390fe05
-SHA512:
-  metadata.gz: 76431db22cf5caf52185ab189ab48295dcbe62e8bba1863ecb21c7213c5ab228d78c87b19a10d3f872741e2247ab40ef3130404db3bb0b8c93acdcdc9083a2ca
-  data.tar.gz: 732da63410df05ae6416c6f38d7c4e3ff322a0b5a49a66cd61930db5a4ec2835508c26c081477c48b962e96daf2bd76e423d82524aade7d3f404ee012a65250f