activerecord7-redshift-adapter-pennylane 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8108a9c785d7604af14ffbaca6265c6350c119406c09951c0a73a2aba888471
-  data.tar.gz: a71d3843e77264799115393dd6ba8bb50717722c292aab9e3e73b0d0463d634e
+  metadata.gz: 26e7edd35acf5f404cb34a387350b1f0a10460b70d6cdffa78e146ff2e5e9bae
+  data.tar.gz: c6b7aa54b4e1d7487e40f048b035e90189e6ac3aed91ffddbcd706297b12de27
 SHA512:
-  metadata.gz: e4fd3c18f5255e06b5e0cb855c516b538304e00de9293108fde3eeb2fa7a90df2539824259af6201b4b14cd3c2d0b148c7357e29bdf00559cfcf1e700cb23ea5
-  data.tar.gz: 96c5852565ca6416135a7a19b49fc384007fbfb7a2bed043dd3d4804caaa765c5ba8fde811e5dc298531bc971d291acdf513b4708276fcddb76f2de489060dbe
+  metadata.gz: f2a95375595b29b82be85c059d2ae82cfd67269ddb603531e700fe45e35ce3750fd10f913afff46138284673a652e8af01a32b223f7de1ad830287820bcda4bc
+  data.tar.gz: 96a9934cc31208484b910adbe2cb22db6872ab16dbb2b011ce1d88a80785fffcf1bdecfeb6a0b065b34cea7a1b38241c1eca425606d2863092af4d2d9189bab6

data/lib/active_record/connection_adapters/redshift_7_0/oid/decimal.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     module Redshift
       module OID # :nodoc:
         class Decimal < Type::Decimal # :nodoc:
-          def infinity(**options)
+          def infinity(options = {})
             BigDecimal('Infinity') * (options[:negative] ? -1 : 1)
           end
         end

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

@@ -24,7 +24,7 @@ module ActiveRecord
       module SchemaStatements
         # Drops the database specified on the +name+ attribute
         # and creates it again using the provided +options+.
-        def recreate_database(name, **options) # :nodoc:
+        def recreate_database(name, options = {}) # :nodoc:
           drop_database(name)
           create_database(name, options)
         end
@@ -37,7 +37,7 @@ module ActiveRecord
         # Example:
         #   create_database config[:database], config
         #   create_database 'foo_development', encoding: 'unicode'
-        def create_database(name, **options)
+        def create_database(name, options = {})
           options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
 
           option_string = options.inject('') do |memo, (key, value)|
@@ -129,7 +129,7 @@ module ActiveRecord
         end
 
         def drop_table(table_name, **options)
-          execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
         end
 
         # Returns true if schema exists.

data/lib/active_record/connection_adapters/redshift_7_0_adapter.rb

@@ -20,8 +20,6 @@ require 'pg'
 
 require 'ipaddr'
 
-ActiveRecord::Tasks::DatabaseTasks.register_task(/redshift/, 'ActiveRecord::Tasks::PostgreSQLDatabaseTasks')
-
 module ActiveRecord
   module ConnectionHandling # :nodoc:
     RS_VALID_CONN_PARAMS = %i[host hostaddr port dbname user password connect_timeout

data/lib/active_record/connection_adapters/redshift_7_1/oid/decimal.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     module Redshift
       module OID # :nodoc:
         class Decimal < Type::Decimal # :nodoc:
-          def infinity(**options)
+          def infinity(options = {})
             BigDecimal('Infinity') * (options[:negative] ? -1 : 1)
           end
         end

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

@@ -44,7 +44,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(super).freeze
+          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(name.to_s).freeze
         end
 
         # Quotes schema names for use in SQL queries.

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

@@ -24,7 +24,7 @@ module ActiveRecord
       module SchemaStatements
         # Drops the database specified on the +name+ attribute
         # and creates it again using the provided +options+.
-        def recreate_database(name, **options) # :nodoc:
+        def recreate_database(name, options = {}) # :nodoc:
           drop_database(name)
           create_database(name, options)
         end
@@ -37,7 +37,7 @@ module ActiveRecord
         # Example:
         #   create_database config[:database], config
         #   create_database 'foo_development', encoding: 'unicode'
-        def create_database(name, **options)
+        def create_database(name, options = {})
           options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
 
           option_string = options.inject('') do |memo, (key, value)|
@@ -129,7 +129,7 @@ module ActiveRecord
         end
 
         def drop_table(table_name, **options)
-          execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+          execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
         end
 
         # Returns true if schema exists.

data/lib/active_record/connection_adapters/redshift_7_1_adapter.rb

@@ -20,7 +20,6 @@ require 'pg'
 
 require 'ipaddr'
 
-ActiveRecord::Tasks::DatabaseTasks.register_task(/redshift/, 'ActiveRecord::Tasks::PostgreSQLDatabaseTasks')
 module ActiveRecord
   module ConnectionHandling # :nodoc:
 

data/lib/active_record/connection_adapters/redshift_7_2/array_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ArrayParser # :nodoc:
+        DOUBLE_QUOTE = '"'
+        BACKSLASH = '\\'
+        COMMA = ','
+        BRACKET_OPEN = '{'
+        BRACKET_CLOSE = '}'
+
+        def parse_pg_array(string) # :nodoc:
+          local_index = 0
+          array = []
+          while local_index < string.length
+            case string[local_index]
+            when BRACKET_OPEN
+              local_index, array = parse_array_contents(array, string, local_index + 1)
+            when BRACKET_CLOSE
+              return array
+            end
+            local_index += 1
+          end
+
+          array
+        end
+
+        private
+
+        def parse_array_contents(array, string, index)
+          is_escaping  = false
+          is_quoted    = false
+          was_quoted   = false
+          current_item = ''
+
+          local_index = index
+          while local_index
+            token = string[local_index]
+            if is_escaping
+              current_item << token
+              is_escaping = false
+            elsif is_quoted
+              case token
+              when DOUBLE_QUOTE
+                is_quoted = false
+                was_quoted = true
+              when BACKSLASH
+                is_escaping = true
+              else
+                current_item << token
+              end
+            else
+              case token
+              when BACKSLASH
+                is_escaping = true
+              when COMMA
+                add_item_to_array(array, current_item, was_quoted)
+                current_item = ''
+                was_quoted = false
+              when DOUBLE_QUOTE
+                is_quoted = true
+              when BRACKET_OPEN
+                internal_items = []
+                local_index, internal_items = parse_array_contents(internal_items, string, local_index + 1)
+                array.push(internal_items)
+              when BRACKET_CLOSE
+                add_item_to_array(array, current_item, was_quoted)
+                return local_index, array
+              else
+                current_item << token
+              end
+            end
+
+            local_index += 1
+          end
+          [local_index, array]
+        end
+
+        def add_item_to_array(array, current_item, quoted)
+          return if !quoted && current_item.empty?
+
+          if !quoted && current_item == 'NULL'
+            array.push nil
+          else
+            array.push current_item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/column.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class RedshiftColumn < Column # :nodoc:
+      delegate :oid, :fmod, to: :sql_type_metadata
+
+      # Required for Rails 6.1, see https://github.com/rails/rails/pull/41756
+      mattr_reader :array, default: false
+      alias array? array
+
+      def initialize(name, default, sql_type_metadata, null = true, default_function = nil, **)
+        super name, default, sql_type_metadata, null, default_function
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module DatabaseStatements
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = internal_exec_query(sql, "EXPLAIN", binds)
+          PostgreSQL::ExplainPrettyPrinter.new.pp(result)
+        end
+
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) # :nodoc:
+          mark_transaction_written_if_write(sql)
+
+          log(sql, name) do
+            with_raw_connection do |conn|
+              result = conn.async_exec(sql).map_types!(@type_map_for_results).values
+              verified!
+              result
+            end
+          end
+        end
+
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        # Executes an SQL statement, returning a PG::Result object on success
+        # or raising a PG::Error exception otherwise.
+        #
+        # Setting +allow_retry+ to true causes the db to reconnect and retry
+        # executing the SQL statement in case of a connection-related exception.
+        # This option should only be enabled for known idempotent queries.
+        #
+        # Note: the PG::Result object is manually memory managed; if you don't
+        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
+        def execute(...) # :nodoc:
+          super
+        ensure
+          @notice_receiver_sql_warnings = []
+        end
+
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          log(sql, name, async: async) do
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conn.async_exec(sql)
+              verified!
+              handle_warnings(result)
+              result
+            end
+          end
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |result|
+            types = {}
+            fields = result.fields
+            fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
+            end
+            build_result(columns: fields, rows: result.values, column_types: types)
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
+        end
+        alias :exec_update :exec_delete
+
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+          if use_insert_returning? || pk == false
+            super
+          else
+            result = internal_exec_query(sql, name, binds)
+            unless sequence_name
+              table_ref = extract_table_ref_from_insert_sql(sql)
+              if table_ref
+                pk = primary_key(table_ref) if pk.nil?
+                pk = suppress_composite_primary_key(pk)
+                sequence_name = default_sequence_name(table_ref, pk)
+              end
+              return result unless sequence_name
+            end
+            last_insert_id_result(sequence_name)
+          end
+        end
+
+        # Begins a transaction.
+        def begin_db_transaction
+          internal_execute('BEGIN', allow_retry: true, materialize_transactions: false)
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          begin_db_transaction
+          internal_execute("SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", allow_retry: true, materialize_transactions: false)
+        end
+
+        # Commits a transaction.
+        def commit_db_transaction
+          internal_execute('COMMIT', allow_retry: false, materialize_transactions: true)
+        end
+
+        # Aborts a transaction.
+        def exec_rollback_db_transaction
+          internal_execute('ROLLBACK', allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          exec_rollback_db_transaction
+          begin_db_transaction
+        end
+
+        # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          "EXPLAIN (#{options.join(", ").upcase})"
+        end
+
+        private
+
+        IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
+        private_constant :IDLE_TRANSACTION_STATUSES
+
+        def cancel_any_running_query
+          return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
+
+          @raw_connection.cancel
+          @raw_connection.block
+        rescue PG::Error
+        end
+
+        # Returns the current ID of a table's sequence.
+        def last_insert_id_result(sequence_name)
+          internal_exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+        end
+
+        def returning_column_values(result)
+          result.rows.first
+        end
+
+        def suppress_composite_primary_key(pk)
+          pk unless pk.is_a?(Array)
+        end
+
+        def handle_warnings(sql)
+          @notice_receiver_sql_warnings.each do |warning|
+            next if warning_ignored?(warning)
+
+            warning.sql = sql
+            ActiveRecord.db_warnings_action.call(warning)
+          end
+        end
+
+        def warning_ignored?(warning)
+          ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid/date_time.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def type_cast_for_database(value)
+            if has_precision? && value.acts_like?(:time) && value.year <= 0
+              bce_year = format('%04d', -value.year + 1)
+              "#{super.sub(/^-?\d+/, bce_year)} BC"
+            else
+              super
+            end
+          end
+
+          def cast_value(value)
+            if value.is_a?(::String)
+              case value
+              when 'infinity' then ::Float::INFINITY
+              when '-infinity' then -::Float::INFINITY
+              when / BC$/
+                astronomical_year = format('%04d', -value[/^\d+/].to_i + 1)
+                super(value.sub(/ BC$/, '').sub(/^\d+/, astronomical_year))
+              else
+                super
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid/decimal.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Decimal < Type::Decimal # :nodoc:
+          def infinity(options = {})
+            BigDecimal('Infinity') * (options[:negative] ? -1 : 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid/json.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Json < Type::Value # :nodoc:
+          include ActiveModel::Type::Helpers::Mutable
+
+          def type
+            :json
+          end
+
+          def type_cast_from_database(value)
+            if value.is_a?(::String)
+              begin
+                ::ActiveSupport::JSON.decode(value)
+              rescue StandardError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array) || value.is_a?(::Hash)
+              ::ActiveSupport::JSON.encode(value)
+            else
+              super
+            end
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid/jsonb.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        class Jsonb < Json # :nodoc:
+          def type
+            :jsonb
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            # Postgres does not preserve insignificant whitespaces when
+            # roundtripping jsonb columns. This causes some false positives for
+            # the comparison here. Therefore, we need to parse and re-dump the
+            # raw value here to ensure the insignificant whitespaces are
+            # consistent with our encoder's output.
+            raw_old_value = type_cast_for_database(type_cast_from_database(raw_old_value))
+            super(raw_old_value, new_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid/type_map_initializer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+        # This class uses the data from PostgreSQL pg_type table to build
+        # the OID -> Type mapping.
+        #   - OID is an integer representing the type.
+        #   - Type is an OID::Type object.
+        # This class has side effects on the +store+ passed during initialization.
+        class TypeMapInitializer # :nodoc:
+          def initialize(store, run_complex_types = true)
+            @store = store
+            @run_complex_types = run_complex_types
+          end
+
+          def run(records)
+            records
+              .reject { |row| @store.key? row['oid'].to_i }
+              .select { |row| @store.key? row['typname'] }
+              .each { |row| register_mapped_type(row) }
+          end
+
+          private
+
+          def register_mapped_type(row)
+            alias_type row['oid'], row['typname']
+          end
+
+          def register(oid, oid_type = nil, &block)
+            oid = assert_valid_registration(oid, oid_type || block)
+            if block_given?
+              @store.register_type(oid, &block)
+            else
+              @store.register_type(oid, oid_type)
+            end
+          end
+
+          def alias_type(oid, target)
+            oid = assert_valid_registration(oid, target)
+            @store.alias_type(oid, target)
+          end
+
+          def register_with_subtype(oid, target_oid)
+            return unless @store.key?(target_oid)
+
+            register(oid) do |_, *args|
+              yield @store.lookup(target_oid, *args)
+            end
+          end
+
+          def assert_valid_registration(oid, oid_type)
+            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+
+            oid.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_7_2/oid.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'oid/date_time'
+require_relative 'oid/decimal'
+require_relative 'oid/json'
+require_relative 'oid/jsonb'
+
+require_relative 'oid/type_map_initializer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module OID # :nodoc:
+      end
+    end
+  end
+end