activerecord-redshift-adapter 0.9.12 → 8.0.0.beta1

data/lib/active_record/connection_adapters/redshift_7_1/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_1/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_1/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_1/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_1/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_1/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_1/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_1/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_1/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

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module Quoting
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        # Escapes binary strings for bytea input to the database.
+        def escape_bytea(value)
+          valid_raw_connection.escape_bytea(value) if value
+        end
+
+        # Unescapes bytea output from a database to the binary string it represents.
+        # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
+        # on escaped binary output from database drive.
+        def unescape_bytea(value)
+          valid_raw_connection.unescape_bytea(value) if value
+        end
+
+        # Quotes strings for use in SQL input.
+        def quote_string(s) # :nodoc:
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
+        end
+
+        # Checks the following cases:
+        #
+        # - table_name
+        # - "table.name"
+        # - schema_name.table_name
+        # - schema_name."table.name"
+        # - "schema.name".table_name
+        # - "schema.name"."table.name"
+        def quote_table_name(name)
+          QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+        end
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        end
+
+        # Quotes column names for use in SQL queries.
+        def quote_column_name(name) # :nodoc:
+          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(name.to_s).freeze
+        end
+
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(name)
+          PG::Connection.quote_ident(name)
+        end
+
+        # Quote date/time values for use in SQL input.
+        def quoted_date(value) # :nodoc:
+          if value.year <= 0
+            bce_year = format("%04d", -value.year + 1)
+            super.sub(/^-?\d+/, bce_year) + " BC"
+          else
+            super
+          end
+        end
+
+        def quoted_binary(value) # :nodoc:
+          "'#{escape_bytea(value.to_s)}'"
+        end
+
+        # Does not quote function default values for UUID columns
+        def quote_default_value(value, column) # :nodoc:
+          if column.type == :uuid && value =~ /\(\)/
+            value
+          else
+            quote(value, column)
+          end
+        end
+
+        def quote(value)
+          case value
+          when Numeric
+            if value.finite?
+              super
+            else
+              "'#{value}'"
+            end
+          when Type::Binary::Data
+            "'#{escape_bytea(value.to_s)}'"
+          else
+            super
+          end
+        end
+
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value.call
+          elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
+            value # Does not quote function default values for UUID columns
+          else
+            super
+          end
+        end
+
+        def type_cast(value)
+          case value
+          when Type::Binary::Data
+            # Return a bind param hash with format as binary.
+            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+            # for more information
+            { value: value.to_s, format: 1 }
+          else
+            super
+          end
+        end
+
+        def lookup_cast_type_from_column(column) # :nodoc:
+          verify! if type_map.nil?
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        end
+
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+            )
+            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+            )
+            (?:\s+COLLATE\s+"\w+")?
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ReferentialIntegrity # :nodoc:
+        def supports_disable_referential_integrity? # :nodoc:
+          true
+        end
+
+        def disable_referential_integrity # :nodoc:
+          yield
+        end
+      end
+    end
+  end
+end