activerecord-cipherstash-pg-adapter 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdfb2bb3cfba47a44161b2bf24d1a6dbeb6c61832cba81f4d076b05d560962cc
-  data.tar.gz: 5683664b0a8102793f861a0a50b8ef6e05a0f3b103fcbcea6b4e9bed89a80b89
+  metadata.gz: f91280c762358755ec87fbfb247164cff70519f1b8eb1befcd2a7cb65e18f61d
+  data.tar.gz: fe9e7177ade9fbf67e02048c6b511de3d949d2d4333b45dfc96181ffacca296a
 SHA512:
-  metadata.gz: 2d6ce8e4dfca6b40d7f2da7f2761c0889c0a4d37a7e6c85ee4c6c1bc85bd5804eefc76dd150fb4be8d82be560ae0ad466f11c53d817581c28d18eb1bfbaed467
-  data.tar.gz: 4a2c9005b6258cb55b9a95b4331df99543ee8d0945d3994bd47655b7d66700f50f7bec05b0b68d88f5fcc7801e93e633d35f7ceebf004babe49c6de81b92afde
+  metadata.gz: 7620f50195e83042060930382b7af7021e261e48ad6b0b6ef3f13e23e50f9bd69210ab9c4ec621097baf9402fe628fae5d4438c75d11dc6e6df2d1d412e62ea3
+  data.tar.gz: 1b1f84b66a3fe9b60ad596341cd1fba0949eab05e473e540baffd23bd3f0ad62c711f4b59201899c80ae6e59f837919552b5efe859f4f3da30d374b2d8482ee3

data/CHANGELOG.md

@@ -6,6 +6,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+## [0.8.2] - 2023-09-25
+
+- Update supported Active Record version to <= 7.1.
+
 ## [0.8.1] - 2023-09-14
 
 - Update max supported Active Record dep to < version 7.1.

data/activerecord-cipherstash-pg-adapter.gemspec

@@ -30,6 +30,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Runtime dependencies here; dev+test go in Gemfile.
-  spec.add_dependency "activerecord", ">= 6.0.0", "< 7.1"
+  spec.add_dependency "activerecord", ">= 6.0.0", "<= 7.1"
   spec.add_dependency "cipherstash-pg", ">= 1.0.0.beta.17"
 end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/column.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :oid, :fmod, to: :sql_type_metadata
+
+        def initialize(*, serial: nil, generated: nil, **)
+          super
+          @serial = serial
+          @generated = generated
+        end
+
+        def serial?
+          @serial
+        end
+        alias_method :auto_incremented_by_db?, :serial?
+
+        def virtual?
+          # We assume every generated column is virtual, no matter the concrete type
+          @generated.present?
+        end
+
+        def has_default?
+          super && !virtual?
+        end
+
+        def array
+          sql_type_metadata.sql_type.end_with?("[]")
+        end
+        alias :array? :array
+
+        def enum?
+          type == :enum
+        end
+
+        def sql_type
+          super.delete_suffix("[]")
+        end
+
+        def init_with(coder)
+          @serial = coder["serial"]
+          @generated = coder["generated"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["serial"] = @serial
+          coder["generated"] = @generated
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            serial? == other.serial?
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            serial?.hash
+        end
+      end
+    end
+    CipherStashPGColumn = CipherStashPG::Column # :nodoc:
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/database_statements.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module DatabaseStatements
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = internal_exec_query(sql, "EXPLAIN", binds)
+          CipherStashPG::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|
+              conn.async_exec(sql).map_types!(@type_map_for_results).values
+            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 ::CipherStashPG::Result object on success
+        # or raising a ::CipherStashPG::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 ::CipherStashPG::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)
+              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 sql_for_insert(sql, pk, binds, returning) # :nodoc:
+          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
+
+          returning_columns = returning || Array(pk)
+
+          returning_columns_statement = returning_columns.map { |c| quote_column_name(c) }.join(", ")
+          sql = "#{sql} RETURNING #{returning_columns_statement}" if returning_columns.any?
+
+          super
+        end
+        private :sql_for_insert
+
+        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 # :nodoc:
+          internal_execute("BEGIN", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+        end
+
+        def begin_isolated_db_transaction(isolation) # :nodoc:
+          internal_execute("BEGIN ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
+        end
+
+        # Commits a transaction.
+        def commit_db_transaction # :nodoc:
+          internal_execute("COMMIT", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        end
+
+        # Aborts a transaction.
+        def exec_rollback_db_transaction # :nodoc:
+          cancel_any_running_query
+          internal_execute("ROLLBACK", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          internal_execute("ROLLBACK AND CHAIN", "TRANSACTION", allow_retry: false, materialize_transactions: true)
+        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 = [::CipherStashPG::PQTRANS_IDLE, ::CipherStashPG::PQTRANS_INTRANS, ::CipherStashPG::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 ::CipherStashPG::Error
+          end
+
+          def execute_batch(statements, name = nil)
+            execute(combine_multi_statements(statements))
+          end
+
+          def build_truncate_statements(table_names)
+            ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
+          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/7.1/cipherstash_pg/explain_pretty_printer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an 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
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/array.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Array < Type::Value # :nodoc:
+          include ActiveModel::Type::Helpers::Mutable
+
+          Data = Struct.new(:encoder, :values) # :nodoc:
+
+          attr_reader :subtype, :delimiter
+          delegate :type, :user_input_in_time_zone, :limit, :precision, :scale, to: :subtype
+
+          def initialize(subtype, delimiter = ",")
+            @subtype = subtype
+            @delimiter = delimiter
+
+            @pg_encoder = ::CipherStashPG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_decoder = ::CipherStashPG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
+          end
+
+          def deserialize(value)
+            case value
+            when ::String
+              type_cast_array(@pg_decoder.decode(value), :deserialize)
+            when Data
+              type_cast_array(value.values, :deserialize)
+            else
+              super
+            end
+          end
+
+          def cast(value)
+            if value.is_a?(::String)
+              value = begin
+                @pg_decoder.decode(value)
+              rescue TypeError
+                # malformed array string is treated as [], will raise in PG 2.0 gem
+                # this keeps a consistent implementation
+                []
+              end
+            end
+            type_cast_array(value, :cast)
+          end
+
+          def serialize(value)
+            if value.is_a?(::Array)
+              casted_values = type_cast_array(value, :serialize)
+              Data.new(@pg_encoder, casted_values)
+            else
+              super
+            end
+          end
+
+          def ==(other)
+            other.is_a?(Array) &&
+              subtype == other.subtype &&
+              delimiter == other.delimiter
+          end
+
+          def type_cast_for_schema(value)
+            return super unless value.is_a?(::Array)
+            "[" + value.map { |v| subtype.type_cast_for_schema(v) }.join(", ") + "]"
+          end
+
+          def map(value, &block)
+            value.map { |v| subtype.map(v, &block) }
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
+
+          def force_equality?(value)
+            value.is_a?(::Array)
+          end
+
+          private
+            def type_cast_array(value, method)
+              if value.is_a?(::Array)
+                value.map { |item| type_cast_array(item, method) }
+              else
+                @subtype.public_send(method, value)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/bit.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Bit < Type::Value # :nodoc:
+          def type
+            :bit
+          end
+
+          def cast_value(value)
+            if ::String === value
+              case value
+              when /^0x/i
+                value[2..-1].hex.to_s(2) # Hexadecimal notation
+              else
+                value                    # Bit-string notation
+              end
+            else
+              value.to_s
+            end
+          end
+
+          def serialize(value)
+            Data.new(super) if value
+          end
+
+          class Data
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              value
+            end
+
+            def binary?
+              /\A[01]*\Z/.match?(value)
+            end
+
+            def hex?
+              /\A[0-9A-F]*\Z/i.match?(value)
+            end
+
+            private
+              attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/bit_varying.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class BitVarying < OID::Bit # :nodoc:
+          def type
+            :bit_varying
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/bytea.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Bytea < Type::Binary # :nodoc:
+          def deserialize(value)
+            return if value.nil?
+            return value.to_s if value.is_a?(Type::Binary::Data)
+            PG::Connection.unescape_bytea(super)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/cidr.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Cidr < Type::Value # :nodoc:
+          def type
+            :cidr
+          end
+
+          def type_cast_for_schema(value)
+            # If the subnet mask is equal to /32, don't output it
+            if value.prefix == 32
+              "\"#{value}\""
+            else
+              "\"#{value}/#{value.prefix}\""
+            end
+          end
+
+          def serialize(value)
+            if IPAddr === value
+              "#{value}/#{value.prefix}"
+            else
+              value
+            end
+          end
+
+          def cast_value(value)
+            if value.nil?
+              nil
+            elsif String === value
+              begin
+                IPAddr.new(value)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/date.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/date_time.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+
+          protected
+            def real_type_unless_aliased(real_type)
+              ActiveRecord::ConnectionAdapters::CipherStashPGAdapter.datetime_type == real_type ? :datetime : real_type
+            end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/7.1/cipherstash_pg/oid/decimal.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/7.1/cipherstash_pg/oid/enum.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Enum < Type::Value # :nodoc:
+          def type
+            :enum
+          end
+
+          private
+            def cast_value(value)
+              value.to_s
+            end
+        end
+      end
+    end
+  end
+end