akapu_firebird_adapter 6.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8b56f53882af6b7e1422cf168f656c75c218a4e5793df59cc4510b43be72d5e
+  data.tar.gz: 8d0c9f253f74259ea4c53051ce9cea787ffae16bd9078af156f15b4e70d357b5
+SHA512:
+  metadata.gz: 4a45a43df378b8c5a7cef865656ddb6089346c849b30bc5787cb8f5c611918fc9bd0c62afbc405b2831a920a0f95f2190a01d5dca2996c9a2eb217e526744450
+  data.tar.gz: 3966cf2f0ee811d26efd6dd241a20d9e17a93a03de46a39148952010cee8d0dcf8b2c3bbf34b87aa15df0b65cdb9998a67f05861df1063d294d6377edc2df35e

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

@@ -0,0 +1,18 @@
+module ActiveRecord::ConnectionHandling
+  def 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::FirebirdAdapter::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::FirebirdAdapter.new(connection, logger, config)
+  end
+end

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

@@ -0,0 +1,33 @@
+module ActiveRecord::ConnectionAdapters::Firebird
+  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/firebird/database_statements.rb

@@ -0,0 +1,116 @@
+module ActiveRecord::ConnectionAdapters::Firebird::DatabaseStatements
+
+  def 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: 'smallint' }
+    }
+  end
+
+  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)
+          elsif name.end_with?(' Destroy')
+            result
+          else
+            ActiveRecord::Result.new([], [])
+          end
+        rescue RangeError => e
+          return ActiveRecord::Result.new([], []) if sql.downcase.start_with? 'select'
+          raise e
+        rescue Exception => e
+          result.close if result.is_a?(Fb::Cursor)
+          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/firebird/quoting.rb

@@ -0,0 +1,5 @@
+module ActiveRecord::ConnectionAdapters::Firebird::Quoting
+  def quoted_date(value)
+    super.sub(/(\.\d{6})\z/, $1.to_s.first(5))
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'active_support/core_ext/string/strip'
+
+module ActiveRecord::ConnectionAdapters::Firebird::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, column, options = {})
+    index_name = index_name_for_remove(table_name, column, options)
+    execute "DROP INDEX #{quote_column_name(index_name)}"
+  end
+
+  def foreign_keys(table_name)
+    result = query(<<-SQL.strip_heredoc, "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 remove_column_for_alter(table_name, column_name, type = nil, options = {})
+    "DROP #{quote_column_name(column_name)}"
+  end
+
+  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
+
+end

data/lib/active_record/connection_adapters/firebird_adapter.rb

@@ -0,0 +1,98 @@
+require 'fb'
+
+require 'active_record/connection_adapters/firebird/connection'
+require 'active_record/connection_adapters/firebird/database_limits'
+require 'active_record/connection_adapters/firebird/database_statements'
+require 'active_record/connection_adapters/firebird/schema_statements'
+require 'active_record/connection_adapters/firebird/quoting'
+
+require 'arel/visitors/firebird'
+
+class ActiveRecord::ConnectionAdapters::FirebirdAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+  ADAPTER_NAME = "Firebird".freeze
+  DEFAULT_ENCODING = "Windows-1252".freeze
+
+  include ActiveRecord::ConnectionAdapters::Firebird::DatabaseLimits
+  include ActiveRecord::ConnectionAdapters::Firebird::DatabaseStatements
+  include ActiveRecord::ConnectionAdapters::Firebird::SchemaStatements
+  include ActiveRecord::ConnectionAdapters::Firebird::Quoting
+
+  def arel_visitor
+    @arel_visitor ||= Arel::Visitors::Firebird.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 == :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/firebird.rb

@@ -0,0 +1,87 @@
+module Arel
+  class SelectManager
+    attr_reader :parentheses_ignored
+
+    def ignore_parentheses
+      @parentheses_ignored = true
+      self
+    end
+  end
+
+  class Visitors::Firebird < Arel::Visitors::ToSql
+    private
+
+    def visit_Arel_Nodes_SelectCore(o, collector, select_statement)
+      collector << 'SELECT'
+
+      visit_Arel_Nodes_SelectOptions(select_statement, collector)
+
+      collector = collect_optimizer_hints(o, collector)
+      collector = maybe_visit o.set_quantifier, collector
+
+      collect_nodes_for o.projections, collector, ' '
+
+      if o.source && !o.source.empty?
+        collector << ' FROM '
+        collector = visit o.source, collector
+      end
+
+      collect_nodes_for o.wheres, collector, ' WHERE ', ' AND '
+      collect_nodes_for o.groups, collector, ' GROUP BY '
+      unless o.havings.empty?
+        collector << ' HAVING '
+        inject_join o.havings, collector, ' AND '
+      end
+      collect_nodes_for o.windows, collector, ' WINDOW '
+
+      collector
+    end
+
+    def visit_Arel_Nodes_SelectStatement o, collector
+      if o.with
+        collector = visit o.with, collector
+        collector << ' '
+      end
+
+      collector = o.cores.inject(collector) { |c,x|
+        visit_Arel_Nodes_SelectCore(x, c, o)
+      }
+
+      unless o.orders.empty?
+        collector << ' ORDER BY '
+        len = o.orders.length - 1
+        o.orders.each_with_index { |x, i|
+          collector = visit(x, collector)
+          collector << ', ' unless len == i
+        }
+      end
+
+      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
+
+    def visit_Arel_SelectManager o, collector
+      return visit(o.ast, collector) if o.parentheses_ignored
+
+      collector << '('
+      visit(o.ast, collector) << ')'
+    end
+
+    def visit_Arel_Nodes_Union o, collector
+      infix_value(o, collector, ' UNION ')
+    end
+
+    def visit_Arel_Nodes_UnionAll o, collector
+      infix_value(o, collector, ' UNION ALL ')
+    end
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: akapu_firebird_adapter
+version: !ruby/object:Gem::Version
+  version: 6.0.1
+platform: ruby
+authors:
+- Fábio Rodrigues
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.4
+- !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'
+- !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
+description:
+email:
+- fabio.info@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/connection_adapters/firebird/connection.rb
+- lib/active_record/connection_adapters/firebird/database_limits.rb
+- lib/active_record/connection_adapters/firebird/database_statements.rb
+- lib/active_record/connection_adapters/firebird/quoting.rb
+- lib/active_record/connection_adapters/firebird/schema_statements.rb
+- lib/active_record/connection_adapters/firebird_adapter.rb
+- lib/active_record/extensions.rb
+- lib/active_record/internal_metadata_extensions.rb
+- lib/arel/visitors/firebird.rb
+homepage: https://github.com/FabioMR/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: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.27
+signing_key:
+specification_version: 4
+summary: Forked from "ActiveRecord Firebird Adapter for Rails 6." due to update dependencies
+  versions
+test_files: []