activerecord-redshift-adapter 8.0.0.beta2 → 8.1.0

data/lib/active_record/connection_adapters/redshift_8_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_8_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_8_1/quoting.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module Quoting
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+          QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+          # 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
+
+          # 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
+
+          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
+
+        # 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
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        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
+      end
+    end
+  end
+end

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

data/lib/active_record/connection_adapters/redshift_8_1/schema_definitions.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ColumnMethods
+        # Defines the primary key field.
+        # Use of the native PostgreSQL UUID type is supported, and can be used
+        # by defining your tables as such:
+        #
+        #   create_table :stuffs, id: :uuid do |t|
+        #     t.string :content
+        #     t.timestamps
+        #   end
+        #
+        # By default, this will use the +uuid_generate_v4()+ function from the
+        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
+        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
+        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
+        # set the +:default+ option to +nil+:
+        #
+        #   create_table :stuffs, id: false do |t|
+        #     t.primary_key :id, :uuid, default: nil
+        #     t.uuid :foo_id
+        #     t.timestamps
+        #   end
+        #
+        # You may also pass a different UUID generation function from +uuid-ossp+
+        # or another library.
+        #
+        # Note that setting the UUID primary key default value to +nil+ will
+        # require you to assure that you always provide a UUID value before saving
+        # a record (as primary keys cannot be +nil+). This might be done via the
+        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
+        def primary_key(name, type = :primary_key, **options)
+          return super unless type == :uuid
+
+          options[:default] = options.fetch(:default, 'uuid_generate_v4()')
+          options[:primary_key] = true
+          column name, type, options
+        end
+
+        def json(name, **options)
+          column(name, :json, options)
+        end
+
+        def jsonb(name, **options)
+          column(name, :jsonb, options)
+        end
+      end
+
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        private
+
+        def create_column_definition(*args)
+          Redshift::ColumnDefinition.new(*args)
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/redshift_8_1/schema_dumper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module ColumnDumper
+        # Adds +:array+ option to the default set provided by the
+        # AbstractAdapter
+        def prepare_column_options(column) # :nodoc:
+          spec = super
+          spec[:default] = "\"#{column.default_function}\"" if column.default_function
+          spec
+        end
+      end
+    end
+  end
+end