ar_firebird_adapter 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ca6d29acdccc19c734c581fd88d10789e7a7e9aa49baba016f68668479d28cb
+  data.tar.gz: 0b12220547231a7bed9a27494309f1dba73f9ae27fde6cb38123906971cbf5f6
+SHA512:
+  metadata.gz: '051176505698bd4da3565b447b0b13c1f6d228c060095b00e78f0bf73f1593244685230906bb75cdb29f359df273e573eb8889b96ba271974d670d5ed9548e30'
+  data.tar.gz: 07a6000f3fcb3d4cf00f87c1352676ce00b3c5f512ff0ea66b63ac39dc8f6ec004c9d796c7b9836c215f0a6d25d7e79adc578017626548f281dfe510893ab2f5

data/lib/active_record/connection_adapters/ar_firebird/connection.rb

@@ -0,0 +1,18 @@
+module ActiveRecord::ConnectionHandling
+  def ar_firebird_connection(config)
+    require 'active_record/extensions'
+    require 'active_record/internal_metadata_extensions'
+
+    config = config.symbolize_keys.dup.reverse_merge(downcase_names: true, port: 3050, encoding: ActiveRecord::ConnectionAdapters::ArFirebirdAdapter::DEFAULT_ENCODING)
+
+    if config[:host]
+      config[:database] = "#{config[:host]}/#{config[:port]}:#{config[:database]}"
+    else
+      config[:database] = File.expand_path(config[:database], Rails.root)
+    end
+
+    connection = ::Fb::Database.new(config).connect
+
+    ActiveRecord::ConnectionAdapters::ArFirebirdAdapter.new(connection, logger, config)
+  end
+end

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

@@ -0,0 +1,33 @@
+module ActiveRecord::ConnectionAdapters::ArFirebird
+  module DatabaseLimits
+
+    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

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

@@ -0,0 +1,96 @@
+module ActiveRecord::ConnectionAdapters::ArFirebird::DatabaseStatements
+
+  delegate :boolean_domain, to: 'ActiveRecord::ConnectionAdapters::ArFirebirdAdapter'
+
+  def execute(sql, name = nil)
+    sql = sql.encode(encoding, 'UTF-8')
+
+    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)
+    sql = sql.encode(encoding, 'UTF-8')
+
+    type_casted_binds = type_casted_binds(binds).map do |value|
+      value.encode(encoding) rescue value
+    end
+
+    log(sql, name, binds, type_casted_binds) do
+      ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+        begin
+          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 col
+              end
+            end
+
+            result.close
+            ActiveRecord::Result.new(fields, rows)
+          else
+            result
+          end
+        rescue Exception => e
+          raise e.message.encode('UTF-8', @connection.encoding)
+        end
+      end
+    end
+  end
+
+  def begin_db_transaction
+    log("begin transaction", nil) { @connection.transaction('READ COMMITTED') }
+  end
+
+  def commit_db_transaction
+    log("commit transaction", nil) { @connection.commit }
+  end
+
+  def exec_rollback_db_transaction
+    log("rollback transaction", nil) { @connection.rollback }
+  end
+
+  def create_table(table_name, **options)
+    super
+
+    if options[:sequence] != false && options[:id] != false
+      sequence_name = options[:sequence] || default_sequence_name(table_name)
+      create_sequence(sequence_name)
+    end
+  end
+
+  def drop_table(table_name, options = {})
+    if options[:sequence] != false
+      sequence_name = options[:sequence] || default_sequence_name(table_name)
+      drop_sequence(sequence_name) if sequence_exists?(sequence_name)
+    end
+
+    super
+  end
+
+  def create_sequence(sequence_name)
+    execute("CREATE SEQUENCE #{sequence_name}") rescue nil
+  end
+
+  def drop_sequence(sequence_name)
+    execute("DROP SEQUENCE #{sequence_name}") rescue nil
+  end
+
+  def sequence_exists?(sequence_name)
+    @connection.generator_names.include?(sequence_name)
+  end
+
+  def default_sequence_name(table_name, _column = nil)
+    "#{table_name}_g01"
+  end
+
+  def next_sequence_value(sequence_name)
+    @connection.query("SELECT NEXT VALUE FOR #{sequence_name} FROM RDB$DATABASE")[0][0]
+  end
+
+end

data/lib/active_record/connection_adapters/ar_firebird/fb_column.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module ArFirebird
+      class FbColumn < ActiveRecord::ConnectionAdapters::Column # :nodoc:
+
+        attr_reader :domain
+        def initialize(
+            name,
+            default,
+            sql_type_metadata = nil,
+            null = true,
+            table_name = nil,
+            default_function = nil,
+            collation = nil,
+            comment = nil,
+            firebird_options = {}
+          )
+          @domain = firebird_options.domain
+          super(
+            name,
+            default,
+            sql_type_metadata,
+            null,
+            default_function,
+            collation: nil,
+            comment: comment
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module ArFirebird
+      module Quoting
+
+        def unquoted_true
+          boolean_domain[:true]
+        end
+
+        def quoted_true # :nodoc:
+          quote unquoted_true
+        end
+
+        def unquoted_false
+          boolean_domain[:false]
+        end
+
+        def quoted_false # :nodoc:
+          quote unquoted_false
+        end
+
+        def lookup_cast_type_from_column(column) # :nodoc:
+          sql_type = (column.domain == boolean_domain[:name]) ? 'BOOLEAN' : column.sql_type
+          type_map.lookup(sql_type)
+        end
+
+        def quoted_date(value)
+          super.sub(/(\.\d{6})\z/, $1.to_s.first(5))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module ActiveRecord::ConnectionAdapters::ArFirebird::SchemaStatements
+
+  def tables(_name = nil)
+    @connection.table_names
+  end
+
+  def views
+    @connection.view_names
+  end
+
+  def indexes(table_name)
+    result = query(<<~SQL, "SCHEMA")
+      SELECT
+        rdb$index_name,
+        rdb$unique_flag
+      FROM
+        rdb$indices
+      WHERE
+        rdb$relation_name = '#{table_name.upcase}';
+    SQL
+
+    result.map do |row|
+      index_name = row[0].strip
+      unique = row[1] == 1
+      columns = query_values(<<~SQL, "SCHEMA")
+        SELECT
+          rdb$field_name
+        FROM
+          rdb$index_segments
+        WHERE
+          rdb$index_name = '#{index_name}'
+        ORDER BY
+          rdb$field_position
+      SQL
+
+      ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+        table_name.downcase,
+        index_name.downcase,
+        unique,
+        columns.map(&:strip).map(&:downcase),
+      )
+    end
+  end
+
+  def remove_index(table_name, options = {})
+    index_name = index_name_for_remove(table_name, options)
+    execute "DROP INDEX #{quote_column_name(index_name)}"
+  end
+
+  def foreign_keys(table_name)
+    result = query(<<~SQL, "SCHEMA")
+      WITH FK_FIELDS AS (
+        SELECT
+          AA2.RDB$RELATION_NAME,
+          AA2.RDB$CONSTRAINT_NAME,
+          BB2.RDB$CONST_NAME_UQ AS LINK_UK_OR_PK,
+          EE2.RDB$RELATION_NAME AS REFERENCE_TABLE,
+          CC2.RDB$FIELD_NAME,
+          AA2.RDB$CONSTRAINT_TYPE
+        FROM
+          RDB$RELATION_CONSTRAINTS AA2
+          LEFT JOIN RDB$REF_CONSTRAINTS BB2 ON BB2.RDB$CONSTRAINT_NAME = AA2.RDB$CONSTRAINT_NAME
+          LEFT JOIN RDB$INDEX_SEGMENTS CC2 ON CC2.RDB$INDEX_NAME = AA2.RDB$INDEX_NAME
+          LEFT JOIN RDB$RELATION_FIELDS DD2 ON DD2.RDB$FIELD_NAME = CC2.RDB$FIELD_NAME AND DD2.RDB$RELATION_NAME = AA2.RDB$RELATION_NAME
+          LEFT JOIN RDB$RELATION_CONSTRAINTS EE2 ON EE2.RDB$CONSTRAINT_NAME = BB2.RDB$CONST_NAME_UQ
+      )
+      SELECT
+        AA.RDB$CONSTRAINT_NAME,
+        BB.REFERENCE_TABLE,
+        BB.FIELDS,
+        BB.REFERENCE_FIELDS
+      FROM
+        RDB$RELATION_CONSTRAINTS AA
+        LEFT JOIN (
+          SELECT
+            AA1.RDB$RELATION_NAME,
+            AA1.RDB$CONSTRAINT_NAME,
+            AA1.LINK_UK_OR_PK,
+            AA1.REFERENCE_TABLE,
+            (
+              SELECT LIST(TRIM(AA3.RDB$FIELD_NAME), ', ') FROM FK_FIELDS AA3 WHERE AA3.RDB$CONSTRAINT_NAME = AA1.RDB$CONSTRAINT_NAME ROWS 1
+            ) AS FIELDS,
+            (
+              SELECT LIST(TRIM(AA4.RDB$FIELD_NAME), ', ') FROM FK_FIELDS AA4 WHERE AA4.RDB$CONSTRAINT_NAME = AA1.LINK_UK_OR_PK ROWS 1
+            ) AS REFERENCE_FIELDS
+          FROM
+            FK_FIELDS AA1
+          GROUP BY
+            AA1.RDB$RELATION_NAME,
+            AA1.RDB$CONSTRAINT_NAME,
+            AA1.REFERENCE_TABLE,
+            AA1.LINK_UK_OR_PK
+        ) BB ON BB.RDB$RELATION_NAME = AA.RDB$RELATION_NAME AND BB.RDB$CONSTRAINT_NAME = AA.RDB$CONSTRAINT_NAME
+      WHERE
+        AA.RDB$CONSTRAINT_TYPE = 'FOREIGN KEY'
+        AND AA.RDB$RELATION_NAME = '#{table_name.upcase}';
+    SQL
+
+    result.map do |row|
+      options = {
+        column: row[2].downcase,
+        name: row[0].strip.downcase,
+        primary_key: row[3].downcase
+      }
+
+      ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row[1].strip.downcase, options)
+    end
+  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"], field)
+    ActiveRecord::ConnectionAdapters::ArFirebird::FbColumn.new(
+      field["name"],
+      field["default"],
+      type_metadata,
+      field["nullable"],
+      table_name,
+      nil,
+      nil,
+      nil,
+      field
+    )
+  end
+
+  def fetch_type_metadata(sql_type, field = "")
+    if field['domain'] == ActiveRecord::ConnectionAdapters::ArFirebirdAdapter.boolean_domain[:name]
+      cast_type = lookup_cast_type("boolean")
+    else
+      cast_type = lookup_cast_type(sql_type)
+    end
+    ActiveRecord::ConnectionAdapters::ArFirebird::SqlTypeMetadata.new(
+      sql_type: sql_type,
+      type: cast_type.type,
+      precision: cast_type.precision,
+      scale: cast_type.scale,
+      limit: cast_type.limit,
+      field: field
+    )
+  end
+
+end

data/lib/active_record/connection_adapters/ar_firebird/sql_type_metadata.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module ArFirebird
+      class SqlTypeMetadata < ActiveRecord::ConnectionAdapters::SqlTypeMetadata
+
+        def initialize(sql_type: nil, type: nil, limit: nil, precision: nil, scale: nil, **firebird_options)
+          @sql_type = sql_type
+          @type = (firebird_options[:field].domain) ? :boolean : sql_type
+          @limit = limit
+          @precision = precision
+          @scale = scale
+          @firebird_options = firebird_options
+        end
+
+        protected
+
+        def attributes_for_hash
+          super + [@firebird_options]
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ar_firebird_adapter.rb

@@ -0,0 +1,126 @@
+require 'fb'
+
+require 'active_record/connection_adapters/ar_firebird/connection'
+require 'active_record/connection_adapters/ar_firebird/database_limits'
+require 'active_record/connection_adapters/ar_firebird/database_statements'
+require 'active_record/connection_adapters/ar_firebird/schema_statements'
+require 'active_record/connection_adapters/ar_firebird/sql_type_metadata'
+require 'active_record/connection_adapters/ar_firebird/fb_column'
+require 'active_record/connection_adapters/ar_firebird/quoting'
+
+require 'arel/visitors/ar_firebird'
+
+class ActiveRecord::ConnectionAdapters::ArFirebirdAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+  ADAPTER_NAME = "ArFirebird".freeze
+  DEFAULT_ENCODING = "Windows-1252".freeze
+
+  include ActiveRecord::ConnectionAdapters::ArFirebird::DatabaseLimits
+  include ActiveRecord::ConnectionAdapters::ArFirebird::DatabaseStatements
+  include ActiveRecord::ConnectionAdapters::ArFirebird::SchemaStatements
+  include ActiveRecord::ConnectionAdapters::ArFirebird::Quoting
+
+
+
+  @boolean_domain = { name: "smallint", limit: 1, type: "smallint", true: 1, false: 0}
+
+  class << self
+    attr_accessor :boolean_domain
+  end
+
+  NATIVE_DATABASE_TYPES =  {
+    primary_key: 'integer not null primary key',
+    string:      { name: 'varchar', limit: 255 },
+    text:        { name: 'blob sub_type text' },
+    integer:     { name: 'integer' },
+    float:       { name: 'float' },
+    decimal:     { name: 'decimal' },
+    datetime:    { name: 'timestamp' },
+    timestamp:   { name: 'timestamp' },
+    date:        { name: 'date' },
+    binary:      { name: 'blob' },
+    boolean:     { name: ActiveRecord::ConnectionAdapters::ArFirebirdAdapter.boolean_domain[:name] }
+  }
+
+  def native_database_types
+    NATIVE_DATABASE_TYPES
+  end
+
+  def arel_visitor
+    @arel_visitor ||= Arel::Visitors::ArFirebird.new(self)
+  end
+
+  def prefetch_primary_key?(table_name = nil)
+    true
+  end
+
+  def active?
+    return false unless @connection.open?
+
+    @connection.query("SELECT 1 FROM RDB$DATABASE")
+    true
+  rescue
+    false
+  end
+
+  def reconnect!
+    disconnect!
+    @connection = ::Fb::Database.connect(@config)
+  end
+
+  def disconnect!
+    super
+    @connection.close rescue nil
+  end
+
+  def reset!
+    reconnect!
+  end
+
+  def primary_keys(table_name)
+    raise ArgumentError unless table_name.present?
+
+    names = query_values(<<~SQL, "SCHEMA")
+      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 = '#{table_name.upcase}'
+        AND c.rdb$constraint_type = 'PRIMARY KEY';
+    SQL
+
+    names.map(&:strip).map(&:downcase)
+  end
+
+  def encoding
+    @connection.encoding
+  end
+
+  def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+    sql = sql.encode('UTF-8', encoding) if sql.encoding.to_s == encoding
+    super
+  end
+
+  def supports_foreign_keys?
+    true
+  end
+
+protected
+
+  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

data/lib/active_record/extensions.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Calculations.module_eval do
+  def count(column_name = nil)
+    return super() if block_given?
+    calculate(:count, column_name || 1)
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
+    result = from_clause + join_clause + where_clause + having_clause
+    result.unshift(offset) if offset
+    result.unshift(limit) if limit
+    result  
+  end
+end if ActiveRecord::VERSION::STRING < '5.2.0'

data/lib/active_record/internal_metadata_extensions.rb

@@ -0,0 +1,31 @@
+class ActiveRecord::InternalMetadata
+  class << self
+    def adapter_name
+      connection.adapter_name.downcase.to_sym
+    end
+
+    def value_name
+      adapter_name == :ar_firebird ? :value_ : :value
+    end
+
+    def []=(key, value)
+      find_or_initialize_by(key: key).update!(value_name => value)
+    end
+
+    def [](key)
+      where(key: key).pluck(value_name).first
+    end
+
+    def create_table
+      unless table_exists?
+        key_options = connection.internal_string_options_for_primary_key
+
+        connection.create_table(table_name, id: false) do |t|
+          t.string :key, key_options
+          t.string value_name
+          t.timestamps
+        end
+      end
+    end
+  end
+end

data/lib/arel/visitors/ar_firebird.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class Arel::Visitors::ArFirebird < Arel::Visitors::ToSql
+
+  private
+
+  def visit_Arel_Nodes_SelectStatement o, collector
+    if o.with
+      collector = visit o.with, collector
+      collector << ' '
+    end
+
+    collector = o.cores.inject(collector) do |c, x|
+      visit_Arel_Nodes_SelectCore(x, c, o)
+    end
+
+    unless o.orders.empty?
+      collector << ' ORDER BY '
+      o.orders.each_with_index do |x, i|
+        collector << ', ' unless i == 0
+        collector = visit(x, collector)
+      end
+    end
+
+    collector
+  end
+
+  def visit_Arel_Nodes_SelectCore(core, collector, o)
+    # We need to use the Arel::Nodes::SelectCore `core`
+    # as well as Arel::Nodes::SelectStatement `o` in
+    # contradiction to the super class because we access
+    # the `visit_Arel_Nodes_SelectOptions` method because
+    # we need to set our limit and offset in the select
+    # clause (Firebird specific SQL)
+    collector << 'SELECT'
+
+    visit_Arel_Nodes_SelectOptions(o, collector)
+
+    collector = maybe_visit core.set_quantifier, collector
+
+    collect_nodes_for core.projections, collector, ' '
+
+    if core.source && !core.source.empty?
+      collector << ' FROM '
+      collector = visit core.source, collector
+    end
+
+    collect_nodes_for core.wheres, collector, ' WHERE ', ' AND '
+    collect_nodes_for core.groups, collector, ' GROUP BY '
+    unless core.havings.empty?
+      collector << ' HAVING '
+      inject_join core.havings, collector, ' AND '
+    end
+    collect_nodes_for core.windows, collector, ' WINDOW '
+
+    collector
+  end
+
+  def visit_Arel_Nodes_Limit(o, collector)
+    collector << 'FIRST '
+    visit o.expr, collector
+  end
+
+  def visit_Arel_Nodes_Offset(o, collector)
+    collector << 'SKIP '
+    visit o.expr, collector
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: ar_firebird_adapter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Fábio Rodrigues
+- Gernot Gradwohl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-15 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.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: pry-meta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: 
+email:
+- grnt.grdwhl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/connection_adapters/ar_firebird/connection.rb
+- lib/active_record/connection_adapters/ar_firebird/database_limits.rb
+- lib/active_record/connection_adapters/ar_firebird/database_statements.rb
+- lib/active_record/connection_adapters/ar_firebird/fb_column.rb
+- lib/active_record/connection_adapters/ar_firebird/quoting.rb
+- lib/active_record/connection_adapters/ar_firebird/schema_statements.rb
+- lib/active_record/connection_adapters/ar_firebird/sql_type_metadata.rb
+- lib/active_record/connection_adapters/ar_firebird_adapter.rb
+- lib/active_record/extensions.rb
+- lib/active_record/internal_metadata_extensions.rb
+- lib/arel/visitors/ar_firebird.rb
+homepage: https://github.com/rails-firebird/ar_firebird_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: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveRecord Firebird Adapter for Rails 5 and 6.
+test_files: []