peasys-ruby 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2bfe718a25db8bdd2f49fa52d98d431b72bcc7615a8228b39e57d8e92b3d587
-  data.tar.gz: 896d7f841636adec7f73a3b3f32beb5ede86267c27622b825d9c4acf9464d3e0
+  metadata.gz: 419d2e97864d0ff2a64d3680138f4d44159bff0645a14e985b52a368e0e031bf
+  data.tar.gz: 7c3e3fbf3805ae4b39979560886759198d56b2ce36b2536d69130db0002f41d4
 SHA512:
-  metadata.gz: 0fb9b7343f3fdf459aff902176db299311b6d88a23457ac0fc1c88821cf3a716364d3eaf0fb82da1066b53972679450d053ecc32f3969d0bc3ec77a2dafcd9c1
-  data.tar.gz: 2a8c6efd843b885428da0fa402f4d0b8bded3234a19700b26ea132429cef0169ac21f1f7fb0e830300bd8c8c8614b4c7e4f0ad0beebfd812c33bb3680fc9fab4
+  metadata.gz: 10f2c9b8313fbad9130bbd2b075642046ee42aec1c4b3f169037def314a76db368bd769bf6bc50087fd48a790aea02e3eb0477ca484fc49a65c90e4e4e6ec0cd
+  data.tar.gz: 0a37b235628fbc62a89e6362c4a49b73fd21d93bb2c9b86684f4e32c27ec14434f3821b9c94a6a608143f0f1adc06351575a2a68ff4c62d51ea4ff61e484e874

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      class Column < ConnectionAdapters::Column
+        attr_reader :auto_increment
+
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, comment: nil, auto_increment: false, **)
+          super(name, default, sql_type_metadata, null, default_function, comment: comment)
+          @auto_increment = auto_increment
+        end
+
+        def auto_increment?
+          @auto_increment
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      module DatabaseStatements
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :rollback, :savepoint, :release, :set
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql)
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def internal_exec_query(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          type_casted_binds = type_casted_binds(binds)
+          bound_sql = bind_params_to_sql(sql, type_casted_binds)
+
+          log(bound_sql, name, binds, type_casted_binds, async: async) do |notification_payload|
+            with_raw_connection do |conn|
+              columns, rows = execute_and_extract(conn, bound_sql)
+              verified!
+              result = build_result(columns: columns, rows: rows)
+              notification_payload[:row_count] = result.length if notification_payload
+              result
+            end
+          end
+        end
+
+        def execute(sql, name = nil, allow_retry: false)
+          sql = transform_query(sql)
+          check_if_write_query(sql)
+          mark_transaction_written_if_write(sql)
+
+          log(sql, name) do
+            with_raw_connection do |conn|
+              execute_and_extract(conn, sql)
+              verified!
+            end
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = [])
+          sql = transform_query(sql)
+          type_casted_binds = type_casted_binds(binds)
+          bound_sql = bind_params_to_sql(sql, type_casted_binds)
+
+          log(bound_sql, name, binds, type_casted_binds) do
+            with_raw_connection do |conn|
+              keyword = bound_sql.strip.split(/\s+/, 2).first.upcase
+              case keyword
+              when "DELETE"
+                response = conn.execute_delete(bound_sql)
+                raise_if_failed(response, bound_sql)
+                verified!
+                response.row_count
+              when "UPDATE"
+                response = conn.execute_update(bound_sql)
+                raise_if_failed(response, bound_sql)
+                verified!
+                response.row_count
+              else
+                execute_and_extract(conn, bound_sql)
+                verified!
+                0
+              end
+            end
+          end
+        end
+        alias exec_update exec_delete
+
+        def begin_db_transaction
+          # DB2 on IBM i uses implicit transactions.
+          # We send a SET TRANSACTION ISOLATION LEVEL to mark the start.
+          # Alternatively, we just track state -- COMMIT/ROLLBACK are explicit.
+        end
+
+        def commit_db_transaction
+          with_raw_connection do |conn|
+            conn.execute_sql("COMMIT")
+          end
+        end
+
+        def exec_rollback_db_transaction
+          with_raw_connection do |conn|
+            conn.execute_sql("ROLLBACK")
+          end
+        end
+
+        def default_sequence_name(table_name, _column = nil)
+          nil
+        end
+
+        private
+
+          # Transposes PeaSelectResponse columnar format to row-based format.
+          #
+          # PeaClient returns: { "COL1" => ["a","b"], "COL2" => [1, 2] }
+          # AR expects: columns=["col1","col2"], rows=[["a",1],["b",2]]
+          def transpose_columnar_result(response)
+            columns = response.columns_name.map { |c| c.to_s.downcase }
+            row_count = response.row_count.to_i
+            return [columns, []] if row_count == 0
+
+            rows = Array.new(row_count) { Array.new(columns.size) }
+
+            response.columns_name.each_with_index do |original_name, col_idx|
+              values = response.result[original_name] || []
+              values.each_with_index do |val, row_idx|
+                rows[row_idx][col_idx] = val
+              end
+            end
+
+            [columns, rows]
+          end
+
+          # Routes SQL to the appropriate PeaClient method based on the statement keyword.
+          def execute_and_extract(conn, sql)
+            keyword = sql.strip.split(/\s+/, 2).first.upcase
+
+            case keyword
+            when "SELECT", "WITH"
+              response = conn.execute_select(sql)
+              raise_if_failed(response, sql)
+              transpose_columnar_result(response)
+            when "INSERT"
+              response = conn.execute_insert(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            when "UPDATE"
+              response = conn.execute_update(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            when "DELETE"
+              response = conn.execute_delete(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            when "CREATE"
+              response = conn.execute_create(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            when "ALTER"
+              response = conn.execute_alter(sql, false)
+              raise_if_failed(response, sql)
+              [[], []]
+            when "DROP"
+              response = conn.execute_drop(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            else
+              # SET, COMMIT, ROLLBACK, GRANT, REVOKE, etc.
+              response = conn.execute_sql(sql)
+              raise_if_failed(response, sql)
+              [[], []]
+            end
+          end
+
+          def raise_if_failed(response, sql)
+            return if response.has_succeeded
+
+            raise ActiveRecord::StatementInvalid.new(
+              "DB2 Error [#{response.sql_state}]: #{response.sql_message}",
+              sql: sql,
+              connection_pool: @pool
+            )
+          end
+
+          # PeaClient has no prepared statement support.
+          # Substitutes bind parameters (?) directly into SQL with proper quoting.
+          def bind_params_to_sql(sql, type_casted_binds)
+            return sql if type_casted_binds.empty?
+
+            binds = type_casted_binds.dup
+            sql.gsub("?") do
+              val = binds.shift
+              if val.nil?
+                "NULL"
+              else
+                quote(val)
+              end
+            end
+          end
+
+          def last_inserted_id(result)
+            with_raw_connection do |conn|
+              response = conn.execute_select(
+                "SELECT IDENTITY_VAL_LOCAL() AS LAST_ID FROM SYSIBM.SYSDUMMY1"
+              )
+              if response.has_succeeded && response.row_count.to_i > 0
+                val = response.result["LAST_ID"]&.first
+                val&.to_i
+              end
+            end
+          end
+
+          def build_truncate_statement(table_name)
+            "DELETE FROM #{quote_table_name(table_name)}"
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      module Quoting
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES  = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # "TABLE"."COLUMN" | function(one or two args)
+                  ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= %("#{name.to_s.gsub('"', '""').upcase}").freeze
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= begin
+              parts = name.to_s.split(".")
+              parts.map { |p| %("#{p.gsub('"', '""').upcase}") }.join(".").freeze
+            end
+          end
+        end
+
+        def quote_string(s)
+          s.gsub("'", "''")
+        end
+
+        def quoted_true
+          "1"
+        end
+
+        def unquoted_true
+          1
+        end
+
+        def quoted_false
+          "0"
+        end
+
+        def unquoted_false
+          0
+        end
+
+        def quoted_date(value)
+          if value.acts_like?(:time)
+            value.strftime("%Y-%m-%d %H:%M:%S.%6N")
+          else
+            value.to_s
+          end
+        end
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        end
+
+        private
+
+          def type_cast(value)
+            case value
+            when true  then 1
+            when false then 0
+            else super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/peasys/schema_creation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      class SchemaCreation < ConnectionAdapters::SchemaCreation
+        private
+
+          def add_column_options!(sql, options)
+            if options[:auto_increment]
+              sql << " GENERATED BY DEFAULT AS IDENTITY"
+            end
+
+            if options[:null] == false
+              sql << " NOT NULL"
+            end
+
+            if options.key?(:default) && !options[:auto_increment]
+              sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
+            end
+
+            sql
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Peasys
+      class SchemaDumper < ConnectionAdapters::SchemaDumper
+        private
+
+          def header(stream)
+            stream.puts <<~HEADER
+              # This file is auto-generated from the current state of the database. Instead
+              # of editing this file, please use the migrations feature of Active Record to
+              # incrementally modify your database, and then regenerate this schema definition.
+              #
+              # This file is the source Rails uses to define your schema when running `bin/rails
+              # db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+              # be faster and is potentially less error prone than running all of your
+              # migrations from scratch. Old migrations may fail to apply correctly if those
+              # migrations use external dependencies or application code.
+              #
+              # It's strongly recommended that you check this file into your version control system.
+
+              ActiveRecord::Schema[#{ActiveRecord::Migration.current_version}].define(version: #{define_params}) do
+            HEADER
+          end
+
+          # DB2 identity columns should be dumped as `bigint` or `integer` primary keys
+          # with no explicit default (Rails infers the auto-increment behavior).
+          def column_spec(column)
+            spec = super
+            spec[:auto_increment] = "true" if column.respond_to?(:auto_increment?) && column.auto_increment?
+            spec
+          end
+
+          # Override to use DB2-specific type names in the dump
+          def schema_type(column)
+            case column.sql_type
+            when /\ACLOB\z/i
+              :text
+            when /\ABLOB\z/i
+              :binary
+            when /\ASMALLINT\z/i
+              :boolean
+            when /\ATIMESTAMP\z/i
+              :datetime
+            when /\ADOUBLE\z/i
+              :float
+            when /\ABIGINT\z/i
+              :bigint
+            else
+              super
+            end
+          end
+
+          # Override to handle DB2's specific schema limit/precision/scale
+          def schema_limit(column)
+            case column.sql_type
+            when /\ASMALLINT\z/i, /\AINTEGER\z/i, /\ABIGINT\z/i,
+                 /\ACLOB\z/i, /\ABLOB\z/i, /\ADOUBLE\z/i, /\ATIMESTAMP\z/i
+              nil
+            else
+              super
+            end
+          end
+
+          def schema_precision(column)
+            case column.sql_type
+            when /\ATIMESTAMP\z/i
+              nil
+            else
+              super
+            end
+          end
+
+          # DB2 defaults that should not be dumped
+          def schema_default(column)
+            return nil if column.respond_to?(:auto_increment?) && column.auto_increment?
+
+            super
+          end
+
+          def explicit_primary_key_default?(column)
+            column.respond_to?(:auto_increment?) && column.auto_increment?
+          end
+      end
+    end
+  end
+end