activerecord-rdb-adapter 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eae56962a83ba7f51da156eb041ef6b9961e450d29088e2481b3085c4913d1b8
+  data.tar.gz: 38fcc781c4852ef2dd1897d0affebaac9006e038dbb90a67efe4ba9995a4e408
+SHA512:
+  metadata.gz: 1f68f8293992979c5f6168746cabed86d7c68290424aa566134db01e40cf3ec9097e53628c05bf71906197ebaeb4f6dec9271a062ba6e9d6b4b6050e00ebd064
+  data.tar.gz: c5dc9601b8205894ca3f668f25848643a69b79093b2069d87d9a60e2d80eb889f77e00b465e797ee765fea0d77b8c5eeb5746776017ca0a5d432c153f6b94890

data/README.md

@@ -0,0 +1,3 @@
+ActiveRecord adapter that allows you to use ActiveRecord 5+(Rails 5.2 is recommended) with [RedDatabase 3+](http://reddatabase.ru/) and Firebird 3
+
+inspired by https://github.com/rowland/activerecord-fb-adapter and https://github.com/FabioMR/firebird_adapter

data/lib/active_record/connection_adapters/rdb/database_limits.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      module DatabaseLimits # :nodoc:
+        def table_alias_length
+          31
+        end
+
+        def column_name_length
+          31
+        end
+
+        def table_name_length
+          31
+        end
+
+        def index_name_length
+          31
+        end
+
+        def indexes_per_table
+          65_535
+        end
+
+        def in_clause_length
+          1_499
+        end
+
+        def sql_query_length
+          32_767
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      module DatabaseStatements # :nodoc:
+        def execute(sql, name = nil)
+          log(sql, name) do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              @connection.query(sql)
+            end
+          end
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          type_casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, type_casted_binds) do
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              result = @connection.execute(sql, *type_casted_binds)
+              if result.is_a?(Fb::Cursor)
+                fields = result.fields.map(&:name)
+                rows = result.fetchall.map do |row|
+                  row.map do |col|
+                    col.encode('UTF-8', @connection.encoding)
+                  rescue StandardError
+                    col
+                  end
+                end
+                result.close
+                ActiveRecord::Result.new(fields, rows)
+              else
+                result
+              end
+            end
+          end
+        rescue StandardError => e
+          raise e.message.encode('UTF-8', @connection.encoding)
+        end
+
+        def explain(arel, binds = [])
+          to_sql(arel, binds)
+        end
+
+        # Begins the transaction (and turns off auto-committing).
+        def begin_db_transaction
+          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
+          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
+          log('rollback transaction', nil) { @connection.rollback }
+        end
+
+        def default_sequence_name(table_name, _column = nil)
+          "#{table_name.to_s.tr('-', '_')[0, table_name_length - 4]}_seq"
+        end
+
+        # Set the sequence to the max value of the table's column.
+        def reset_sequence!(table, column, sequence = nil)
+          sequence ||= default_sequence_name(table, column)
+          max_id = select_value("select max(#{column}) from #{table}")
+          execute("alter sequence #{sequence} restart with #{max_id}")
+        end
+
+        # Uses the raw connection to get the next sequence value.
+        def next_sequence_value(sequence_name)
+          @connection.query("SELECT NEXT VALUE FOR #{sequence_name} FROM RDB$DATABASE")[0][0]
+        end
+
+        def last_inserted_id(_result)
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      module Quoting # :nodoc:
+        QUOTED_FALSE = "'false'".freeze
+        QUOTED_TRUE = "'true'".freeze
+
+        QUOTED_POSITION = '"POSITION"'.freeze
+        QUOTED_VALUE = '"VALUE"'.freeze
+
+        def quote_string(string) # :nodoc:
+          string.gsub(/'/, "''")
+        end
+
+        def quoted_date(time)
+          if time.is_a?(Time) || time.is_a?(DateTime)
+            time.localtime.strftime('%d.%m.%Y %H:%M:%S')
+          else
+            time.strftime('%d.%m.%Y')
+          end
+        end
+
+        def quote_column_name(column_name) # :nodoc:
+          column = column_name.dup.to_s
+          column.gsub!(/(?<=[^\"\w]|^)position(?=[^\"\w]|$)/i, QUOTED_POSITION)
+          column.gsub!(/(?<=[^\"\w]|^)value(?=[^\"\w]|$)/i, QUOTED_VALUE)
+          column.delete!('"')
+          column.upcase!
+          @connection.dialect == 1 ? column.to_s : %("#{column}")
+        end
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        end
+
+        def unquoted_true
+          true
+        end
+
+        def quoted_true # :nodoc:
+          QUOTED_TRUE
+        end
+
+        def unquoted_false
+          false
+        end
+
+        def quoted_false # :nodoc:
+          QUOTED_FALSE
+        end
+
+        def type_cast_from_column(column, value) # :nodoc:
+          if column
+            type = column.type || lookup_cast_type_from_column(column)
+            type.serialize(value)
+          else
+            value
+          end
+        end
+
+        def lookup_cast_type_from_column(column) # :nodoc:
+          type = column.try(:sql_type) || column.try(:type)
+          lookup_cast_type(type)
+        end
+
+        def type_casted_binds(binds) # :nodoc:
+          if binds.first.is_a?(Array)
+            binds.map { |column, value| type_cast(value, column) }
+          else
+            binds.map { |attr| type_cast(attr.value_for_database, attr) }
+          end
+        end
+
+        private
+
+        def id_value_for_database(value)
+          if primary_key = value.class.primary_key
+            value.instance_variable_get(:@attributes)[primary_key].value_for_database
+          end
+        end
+
+        def _quote(value)
+          case value
+          when Time, DateTime
+            "'#{value.strftime('%d.%m.%Y %H:%M')}'"
+          when Date
+            "'#{value.strftime('%d.%m.%Y')}'"
+          else
+            super
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+            value.to_s
+          when Array
+            value.to_yaml
+          when Hash then
+            encode_hash(value)
+          when true then
+            unquoted_true
+          when false then
+            unquoted_false
+            # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then
+            value.to_s('F')
+          when Type::Time::Value then
+            quoted_time(value)
+          when Date, Time, DateTime then
+            quoted_date(value)
+          when *types_which_need_no_typecasting
+            value
+          else
+            raise TypeError
+          end
+        end
+
+        def rdb_to_ar_case(column_name)
+          /[[:lower:]]/.match?(column_name) ? column_name : column_name.downcase
+        end
+
+        def ar_to_rdb_case(column_name)
+          /[[:upper:]]/.match?(column_name) ? column_name : column_name.upcase
+        end
+
+        def encode_hash(value)
+          if value.is_a?(Hash)
+            value.to_yaml
+          else
+            value
+          end
+        end
+
+        if defined? Encoding
+          def decode(str)
+            Base64.decode64(str).force_encoding(@connection.encoding)
+          end
+        else
+          def decode(str)
+            Base64.decode64(str)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb/schema_creation.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+
+        private
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, o.options)
+          column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+          column_sql
+        end
+
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          # must explicitly check for :null to allow change_column to work on migrations
+          if !options[:null]
+            sql << " NOT NULL"
+          end
+          if options[:auto_increment]
+            sql << " AUTO_INCREMENT"
+          end
+          if options[:primary_key]
+            sql << " PRIMARY KEY"
+          end
+          sql
+        end
+
+        def visit_TableDefinition(o)
+          create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+
+          statements = o.columns.map(&method(:accept))
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+          end
+
+          if supports_foreign_keys_in_create?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+          end
+
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, table_options(o))
+          create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+          create_sql
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb/schema_dumper.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+
+        def column_spec_for_primary_key(column)
+          spec = super
+          spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+          spec
+        end
+
+        def schema_type(column)
+          if column.bigint?
+            :bigint
+          else
+            column.type.type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,425 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      module SchemaStatements # :nodoc:
+        methods_to_commit = %i[add_column
+                               create_table
+                               rename_column
+                               remove_column
+                               change_column
+                               change_column_default
+                               change_column_null
+                               remove_index
+                               remove_index!
+                               drop_table
+                               create_sequence
+                               drop_sequence
+                               drop_trigger]
+
+        def tables(_name = nil)
+          @connection.table_names
+        end
+
+        def views
+          @connection.view_names
+        end
+
+        def indexes(table_name, _name = nil)
+          @connection.indexes.values.map do |ix|
+            IndexDefinition.new(table_name, ix.index_name, ix.unique, ix.columns) if ix.table_name == table_name.to_s && ix.index_name !~ /^rdb\$/
+          end.compact
+        end
+
+        def index_name_exists?(table_name, index_name)
+          index_name = index_name.to_s.upcase
+          indexes(table_name).detect { |i| i.name.upcase == index_name }
+        end
+
+        def columns(table_name, _name = nil)
+          @col_definitions ||= {}
+          @col_definitions[table_name] = column_definitions(table_name).map do |field|
+            sql_type_metadata = column_type_for(field)
+            rdb_opt = { domain: field[:domain], sub_type: field[:sql_subtype] }
+            RdbColumn.new(field[:name], field[:default], sql_type_metadata, field[:nullable], table_name, rdb_opt)
+          end
+        end
+
+        def create_table(name, options = {}) # :nodoc:
+          raise ActiveRecordError, 'Firebird does not support temporary tables' if options.key? :temporary
+
+          raise ActiveRecordError, 'Firebird does not support creating tables with a select' if options.key? :as
+
+          drop_table name, if_exists: true if options.key? :force
+
+          needs_sequence = options[:id]
+
+          super name, options do |table_def|
+            yield table_def if block_given?
+            needs_sequence ||= table_def.needs_sequence
+          end
+
+          return if options[:sequence] == false || !needs_sequence
+          create_sequence(options[:sequence] || default_sequence_name(name))
+          trg_sql = <<-END_SQL
+            CREATE TRIGGER N$#{name.upcase} FOR #{name.upcase}
+            ACTIVE BEFORE INSERT
+            AS
+            declare variable gen_val bigint;
+            BEGIN
+              if (new.ID is null) then
+                new.ID = next value for #{options[:sequence] || default_sequence_name(name)};
+              else begin
+                gen_val = gen_id(#{options[:sequence] || default_sequence_name(name)}, 1);
+                if (new.ID > gen_val) then
+                  gen_val = gen_id(#{options[:sequence] || default_sequence_name(name)}, new.ID - gen_val);
+              end
+            END
+          END_SQL
+          execute(trg_sql)
+        end
+
+        def drop_table(name, options = {}) # :nodoc:
+          drop_sql = "DROP TABLE #{quote_table_name(name)}"
+          if options[:if_exists]
+            drop = !execute(squish_sql(<<-END_SQL))
+            select 1 from rdb$relations where rdb$relation_name = #{quote_table_name(name).tr('"', '\'')}
+            END_SQL
+                   .empty?
+          end
+
+          trigger_name = "N$#{name.upcase}"
+          drop_trigger(trigger_name) if trigger_exists?(trigger_name)
+
+          sequence_name = options[:sequence] || default_sequence_name(name)
+          drop_sequence(sequence_name) if sequence_exists?(sequence_name)
+
+          execute(drop_sql) if drop
+        end
+
+        def create_sequence(sequence_name)
+          execute("CREATE SEQUENCE #{sequence_name}")
+        rescue StandardError
+          nil
+        end
+
+        def drop_sequence(sequence_name)
+          execute("DROP SEQUENCE #{sequence_name}")
+        rescue StandardError
+          nil
+        end
+
+        def drop_trigger(trigger_name)
+          execute("DROP TRIGGER #{trigger_name}")
+        rescue StandardError
+          nil
+        end
+
+        def trigger_exists?(trigger_name)
+          !execute(squish_sql(<<-END_SQL))
+            select 1
+            from rdb$triggers
+             where rdb$trigger_name = '#{trigger_name}'
+          END_SQL
+            .empty?
+        end
+
+        def add_column(table_name, column_name, type, options = {})
+          super
+
+          create_sequence(options[:sequence] || default_sequence_name(table_name)) if type == :primary_key && options[:sequence] != false
+
+          return unless options[:position]
+          # position is 1-based but add 1 to skip id column
+          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|
+            remove_index! i.table, i.name if i.columns.any? { |c| c == column_name.to_s }
+          end
+
+          column_exist = !execute(squish_sql(<<-END_SQL))
+          select 1 from RDB$RELATION_FIELDS rf
+            where lower(rf.RDB$RELATION_NAME) = '#{table_name.downcase}' and lower(rf.RDB$FIELD_NAME) = '#{column_name.downcase}'
+          END_SQL
+                         .empty?
+          super if column_exist
+        end
+
+        def remove_column_for_alter(_table_name, column_name, _type = nil, _options = {})
+          "DROP #{quote_column_name(column_name)}"
+        end
+
+        def change_column(table_name, column_name, type, options = {})
+          type_sql = type_to_sql(type, *options.values_at(:limit, :precision, :scale))
+
+          if %i[text string].include?(type)
+            copy_column = 'c_temp'
+            add_column table_name, copy_column, type, options
+            execute(squish_sql(<<-END_SQL))
+            UPDATE #{table_name} SET #{copy_column.quote_column_name} = #{column_name.to_s.quote_column_name};
+            END_SQL
+            remove_column table_name, column_name
+            rename_column table_name, copy_column, column_name
+          else
+            execute(squish_sql(<<-END_SQL))
+            ALTER TABLE #{quote_table_name(table_name)}
+            ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_sql}
+            END_SQL
+          end
+          change_column_null(table_name, column_name, !!options[:null]) if options.key?(:null)
+          change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
+        end
+
+        def change_column_default(table_name, column_name, 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)
+          change_column_default(table_name, column_name, default) if default
+
+          db_column = columns(table_name).find { |c| c.name == column_name.to_s }
+          options = { null: null }
+          options[:default] = db_column.default if !default && db_column.default
+          options[:default] = default if default
+          ar_type = db_column.type
+          type = type_to_sql(ar_type.type, ar_type.limit, ar_type.precision, ar_type.scale)
+
+          copy_column = 'c_temp'
+          add_column table_name, copy_column, type, options
+          execute(squish_sql(<<-END_SQL))
+            UPDATE #{table_name} SET #{copy_column.quote_column_name} = #{column_name.to_s.quote_column_name};
+          END_SQL
+          remove_column table_name, column_name
+          rename_column table_name, copy_column, column_name
+        end
+
+        def rename_column(table_name, 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)
+          execute "DROP INDEX #{quote_column_name(index_name)}"
+        end
+
+        def remove_index(table_name, options = {})
+          index_name = index_name(table_name, options)
+          execute "DROP INDEX #{quote_column_name(index_name)}"
+        end
+
+        def index_name(table_name, options) #:nodoc:
+          if options.respond_to?(:keys) # legacy support
+            if options[:column]
+              index_name = "#{table_name}_#{Array.wrap(options[:column]) * '_'}"
+              if index_name.length > 31
+                "IDX_#{Digest::SHA256.hexdigest(index_name)[0..22]}"
+              else
+                index_name
+              end
+            elsif options[:name]
+              options[:name]
+            else
+              raise ArgumentError 'You must specify the index name'
+            end
+          else
+            index_name(table_name, column: options)
+          end
+        end
+
+        def index_exists?(table_name, column_name, options = {})
+          column_names = Array(column_name).map(&:to_s)
+          checks = []
+          checks << lambda { |i| i.columns == column_names }
+          checks << lambda(&:unique) if options[:unique]
+          checks << lambda { |i| i.name.upcase == options[:name].to_s.upcase } if options[:name]
+
+          indexes(table_name).any? { |i| checks.all? { |check| check[i] } }
+        end
+
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil, **args)
+          if !args.nil? && !args.empty?
+            limit = args[:limit] if limit.nil?
+            precision = args[:precision] if precision.nil?
+            scale = args[:scale] if scale.nil?
+          end
+          case type
+          when :integer
+            integer_to_sql(limit)
+          when :float
+            float_to_sql(limit)
+          when :text
+            text_to_sql(limit)
+          # when :blob
+          #   binary_to_sql(limit)
+          when :string
+            string_to_sql(limit)
+          else
+            type = type.to_sym if type
+            if native = native_database_types[type]
+              column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
+
+              if type == :decimal # ignore limit, use precision and scale
+                scale ||= native[:scale]
+
+                if precision ||= native[:precision]
+                  column_type_sql << if scale
+                                       "(#{precision},#{scale})"
+                                     else
+                                       "(#{precision})"
+                                     end
+                elsif scale
+                  raise ArgumentError, 'Error adding decimal column: precision cannot be empty if scale is specified'
+                end
+
+              elsif %i[datetime timestamp time interval].include?(type) && precision ||= native[:precision]
+                if (0..6) === precision
+                  column_type_sql << "(#{precision})"
+                else
+                  raise(ActiveRecordError, "No #{native[:name]} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+                end
+              elsif (type != :primary_key) && (limit ||= native.is_a?(Hash) && native[:limit])
+                column_type_sql << "(#{limit})"
+              end
+
+              column_type_sql
+            else
+              type.to_s
+            end
+          end
+        end
+
+        def primary_key(table_name)
+          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_rdb_case(table_name)}'
+            AND c.rdb$constraint_type = 'PRIMARY KEY';
+          END_SQL
+
+          row.first && rdb_to_ar_case(row.first[0].rstrip)
+        end
+
+        def native_database_types
+          @native_database_types ||= initialize_native_database_types.freeze
+        end
+
+        def create_schema_dumper(options)
+          Rdb::SchemaDumper.create(self, options)
+        end
+
+        private
+
+        def column_definitions(table_name)
+          @connection.columns(table_name)
+        end
+
+        def new_column_from_field(table_name, field)
+          type_metadata = fetch_type_metadata(field['sql_type'])
+          ActiveRecord::ConnectionAdapters::Column.new(field['name'], field['default'], type_metadata, field['nullable'], table_name)
+        end
+
+        def column_type_for(field)
+          sql_type = RdbColumn.sql_type_for(field)
+          type = lookup_cast_type(sql_type)
+          { type: type, sql_type: type.type }
+        end
+
+        def integer_to_sql(limit)
+          return 'integer' if limit.nil?
+          case limit
+          when 1..2 then
+            'smallint'
+          when 3..4 then
+            'integer'
+          when 5..8 then
+            'bigint'
+          else
+            raise ActiveRecordError "No integer type has byte size #{limit}. " \
+                                    'Use a NUMERIC with PRECISION 0 instead.'
+          end
+        end
+
+        def float_to_sql(limit)
+          limit.nil? || limit <= 4 ? 'float' : 'double precision'
+        end
+
+        def text_to_sql(limit)
+          if limit && limit > 0
+            "VARCHAR(#{limit})"
+          else
+            'BLOB SUB_TYPE TEXT'
+          end
+        end
+
+        def string_to_sql(limit)
+          if limit && limit > 0
+            "VARCHAR(#{limit})"
+          else
+            'VARCHAR(150)'
+          end
+        end
+
+        def initialize_native_database_types
+          { primary_key: 'integer not null primary key',
+            string: { name: 'varchar', limit: 255 },
+            text: { name: 'blob sub_type text' },
+            integer: { name: 'integer' },
+            bigint: { name: 'bigint' },
+            float: { name: 'float' },
+            decimal: { name: 'decimal' },
+            datetime: { name: 'timestamp' },
+            timestamp: { name: 'timestamp' },
+            time: { name: 'time' },
+            date: { name: 'date' },
+            binary: { name: 'blob' },
+            boolean: { name: 'boolean' } }
+        end
+
+        def sequence_exists?(sequence_name)
+          @connection.generator_names.include?(sequence_name)
+        end
+
+        def create_table_definition(*args)
+          Rdb::TableDefinition.new(*args)
+        end
+
+        def squish_sql(sql)
+          sql.strip.gsub(/\s+/, ' ')
+        end
+
+        class << self
+          def after(*names)
+            names.flatten.each do |name|
+              m = ActiveRecord::ConnectionAdapters::Rdb::SchemaStatements.instance_method(name)
+              define_method(name) do |*args, &block|
+                m.bind(self).call(*args, &block)
+                yield
+                commit_db_transaction
+              end
+            end
+          end
+        end
+
+        after(methods_to_commit) do
+          puts 'Commiting transaction'
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb/table_definition.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Rdb
+      module ColumnMethods # :nodoc:
+
+        attr_accessor :needs_sequence
+
+        def primary_key(name, type = :primary_key, **options)
+          self.needs_sequence = true
+          super
+        end
+
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition # :nodoc:
+        include ColumnMethods
+
+        def new_column_definition(name, type, **options)
+          super
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table # :nodoc:
+        include ColumnMethods
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb_adapter.rb

@@ -0,0 +1,152 @@
+require 'fb'
+require 'base64'
+require 'arel'
+require 'arel/visitors/rdb_visitor'
+
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/rdb/database_statements'
+require 'active_record/connection_adapters/rdb/database_limits'
+require 'active_record/connection_adapters/rdb/schema_creation'
+require 'active_record/connection_adapters/rdb/schema_dumper'
+require 'active_record/connection_adapters/rdb/schema_statements'
+require 'active_record/connection_adapters/rdb/quoting'
+require 'active_record/connection_adapters/rdb/table_definition'
+require 'active_record/connection_adapters/rdb_column'
+require 'active_record/rdb_base'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class RdbAdapter < AbstractAdapter # :nodoc:
+      include Rdb::DatabaseLimits
+      include Rdb::DatabaseStatements
+      include Rdb::Quoting
+      include Rdb::SchemaStatements
+
+      @@default_transaction_isolation = :read_committed
+      cattr_accessor :default_transaction_isolation
+
+      ADAPTER_NAME = 'rdb'.freeze
+
+      def initialize(connection, logger = nil, config = {})
+        super(connection, logger, config)
+        # Our Responsibility
+        @config = config
+        @visitor = Arel::Visitors::Rdb.new self
+      end
+
+      def arel_visitor
+        Arel::Visitors::Rdb.new self
+      end
+
+      def valid_type?(type)
+        !native_database_types[type].nil? || !native_database_types[type.type].nil?
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def schema_creation
+        Rdb::SchemaCreation.new self
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def supports_count_distinct?
+        true
+      end
+
+      def supports_ddl_transactions?
+        true
+      end
+
+      def supports_transaction_isolation?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def prefetch_primary_key?(_table_name = nil)
+        true
+      end
+
+      def ids_in_list_limit
+        1499
+      end
+
+      def active?
+        return false unless @connection.open?
+        # return true if @connection.transaction_started
+        @connection.query('SELECT 1 FROM RDB$DATABASE')
+        true
+      rescue StandardError
+        false
+      end
+
+      def reconnect!
+        disconnect!
+        @connection = ::Fb::Database.connect(@config)
+      end
+
+      def disconnect!
+        super
+        begin
+          @connection.close
+        rescue StandardError
+          nil
+        end
+      end
+
+      def reset!
+        reconnect!
+      end
+
+      def requires_reloading?
+        false
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        execute("SAVEPOINT #{name}")
+      end
+
+      def rollback_to_savepoint(name = current_savepoint_name)
+        execute("ROLLBACK TO SAVEPOINT #{name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        execute("RELEASE SAVEPOINT #{name}")
+      end
+
+      protected
+
+      def initialize_type_map(map)
+        super
+        map.register_type(/timestamp/i, Type::DateTime.new)
+        map.alias_type(/blob sub_type text/i, 'text')
+      end
+
+      def translate_exception(e, message)
+        case e.message
+        when /violation of FOREIGN KEY constraint/
+          ActiveRecord::InvalidForeignKey.new(message)
+        when /violation of PRIMARY or UNIQUE KEY constraint/, /attempt to store duplicate value/
+          ActiveRecord::RecordNotUnique.new(message)
+        when /This operation is not defined for system tables/
+          ActiveRecord::ActiveRecordError.new(message)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb_column.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class RdbColumn < Column # :nodoc:
+      class << self
+        def sql_type_for(field)
+          sql_type = field[:sql_type]
+          sub_type = field[:sql_subtype]
+
+          sql_type << case sql_type
+                      when /(numeric|decimal)/i
+                        "(#{field[:precision]},#{field[:scale].abs})"
+                      when /(int|float|double|char|varchar|bigint)/i
+                        "(#{field[:length]})"
+                      else
+                        ''
+                      end
+
+          sql_type << ' sub_type text' if /blob/i.match?(sql_type) && sub_type == 1
+          sql_type
+        end
+      end
+
+      attr_reader :sub_type, :domain
+
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, rdb_options = {})
+        @domain, @sub_type = rdb_options.values_at(:domain, :sub_type)
+        name = name.dup
+        name.downcase!
+        super(name, parse_default(default), sql_type_metadata, null, table_name)
+      end
+
+      def sql_type
+        @sql_type_metadata[:sql_type]
+      end
+
+      def type
+        @sql_type_metadata[:type]
+      end
+
+      def precision
+        @sql_type_metadata[:precision]
+      end
+
+      def scale
+        @sql_type_metadata[:scale]
+      end
+
+      def limit
+        @sql_type_metadata[:limit]
+      end
+
+      private
+
+      def parse_default(default)
+        return if default.nil? || /null/i.match?(default)
+        d = default.dup
+        d.gsub!(/^\s*DEFAULT\s+/i, '')
+        d.gsub!(/(^'|'$)/, '')
+        d
+      end
+
+      def simplified_type(field_type)
+        return :datetime if /timestamp/i.match?(field_type)
+        return :text if /blob sub_type text/i.match?(field_type)
+        super
+      end
+    end
+  end
+end

data/lib/active_record/rdb_base.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def rdb_connection(config)
+      require 'fb'
+      config = rdb_connection_config(config)
+      db = ::Fb::Database.new(config)
+      begin
+        connection = db.connect
+      rescue StandardError
+        unless config[:create]
+          require 'pp'
+          pp config
+          raise ConnectionNotEstablished, 'No Firebird connections established.'
+        end
+        connection = db.create.connect
+      end
+      ConnectionAdapters::RdbAdapter.new(connection, logger, config)
+    end
+
+    def rdb_connection_config(config)
+      config = config.symbolize_keys.dup.reverse_merge(downcase_names: true)
+      port = config[:port] || 3050
+      raise ArgumentError, 'No database specified. Missing argument: database.' unless config[:database]
+      config[:database] = File.expand_path(config[:database], defined?(Rails) && Rails.root) if config[:host].nil? || /localhost/i.match?(config[:host])
+      config[:database] = "#{config[:host]}/#{port}:#{config[:database]}" if config[:host]
+      # config[:charset] = config[:charset].gsub(/-/, '') if config[:charset]
+      # config[:encoding] = config[:encoding].gsub(/-/, '') if config[:encoding]
+      config[:page_size] = 8192 unless config[:page_size]
+      config[:readonly_selects] = true unless config[:readonly_selects].present?
+      config
+    end
+  end
+end

data/lib/active_record/tasks/rdb_database_tasks.rb

@@ -0,0 +1,82 @@
+require 'active_record/tasks/database_tasks'
+
+module ActiveRecord
+  module Tasks
+    class RdbDatabaseTasks # :nodoc:
+      delegate :rdb_connection_config, :establish_connection, to: ::ActiveRecord::Base
+
+      def initialize(configuration, root = ::ActiveRecord::Tasks::DatabaseTasks.root)
+        @root = root
+        @configuration = rdb_connection_config(configuration)
+      end
+
+      def create
+        rdb_database.create
+        establish_connection configuration
+      rescue ::Fb::Error => e
+        raise unless e.message.include?('database or file exists')
+        raise DatabaseAlreadyExists
+      end
+
+      def drop
+        rdb_database.drop
+      rescue ::Fb::Error => e
+        raise ::ActiveRecord::ConnectionNotEstablished, e.message
+      end
+
+      def purge
+        begin
+          drop
+        rescue StandardError
+          nil
+        end
+        create
+      end
+
+      def structure_dump(filename)
+        isql :extract, output: filename
+      end
+
+      def structure_load(filename)
+        isql input: filename
+      end
+
+      private
+
+      def rdb_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
+
+      def isql_create(*_args)
+        "#{isql_executable} -input "
+      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 = %w[isql-fb isql].detect(&method(:find_executable0))
+        exe || abort('Unable to find isql or isql-fb in your $PATH')
+      end
+
+      attr_reader :configuration
+
+      attr_reader :root
+    end
+  end
+end

data/lib/activerecord-rdb-adapter.rb

@@ -0,0 +1,10 @@
+require 'active_record/connection_adapters/rdb_adapter'
+
+if defined?(::Rails::Railtie) && ::ActiveRecord::VERSION::MAJOR > 3
+  class Railtie < ::Rails::Railtie # :nodoc:
+    rake_tasks do
+      load 'active_record/tasks/rdb_database_tasks.rb'
+      ActiveRecord::Tasks::DatabaseTasks.register_task(/rdb/, ActiveRecord::Tasks::RdbDatabaseTasks)
+    end
+  end
+end

data/lib/arel/visitors/rdb_visitor.rb

@@ -0,0 +1,117 @@
+module Arel
+  module Visitors
+    class Rdb < Arel::Visitors::ToSql # :nodoc
+
+      def preparable
+        false
+      end
+
+      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
+
+        maybe_visit o.lock, 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
+
+        if Rails::VERSION::MAJOR < 5
+          collector = maybe_visit o.having, collector
+        else
+          unless o.havings.empty?
+            collector << " HAVING "
+            inject_join o.havings, collector, AND
+          end
+        end
+
+        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
+      end
+
+      def limit_with_rows o, collector
+        o.offset.expr.value = ActiveModel::Attribute.with_cast_value("OFFSET".freeze,
+                                                                     o.offset.expr.value.value + 1,
+                                                                     ActiveModel::Type.default_value)
+        offset = o.offset.expr.value
+        o.limit.expr.value = ActiveModel::Attribute.with_cast_value("LIMIT".freeze,
+                                                                    (o.limit.expr.value.value) + (offset.value - 1),
+                                                                    ActiveModel::Type.default_value)
+        limit = o.limit.expr.value
+        collector << " ROWS "
+        collector.add_bind(offset) {|i| "?"}
+        collector << " TO "
+        collector.add_bind(limit) {|i| "?"}
+      end
+
+      def quote_column_name name
+        return name if Arel::Nodes::SqlLiteral === name
+        @connection.quote_column_name(name)
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-rdb-adapter
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Andrey Lobanov (RedSoft)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: ActiveRecord Firebird and RedDatabase Adapter for Rails 5+
+email: andrey.lobanov@red-soft.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/active_record/connection_adapters/rdb/database_limits.rb
+- lib/active_record/connection_adapters/rdb/database_statements.rb
+- lib/active_record/connection_adapters/rdb/quoting.rb
+- lib/active_record/connection_adapters/rdb/schema_creation.rb
+- lib/active_record/connection_adapters/rdb/schema_dumper.rb
+- lib/active_record/connection_adapters/rdb/schema_statements.rb
+- lib/active_record/connection_adapters/rdb/table_definition.rb
+- lib/active_record/connection_adapters/rdb_adapter.rb
+- lib/active_record/connection_adapters/rdb_column.rb
+- lib/active_record/rdb_base.rb
+- lib/active_record/tasks/rdb_database_tasks.rb
+- lib/activerecord-rdb-adapter.rb
+- lib/arel/visitors/rdb_visitor.rb
+homepage: http://gitlab.red-soft.biz/andrey.lobanov/activerecord-rdb-adapter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Firebird library fb
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: ActiveRecord Firebird and RedDatabase Adapter
+test_files: []