activerecord-redshift-adapter 0.9.10 → 8.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d981a65a30765fe36e5e58616007f33103f238596de10188107d5e7bbe677093
+  data.tar.gz: 78f40be0d77ab87f6e4b3b1f6857f84aae35d0b5184a6fe1b320b14c080bbce9
+SHA512:
+  metadata.gz: f8a9a3801675594bc2a3400c3a4d4657247614b250558c7c169c1f720c0b8f8ce333b29e6a1e621bd3557539c69c8a5ecb160d059049e80ab24d3c531350aecb
+  data.tar.gz: f75478c7a7df07526ad528e562978bae1918b8146562d42bab6fcf45c8f8eff749b67a3efa5dc08530285642d5ed1003247c2fa64bf3ce60f3482b9824a79580

data/LICENSE

@@ -1,4 +1,28 @@
-Copyright (c) 2010-2014, Fiksu, Inc.
+-----------------------------------------------------------------------------------
+The MIT License (MIT)
+
+Copyright (c) 2004-2013 David Heinemeier Hansson (original code author)
+Copyright (c) 2013 Minero Aoki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----------------------------------------------------------------------------------
+Copyright (c) 2010-2013, Fiksu, Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,101 +1,43 @@
-# activerecord-redshift-adapter
+activerecord-redshift-adapter
+==============================
 
-adapter for aws redshift for rails 3
+Amazon Redshift adapter for ActiveRecord 7+ (Rails 7+).
+This is a fork from https://github.com/pennylane-hq/activerecord-adapter-redshift, which is a fork from
+https://rubygems.org/gems/activerecord7-redshift-adapter hosted on a private Gitlab instance.
+It's itself forked the project from https://github.com/kwent/activerecord6-redshift-adapter
 
-Ripped from rails 3 postgresql.
+Thanks to the auhors.
 
-## example database.yml
-```yml
-common: &common
-  adapter: postgresql
-  username: postgres
-  encoding: SQL_ASCII
-  template: template0
-  pool: 5
-  timeout: 5000
+Usage
+-------------------
 
-redshiftdb: &redshiftdb
-  adapter: redshift
-  host: clustername.something.us-east-1.redshift.amazonaws.com
-  database: databasename
-  port: 5439
-  username: username
-  password: password
-
-redshift_development:
-  <<: *common
-  <<: *redshiftdb
-  database: databasename
-```
+For Rails, write following in Gemfile:
 
-## options
-```html
-<table>
-  <tr>
-    <th>option</th>
-    <th>description</th>
-  </tr>
-  <tr>
-    <th>schema_search_path</th>
-    <td>set schema_search_path. use default value if not given.</td>
-  </tr>
-  <tr>
-    <th>read_timezone</th>
-    <td>force timezone for datetime when select values. ActiveRecord default timezone will set if not given.</td>
-  </tr>
-</table>
+```ruby
+gem 'activerecord-redshift-adapter'
 ```
 
-## Have you considered using Partitioned gem?  It works with redshift!
-
-https://github.com/fiksu/partitioned
+Specify the adapter name in the `database.yml` file:
 
-## TableManager
-
-Helpful code to clone redshift tables
-
-```sql
-create table foos
-(
-  id int not null primary key distkey,
-   name varchar(255) unique sortkey
-);
+```YAML
+development:
+  adapter: redshift
+  host: host
+  port: port
+  database: db
+  username: user
+  password: password
+  encoding: utf8
 ```
 
+or use it directly in the URL when establishing a connection:
 ```ruby
-class Foo < ActiveRecord::Base
+class SomeModel < ApplicationRecord
+  establish_connection('redshift://username:password@host/database')
 end
-
-require 'activerecord_redshift_adapter'
-
-table_manager = ActiverecordRedshift::TableManager.new(Foo.connection, :exemplar_table_name => Foo.table_name)
-table_manager.duplicate_table
 ```
 
-yields:
-
-```sql
-  select oid from pg_namespace where nspname = 'public' limit 1;
-
-  select oid,reldiststyle from pg_class where relnamespace = 2200 and relname = 'foos' limit 1;
-
-  select contype,conkey from pg_constraint where connamespace = 2200 and conrelid = 212591;
-
-  select attname,attnum from pg_attribute where attrelid = 212591 and attnum in (2,1);
+License
+---------
 
-  show search_path;
-
-  set search_path = 'public';
-
-  select * from pg_table_def where tablename = 'foos' and schemaname = 'public';
-
-  create temporary table temporary_events_25343
-  (
-   id integer not null distkey,
-   name character varying(255),
-   primary key (id),
-   unique (name)
-  ) sortkey (name);
-
-  set search_path = '$user','public';
-```
+MIT license (same as ActiveRecord)

data/lib/active_record/connection_adapters/redshift_7_0/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_0/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_0/database_statements.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Redshift
+      module DatabaseStatements
+        def explain(arel, binds = [])
+          sql = "EXPLAIN #{to_sql(arel, binds)}"
+          ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+        end
+
+        class ExplainPrettyPrinter # :nodoc:
+          # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+          # PostgreSQL shell:
+          #
+          #                                     QUERY PLAN
+          #   ------------------------------------------------------------------------------
+          #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
+          #      Join Filter: (posts.user_id = users.id)
+          #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
+          #            Index Cond: (id = 1)
+          #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
+          #            Filter: (posts.user_id = 1)
+          #   (6 rows)
+          #
+          def pp(result)
+            header = result.columns.first
+            lines  = result.rows.map(&:first)
+
+            # We add 2 because there's one char of padding at both sides, note
+            # the extra hyphens in the example above.
+            width = [header, *lines].map(&:length).max + 2
+
+            pp = []
+
+            pp << header.center(width).rstrip
+            pp << '-' * width
+
+            pp += lines.map { |line| " #{line}" }
+
+            nrows = result.rows.length
+            rows_label = nrows == 1 ? 'row' : 'rows'
+            pp << "(#{nrows} #{rows_label})"
+
+            "#{pp.join("\n")}\n"
+          end
+        end
+
+        def select_value(arel, name = nil, binds = [])
+          # In Rails 5.2, arel_from_relation replaced binds_from_relation,
+          # so we see which method exists to get the variables
+          #
+          # In Rails 6.0 to_sql_and_binds began only returning sql, with
+          # to_sql_and_binds serving as a replacement
+          if respond_to?(:arel_from_relation, true)
+            arel = arel_from_relation(arel)
+            sql, binds = to_sql_and_binds(arel, binds)
+          else
+            arel, binds = binds_from_relation arel, binds
+            sql = to_sql(arel, binds)
+          end
+          execute_and_clear(sql, name, binds) do |result|
+            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
+          end
+        end
+
+        def select_values(arel, name = nil)
+          # In Rails 5.2, arel_from_relation replaced binds_from_relation,
+          # so we see which method exists to get the variables
+          #
+          # In Rails 6.0 to_sql_and_binds began only returning sql, with
+          # to_sql_and_binds serving as a replacement
+          if respond_to?(:arel_from_relation, true)
+            arel = arel_from_relation(arel)
+            sql, binds = to_sql_and_binds(arel, [])
+          else
+            arel, binds = binds_from_relation arel, []
+            sql = to_sql(arel, binds)
+          end
+
+          execute_and_clear(sql, name, binds) do |result|
+            if result.nfields > 0
+              result.column_values(0)
+            else
+              []
+            end
+          end
+        end
+
+        # Executes a SELECT query and returns an array of rows. Each row is an
+        # array of field values.
+        def select_rows(arel, name = nil, binds = [])
+          if respond_to?(:arel_from_relation, true)
+            arel = arel_from_relation(arel)
+            sql, binds = to_sql_and_binds(arel, [])
+          else
+            arel, binds = binds_from_relation arel, []
+            sql = to_sql(arel, binds)
+          end
+          execute_and_clear(sql, name, binds, &:values)
+        end
+
+        # The internal PostgreSQL identifier of the money data type.
+        MONEY_COLUMN_TYPE_OID = 790 # :nodoc:
+        # The internal PostgreSQL identifier of the BYTEA data type.
+        BYTEA_COLUMN_TYPE_OID = 17 # :nodoc:
+
+        # create a 2D array representing the result set
+        def result_as_array(res) # :nodoc:
+          # check if we have any binary column and if they need escaping
+          ftypes = Array.new(res.nfields) do |i|
+            [i, res.ftype(i)]
+          end
+
+          rows = res.values
+          return rows unless ftypes.any? do |_, x|
+            [BYTEA_COLUMN_TYPE_OID, MONEY_COLUMN_TYPE_OID].include?(x)
+          end
+
+          typehash = ftypes.group_by { |_, type| type }
+          binaries = typehash[BYTEA_COLUMN_TYPE_OID] || []
+          monies   = typehash[MONEY_COLUMN_TYPE_OID] || []
+
+          rows.each do |row|
+            # unescape string passed BYTEA field (OID == 17)
+            binaries.each do |index, _|
+              row[index] = unescape_bytea(row[index])
+            end
+
+            # If this is a money type column and there are any currency symbols,
+            # then strip them off. Indeed it would be prettier to do this in
+            # PostgreSQLColumn.string_to_decimal but would break form input
+            # fields that call value_before_type_cast.
+            monies.each do |index, _|
+              data = row[index]
+              # Because money output is formatted according to the locale, there are two
+              # cases to consider (note the decimal separators):
+              #  (1) $12,345,678.12
+              #  (2) $12.345.678,12
+              case data
+              when /^-?\D+[\d,]+\.\d{2}$/ # (1)
+                data.gsub!(/[^-\d.]/, '')
+              when /^-?\D+[\d.]+,\d{2}$/ # (2)
+                data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+              end
+            end
+          end
+        end
+
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) # :nodoc:
+          log(sql, name) do
+            result_as_array @connection.async_exec(sql)
+          end
+        end
+
+        # Executes an SQL statement, returning a PG::Result object on success
+        # or raising a PG::Error exception otherwise.
+        def execute(sql, name = nil)
+          log(sql, name) do
+            @connection.async_exec(sql)
+          end
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          execute_and_clear(sql, name, binds, prepare: prepare) do |result|
+            types = {}
+            fields = result.fields
+            fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = get_oid_type(ftype, fmod, fname)
+            end
+            ActiveRecord::Result.new(fields, result.values, types)
+          end
+        end
+        alias internal_exec_query exec_query
+
+        def exec_delete(sql, name = 'SQL', binds = [])
+          execute_and_clear(sql, name, binds, &:cmd_tuples)
+        end
+        alias exec_update exec_delete
+
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+          if pk.nil?
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk && use_insert_returning?
+
+          super
+        end
+
+        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+          val = exec_query(sql, name, binds)
+          if !use_insert_returning? && pk
+            unless sequence_name
+              table_ref = extract_table_ref_from_insert_sql(sql)
+              sequence_name = default_sequence_name(table_ref, pk)
+              return val unless sequence_name
+            end
+            last_insert_id_result(sequence_name)
+          else
+            val
+          end
+        end
+
+        # Begins a transaction.
+        def begin_db_transaction
+          execute 'BEGIN'
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          begin_db_transaction
+          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+        end
+
+        # Commits a transaction.
+        def commit_db_transaction
+          execute 'COMMIT'
+        end
+
+        # Aborts a transaction.
+        def exec_rollback_db_transaction
+          execute 'ROLLBACK'
+        end
+      end
+    end
+  end
+end

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