activerecord-rdb-adapter 0.9.4 → 0.9.5

data/fb_extensions.rb

@@ -1,21 +1,21 @@
-module Fb
-  class Connection
-    def execute_script(sql)
-      stmts = []
-      delim = ';'
-      while sql =~ /\S/
-        stmt, sql = sql.split(delim, 2)
-        if stmt =~ /^\s*set\s+term\s+(\S+)/i
-          delim = $1
-        elsif stmt =~ /\S/
-          stmts << stmt
-        end
-      end
-      self.transaction do
-        stmts.each do |stmt|
-          self.execute(stmt)
-        end
-      end
-    end
-  end
-end
+module Fb
+  class Connection
+    def execute_script(sql)
+      stmts = []
+      delim = ';'
+      while sql =~ /\S/
+        stmt, sql = sql.split(delim, 2)
+        if stmt =~ /^\s*set\s+term\s+(\S+)/i
+          delim = $1
+        elsif stmt =~ /\S/
+          stmts << stmt
+        end
+      end
+      self.transaction do
+        stmts.each do |stmt|
+          self.execute(stmt)
+        end
+      end
+    end
+  end
+end

data/lib/active_model/type/integer.rb

@@ -1,68 +1,68 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Integer < Value # :nodoc:
-      include Helpers::Numeric
-
-      DEFAULT_LIMIT = 8
-
-      def initialize(*)
-        super
-        @range = min_value...max_value
-      end
-
-      def type
-        :integer
-      end
-
-      def deserialize(value)
-        return if value.nil?
-        value.to_i
-      end
-
-      def serialize(value)
-        result = cast(value)
-        if result
-          ensure_in_range(result)
-        end
-        result
-      end
-
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-      attr_reader :range
-
-      private
-
-      def cast_value(value)
-        case value
-        when true then 1
-        when false then 0
-        else
-          value.to_i rescue nil
-        end
-      end
-
-      def ensure_in_range(value)
-        unless range.cover?(value)
-          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
-        end
-      end
-
-      def max_value
-        1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
-      end
-
-      def min_value
-        -max_value
-      end
-
-      def _limit
-        limit || DEFAULT_LIMIT
-      end
-    end
-  end
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Integer < Value # :nodoc:
+      include Helpers::Numeric
+
+      DEFAULT_LIMIT = 8
+
+      def initialize(*)
+        super
+        @range = min_value...max_value
+      end
+
+      def type
+        :integer
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value.to_i
+      end
+
+      def serialize(value)
+        result = cast(value)
+        if result
+          ensure_in_range(result)
+        end
+        result
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+
+      attr_reader :range
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then 1
+        when false then 0
+        else
+          value.to_i rescue nil
+        end
+      end
+
+      def ensure_in_range(value)
+        unless range.cover?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+        end
+      end
+
+      def max_value
+        1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
+      end
+
+      def min_value
+        -max_value
+      end
+
+      def _limit
+        limit || DEFAULT_LIMIT
+      end
+    end
+  end
 end

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

@@ -1,35 +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
+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

@@ -1,183 +1,186 @@
-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
-        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
-
-        def insert_fixtures_set(fixture_set, tables_to_delete = [])
-          fixture_inserts = fixture_set.map do |table_name, fixtures|
-            next if fixtures.empty?
-
-            build_fixture_sql(fixtures, table_name).collect {|f| f }
-          end.compact
-
-          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
-          sql = fixture_inserts.flatten(1)
-          sql.unshift(*table_deletes)
-
-          transaction(requires_new: true) do
-            sql.each do |s|
-              execute s, 'Fixture load'
-            end
-          end
-        end
-
-        private
-
-        def default_insert_value(column)
-          if column.default.nil?
-            Arel.sql('NULL')
-          else
-            Arel.sql(quote(column.default))
-          end
-        end
-
-        def build_fixture_sql(fixtures, table_name)
-          columns = schema_cache.columns_hash(table_name)
-
-          values = fixtures.map do |fixture|
-            fixture = fixture.stringify_keys
-
-            unknown_columns = fixture.keys - columns.keys
-            if unknown_columns.any?
-              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
-            end
-
-            columns.map do |name, column|
-              if fixture.key?(name)
-                type = lookup_cast_type_from_column(column)
-                bind = Relation::QueryAttribute.new(name, fixture[name], type)
-                with_yaml_fallback(bind.value_for_database)
-              else
-                default_insert_value(column)
-              end
-            end
-          end
-
-          sql ||= []
-
-          values.each_with_index do |row, i|
-            s = ''
-            s << "INSERT INTO #{quote_table_name(table_name)}"
-
-            unless columns.empty?
-              s << ' ('
-              columns.each_with_index do |x, y|
-                s << ', ' unless y == 0
-                s << quote_column_name(x[1].name)
-              end
-              s << ')'
-            end
-
-            s << ' VALUES ('
-            row.each_with_index do |value, k|
-              s << ', ' unless k == 0
-              case value
-              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
-                s << value.to_s
-              when Time
-                s << quote(value.strftime("%F %T"))
-              else
-                s << quote(value).to_s
-              end
-            end
-            s << ');'
-            sql << s
-          end
-
-          sql
-        end
-      end
-    end
-  end
-end
+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
+            rescue => e
+              result.close if result && result.is_a?(Fb::Cursor)
+              raise e
+            end
+          end
+        rescue => e
+          raise e
+        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
+
+        def insert_fixtures_set(fixture_set, tables_to_delete = [])
+          fixture_inserts = fixture_set.map do |table_name, fixtures|
+            next if fixtures.empty?
+
+            build_fixture_sql(fixtures, table_name).collect {|f| f }
+          end.compact
+
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+          sql = fixture_inserts.flatten(1)
+          sql.unshift(*table_deletes)
+
+          transaction(requires_new: true) do
+            sql.each do |s|
+              execute s, 'Fixture load'
+            end
+          end
+        end
+
+        private
+
+        def default_insert_value(column)
+          if column.default.nil?
+            Arel.sql('NULL')
+          else
+            Arel.sql(quote(column.default))
+          end
+        end
+
+        def build_fixture_sql(fixtures, table_name)
+          columns = schema_cache.columns_hash(table_name)
+
+          values = fixtures.map do |fixture|
+            fixture = fixture.stringify_keys
+
+            unknown_columns = fixture.keys - columns.keys
+            if unknown_columns.any?
+              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+            end
+
+            columns.map do |name, column|
+              if fixture.key?(name)
+                type = lookup_cast_type_from_column(column)
+                bind = Relation::QueryAttribute.new(name, fixture[name], type)
+                with_yaml_fallback(bind.value_for_database)
+              else
+                default_insert_value(column)
+              end
+            end
+          end
+
+          sql ||= []
+
+          values.each_with_index do |row, i|
+            s = ''
+            s << "INSERT INTO #{quote_table_name(table_name)}"
+
+            unless columns.empty?
+              s << ' ('
+              columns.each_with_index do |x, y|
+                s << ', ' unless y == 0
+                s << quote_column_name(x[1].name)
+              end
+              s << ')'
+            end
+
+            s << ' VALUES ('
+            row.each_with_index do |value, k|
+              s << ', ' unless k == 0
+              case value
+              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                s << value.to_s
+              when Time
+                s << quote(value.strftime("%F %T"))
+              else
+                s << quote(value).to_s
+              end
+            end
+            s << ');'
+            sql << s
+          end
+
+          sql
+        end
+      end
+    end
+  end
+end