activerecord-oracle_enhanced-adapter 8.1.2 → 8.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0a57a3c3e6704c929a68d675c82aefc07cb37d5d243d3b751efa8b1f25e45e
-  data.tar.gz: 808f61757c1330f099256c237976febf14b1b524b7632d88bac3d13aeb98897e
+  metadata.gz: 3f69a5874a83fcb0afd6b60ae09f61e0a300201cf3a99b6aee5523dcd92a985b
+  data.tar.gz: 8eee0fdb3853c42f27d37b37726ea9c4d685cadc047d00971291b0efe36503bd
 SHA512:
-  metadata.gz: 47bc577a39b3919ac687bc465db2a11e7ac449afb62ecd9cc3373e87b26b5ef821db8c0e0bbb0bb99e814501a49e7b7b003ac41c5748cd19a994945dfed999f5
-  data.tar.gz: da7d7996aab9d7912eff0ca4895a580db986246f9ebab0ea98e7a50490537c87cfc6c72f23eb117c703ede774e3bf85d0df499eaf1747248f7bc2118f5b900c7
+  metadata.gz: d8f684da4497ca2b4534744100d2c1468a7871420b127d4996816057e90d62213e5f456816c1e294920609f6f01122c778c0ff76b7479e3fa52b8f19c4694728
+  data.tar.gz: a2d729ffbcf21518d3b5a291e913c79104308d191e2ee6a54ac60b18418f4c8732e3069da2ecd5302cc6dd9f10e43d35c043fbeba204d99cb0b6e3b527cc0479

data/VERSION

@@ -1 +1 @@
-8.1.2
+8.1.4

data/lib/active_record/connection_adapters/oracle_enhanced/connection.rb

@@ -16,102 +16,19 @@ module ActiveRecord
           end
         end
 
-        attr_reader :raw_connection
+        attr_reader :raw_connection, :owner
 
         private
-          # Used always by JDBC connection as well by OCI connection when describing tables over database link
-          def describe(name)
-            name = name.to_s
-            if name.include?("@")
-              raise ArgumentError "db link is not supported"
-            else
-              default_owner = @owner
-            end
-            real_name = OracleEnhanced::Quoting.valid_table_name?(name) ? name.upcase : name
-            if real_name.include?(".")
-              table_owner, table_name = real_name.split(".")
-            else
-              table_owner, table_name = default_owner, real_name
-            end
-            sql = <<~SQL.squish
-              SELECT owner, table_name, 'TABLE' name_type
-              FROM all_tables
-              WHERE owner = :table_owner
-                AND table_name = :table_name
-              UNION ALL
-              SELECT owner, view_name table_name, 'VIEW' name_type
-              FROM all_views
-              WHERE owner = :table_owner
-                AND view_name = :table_name
-              UNION ALL
-              SELECT table_owner, table_name, 'SYNONYM' name_type
-              FROM all_synonyms
-              WHERE owner = :table_owner
-                AND synonym_name = :table_name
-              UNION ALL
-              SELECT table_owner, table_name, 'SYNONYM' name_type
-              FROM all_synonyms
-              WHERE owner = 'PUBLIC'
-                AND synonym_name = :real_name
-            SQL
-            if result = _select_one(sql, "CONNECTION", [table_owner, table_name, table_owner, table_name, table_owner, table_name, real_name])
-              case result["name_type"]
-              when "SYNONYM"
-                describe("#{result['owner'] && "#{result['owner']}."}#{result['table_name']}")
-              else
-                [result["owner"], result["table_name"]]
-              end
-            else
-              raise OracleEnhanced::ConnectionException, %Q{"DESC #{name}" failed; does it exist?}
-            end
-          end
-
           # Oracle column names by default are case-insensitive, but treated as upcase;
           # for neatness, we'll downcase within Rails. EXCEPT that folks CAN quote
           # their column names when creating Oracle tables, which makes then case-sensitive.
           # I don't know anybody who does this, but we'll handle the theoretical case of a
           # camelCase column name. I imagine other dbs handle this different, since there's a
           # unit test that's currently failing test_oci.
-          #
-          # `_oracle_downcase` is expected to be called only from
-          # `ActiveRecord::ConnectionAdapters::OracleEnhanced::OCIConnection`
-          # or `ActiveRecord::ConnectionAdapters::OracleEnhanced::JDBCConnection`.
-          # Other method should call `ActiveRecord:: ConnectionAdapters::OracleEnhanced::Quoting#oracle_downcase`
-          # since this is kind of quoting, not connection.
-          # To avoid it is called from anywhere else, added _ at the beginning of the method name.
           def _oracle_downcase(column_name)
             return nil if column_name.nil?
             /[a-z]/.match?(column_name) ? column_name : column_name.downcase
           end
-
-          # _select_one and _select_value methods are expected to be called
-          # only from `ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection#describe`
-          # Other methods should call `ActiveRecord::ConnectionAdapters::DatabaseStatements#select_one`
-          # and  `ActiveRecord::ConnectionAdapters::DatabaseStatements#select_value`
-          # To avoid called from its subclass added a underscore in each method.
-
-          # Returns a record hash with the column names as keys and column values
-          # as values.
-          # binds is a array of native values in contrast to ActiveRecord::Relation::QueryAttribute
-          def _select_one(arel, name = nil, binds = [])
-            cursor = prepare(arel)
-            cursor.bind_params(binds)
-            cursor.exec
-            columns = cursor.get_col_names.map do |col_name|
-              _oracle_downcase(col_name)
-            end
-            row = cursor.fetch
-            columns.each_with_index.to_h { |x, i| [x, row[i]] } if row
-          ensure
-            cursor.close
-          end
-
-          # Returns a single value from a record
-          def _select_value(arel, name = nil, binds = [])
-            if result = _select_one(arel, name, binds)
-              result.values.first
-            end
-          end
       end
 
       # Returns array with major and minor version of database (e.g. [12, 1])

data/lib/active_record/connection_adapters/oracle_enhanced/jdbc_connection.rb

@@ -522,11 +522,6 @@ module ActiveRecord
           end
         end
 
-        # To allow private method called from `JDBCConnection`
-        def describe(name)
-          super
-        end
-
         # Return java.sql.SQLException error code
         def error_code(exception)
           case exception

data/lib/active_record/connection_adapters/oracle_enhanced/oci_connection.rb

@@ -237,10 +237,6 @@ module ActiveRecord
           lob.write value
         end
 
-        def describe(name)
-          super
-        end
-
         # Return OCIError error code
         def error_code(exception)
           case exception

data/lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -53,7 +53,7 @@ module ActiveRecord
         end
 
         def data_source_exists?(table_name)
-          (_owner, _table_name) = _connection.describe(table_name)
+          (_owner, _table_name) = resolve_data_source_name(table_name)
           true
         rescue
           false
@@ -87,7 +87,7 @@ module ActiveRecord
         end
 
         def indexes(table_name) # :nodoc:
-          (_owner, table_name) = _connection.describe(table_name)
+          (_owner, table_name) = resolve_data_source_name(table_name)
           default_tablespace_name = default_tablespace
 
           result = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
@@ -259,7 +259,7 @@ module ActiveRecord
           schema_cache.clear_data_source_cache!(table_name.to_s)
           schema_cache.clear_data_source_cache!(new_name.to_s)
           execute "RENAME #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-          execute "RENAME #{quote_table_name("#{table_name}_seq")} TO #{default_sequence_name(new_name)}" rescue nil
+          execute "RENAME #{default_sequence_name(table_name)} TO #{default_sequence_name(new_name)}" rescue nil
 
           rename_table_indexes(table_name, new_name, **options)
         end
@@ -368,7 +368,7 @@ module ActiveRecord
         #
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
-          (_owner, table_name) = _connection.describe(table_name)
+          (_owner, table_name) = resolve_data_source_name(table_name)
           result = select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("index_name", index_name.to_s.upcase)])
             SELECT 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -511,7 +511,7 @@ module ActiveRecord
 
         def table_comment(table_name) # :nodoc:
           # TODO
-          (_owner, table_name) = _connection.describe(table_name)
+          (_owner, table_name) = resolve_data_source_name(table_name)
           select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -527,7 +527,7 @@ module ActiveRecord
 
         def column_comment(table_name, column_name) # :nodoc:
           # TODO: it  does not exist in Abstract adapter
-          (_owner, table_name) = _connection.describe(table_name)
+          (_owner, table_name) = resolve_data_source_name(table_name)
           select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -555,7 +555,7 @@ module ActiveRecord
 
         # get table foreign keys for schema dump
         def foreign_keys(table_name) # :nodoc:
-          (_owner, desc_table_name) = _connection.describe(table_name)
+          (_owner, desc_table_name) = resolve_data_source_name(table_name)
 
           fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
@@ -733,6 +733,80 @@ module ActiveRecord
 
             execute("ALTER INDEX #{quote_column_name(index_name)} REBUILD TABLESPACE #{tablespace}")
           end
+
+          # Resolves an Oracle data-source name to its underlying [owner, table_name]
+          # by following synonyms through the catalog. Defaults the schema to
+          # `_connection.owner` (the adapter's configured default schema, taken
+          # from `config[:schema]` or `config[:username]`) when the name is not
+          # schema-qualified. This is distinct from
+          # `SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA')`, which can differ after
+          # `ALTER SESSION SET CURRENT_SCHEMA`.
+          # Raises OracleEnhanced::ConnectionException if the object does not
+          # exist or if synonym resolution produces a looping chain.
+          def resolve_data_source_name(name)
+            visited = Set.new
+            loop do
+              schema, identifier = extract_schema_qualified_name(name)
+              real_name = schema ? "#{schema}.#{identifier}" : identifier
+              owner = schema || _connection.owner
+
+              unless visited.add?([owner, identifier])
+                raise OracleEnhanced::ConnectionException,
+                      %Q{"DESC #{name}" failed; looping chain of synonyms}
+              end
+
+              binds = [
+                bind_string("table_owner", owner),
+                bind_string("table_name", identifier),
+                bind_string("real_name", real_name),
+              ]
+              # Single-pass lookup against all_objects, ordered so the first row
+              # is the one the legacy 4-way UNION ALL (all_tables, all_views,
+              # owner synonym, public synonym) would have returned: prefer a
+              # match in the caller's schema over PUBLIC, and within a schema
+              # prefer TABLE over VIEW over SYNONYM.
+              result = select_one(<<~SQL.squish, "SCHEMA", binds)
+                SELECT owner, object_name table_name, object_type name_type
+                FROM all_objects
+                WHERE ((owner = :table_owner AND object_name = :table_name)
+                   OR (owner = 'PUBLIC' AND object_name = :real_name))
+                  AND object_type IN ('TABLE', 'VIEW', 'SYNONYM')
+                ORDER BY DECODE(owner, 'PUBLIC', 2, 1),
+                         DECODE(object_type, 'TABLE', 1, 'VIEW', 2, 'SYNONYM', 3)
+              SQL
+
+              raise OracleEnhanced::ConnectionException, %Q{"DESC #{name}" failed; does it exist?} unless result
+
+              if result["name_type"] == "SYNONYM"
+                synonym_binds = [
+                  bind_string("owner", result["owner"]),
+                  bind_string("synonym_name", result["table_name"]),
+                ]
+                syn = select_one(<<~SQL.squish, "SCHEMA", synonym_binds)
+                  SELECT table_owner, table_name
+                  FROM all_synonyms
+                  WHERE owner = :owner AND synonym_name = :synonym_name
+                SQL
+                raise OracleEnhanced::ConnectionException, %Q{"DESC #{name}" failed; does it exist?} unless syn
+                name = "#{syn['table_owner'] && "#{syn['table_owner']}."}#{syn['table_name']}"
+              else
+                return [result["owner"], result["table_name"]]
+              end
+            end
+          end
+
+          # Splits "schema.identifier" into its parts, returning [schema, identifier].
+          # Mirrors Rails' PostgreSQL/MySQL adapters: a non-qualified name yields
+          # schema = nil. Oracle-specific bits: rejects db links and upcases valid
+          # identifiers so catalog lookups match the stored upper-case names.
+          def extract_schema_qualified_name(string)
+            string = string.to_s
+            raise ArgumentError, "db link is not supported" if string.include?("@")
+
+            string = string.upcase if OracleEnhanced::Quoting.valid_table_name?(string)
+            schema, identifier = string.split(".") if string.include?(".")
+            [schema, identifier || string]
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -519,7 +519,7 @@ module ActiveRecord
         table_name = table_name.to_s
         do_not_prefetch = @do_not_prefetch_primary_key[table_name]
         if do_not_prefetch.nil?
-          owner, desc_table_name = _connection.describe(table_name)
+          owner, desc_table_name = resolve_data_source_name(table_name)
           @do_not_prefetch_primary_key[table_name] = do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name)
         end
         !do_not_prefetch
@@ -588,7 +588,7 @@ module ActiveRecord
       end
 
       def column_definitions(table_name)
-        (owner, desc_table_name) = _connection.describe(table_name)
+        (owner, desc_table_name) = resolve_data_source_name(table_name)
 
         select_all(<<~SQL.squish, "SCHEMA", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
           SELECT cols.column_name AS name, cols.data_type AS sql_type,
@@ -620,7 +620,7 @@ module ActiveRecord
       # Find a table's primary key and sequence.
       # *Note*: Only primary key is implemented - sequence will be nil.
       def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) # :nodoc:
-        (owner, desc_table_name) = _connection.describe(table_name)
+        (owner, desc_table_name) = resolve_data_source_name(table_name)
 
         seqs = select_values_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("owner", owner), bind_string("sequence_name", default_sequence_name(desc_table_name))])
           select us.sequence_name
@@ -662,7 +662,7 @@ module ActiveRecord
       end
 
       def primary_keys(table_name) # :nodoc:
-        (_owner, desc_table_name) = _connection.describe(table_name)
+        (_owner, desc_table_name) = resolve_data_source_name(table_name)
 
         pks = select_values_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("table_name", desc_table_name)])
           SELECT cc.column_name
@@ -685,8 +685,9 @@ module ActiveRecord
         # It does not construct DISTINCT clause. Just return column names for distinct.
         order_columns = orders.reject(&:blank?).map { |s|
             s = visitor.compile(s) unless s.is_a?(String)
-            # remove any ASC/DESC modifiers
-            s.gsub(/\s+(ASC|DESC)\s*?/i, "")
+            # remove any ASC/DESC and NULLS FIRST/LAST modifiers
+            s.gsub(/\s+(?:ASC|DESC)\b/i, "")
+             .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
           }.reject(&:blank?).map.with_index { |column, i|
             "FIRST_VALUE(#{column}) OVER (PARTITION BY #{columns.join(', ')} ORDER BY #{column}) AS alias_#{i}__"
           }

data/lib/arel/visitors/oracle.rb

@@ -172,8 +172,12 @@ module Arel # :nodoc: all
           end.flatten
           o.orders = []
           orders.each_with_index do |order, i|
-            o.orders <<
-              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i.match?(order)}")
+            parts = ["alias_#{i}__"]
+            parts << "DESC" if /\bdesc\b/i.match?(order)
+            if (nulls_match = order.match(/\bNULLS\s+(FIRST|LAST)\b/i))
+              parts << "NULLS #{nulls_match[1].upcase}"
+            end
+            o.orders << Nodes::SqlLiteral.new(parts.join(" "))
           end
           o
         end

data/lib/arel/visitors/oracle_common.rb

@@ -46,6 +46,35 @@ module Arel # :nodoc: all
         def schema_cache
           @connection.schema_cache
         end
+
+        def visit_Arel_Nodes_In(o, collector)
+          attr, values = o.left, o.right
+          return super unless values.is_a?(Array)
+
+          in_clause_length = @connection.in_clause_length
+          return super if values.length <= in_clause_length
+
+          # Split into multiple IN nodes and combine with OR
+          in_nodes = values.each_slice(in_clause_length).map do |slice|
+            Arel::Nodes::In.new(attr, slice)
+          end
+          or_node = Arel::Nodes::Or.new(in_nodes)
+          visit(Arel::Nodes::Grouping.new(or_node), collector)
+        end
+
+        def visit_Arel_Nodes_NotIn(o, collector)
+          attr, values = o.left, o.right
+          return super unless values.is_a?(Array)
+
+          in_clause_length = @connection.in_clause_length
+          return super if values.length <= in_clause_length
+
+          # Split into multiple NOT IN nodes and combine with AND
+          not_in_nodes = values.each_slice(in_clause_length).map do |slice|
+            Arel::Nodes::NotIn.new(attr, slice)
+          end
+          visit(Arel::Nodes::And.new(not_in_nodes), collector)
+        end
     end
   end
 end

data/spec/active_record/connection_adapters/oracle_enhanced/columns_for_distinct_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter#columns_for_distinct" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+
+  it "strips ASC modifier" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at ASC"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/\bASC\b/i)
+  end
+
+  it "strips DESC modifier" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at DESC"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/\bDESC\b/i)
+  end
+
+  it "strips NULLS FIRST modifier" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at NULLS FIRST"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/NULLS\s+FIRST/i)
+  end
+
+  it "strips NULLS LAST modifier" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at NULLS LAST"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/NULLS\s+LAST/i)
+  end
+
+  it "strips combined DESC NULLS LAST" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at DESC NULLS LAST"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/\bDESC\b/i)
+    expect(sql).not_to match(/NULLS/i)
+  end
+
+  it "strips combined ASC NULLS FIRST" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at ASC NULLS FIRST"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/\bASC\b/i)
+    expect(sql).not_to match(/NULLS/i)
+  end
+
+  it "strips lowercase desc nulls last" do
+    sql = @conn.columns_for_distinct(["posts.id"], ["posts.created_at desc nulls last"])
+    expect(sql).to include("FIRST_VALUE(posts.created_at)")
+    expect(sql).not_to match(/\bdesc\b/i)
+    expect(sql).not_to match(/nulls/i)
+  end
+
+  it "joins composite primary key columns in PARTITION BY" do
+    sql = @conn.columns_for_distinct(["posts.id", "posts.tenant_id"], ["posts.created_at DESC"])
+    expect(sql).to include("PARTITION BY posts.id, posts.tenant_id")
+  end
+
+  it "strips DESC NULLS LAST from an Arel ordering node" do
+    order_node = Arel::Table.new(:posts)[:created_at].desc.nulls_last
+    sql = @conn.columns_for_distinct(["posts.id"], [order_node])
+    expect(sql).to match(/FIRST_VALUE\("POSTS"\."CREATED_AT"\)/i)
+    expect(sql).not_to match(/\bDESC\b/i)
+    expect(sql).not_to match(/NULLS/i)
+  end
+
+  describe "integration with Arel::Visitors::Oracle#order_hacks" do
+    def compile_distinct_order(distinct_columns, order)
+      projection = "DISTINCT #{distinct_columns.join(', ')}, " \
+                   "#{@conn.columns_for_distinct(distinct_columns, [order])}"
+      stmt = Arel::Nodes::SelectStatement.new
+      stmt.cores.first.projections << Arel::Nodes::SqlLiteral.new(projection)
+      stmt.orders << (order.is_a?(String) ? Arel::Nodes::SqlLiteral.new(order) : order)
+      @conn.visitor.accept(stmt, Arel::Collectors::SQLString.new).value
+    end
+
+    it "preserves DESC NULLS LAST in the outer ORDER BY for a raw SQL order" do
+      sql = compile_distinct_order(["posts.id"], "posts.created_at DESC NULLS LAST")
+      expect(sql).to include("ORDER BY alias_0__ DESC NULLS LAST")
+    end
+
+    it "preserves DESC NULLS LAST in the outer ORDER BY for an Arel ordering node" do
+      order_node = Arel::Table.new(:posts)[:created_at].desc.nulls_last
+      sql = compile_distinct_order(["posts.id"], order_node)
+      expect(sql).to include("ORDER BY alias_0__ DESC NULLS LAST")
+    end
+
+    it "preserves NULLS FIRST without emitting DESC for an ASC-with-nulls order" do
+      sql = compile_distinct_order(["posts.id"], "posts.created_at ASC NULLS FIRST")
+      expect(sql).to match(/ORDER BY alias_0__ NULLS FIRST\b/)
+      expect(sql).not_to match(/alias_0__ DESC/)
+    end
+  end
+end

data/spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb

@@ -531,59 +531,177 @@ describe "OracleEnhancedConnection" do
     end
   end
 
-  describe "describe table" do
+  describe "resolve_data_source_name" do
     before(:all) do
-      @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS)
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      @conn = ActiveRecord::Base.connection
       @owner = CONNECTION_PARAMS[:username].upcase
     end
 
-    it "should describe existing table" do
-      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
-      expect(@conn.describe("test_employees")).to eq([@owner, "TEST_EMPLOYEES"])
-      @conn.exec "DROP TABLE test_employees" rescue nil
+    def resolve(name)
+      @conn.send(:resolve_data_source_name, name)
     end
 
-    it "should not describe non-existing table" do
-      expect { @conn.describe("test_xxx") }.to raise_error(ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException)
+    it "should resolve existing table" do
+      @conn.execute "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      expect(resolve("test_employees")).to eq([@owner, "TEST_EMPLOYEES"])
+      @conn.execute "DROP TABLE test_employees" rescue nil
     end
 
-    it "should describe table in other schema" do
-      expect(@conn.describe("sys.dual")).to eq(["SYS", "DUAL"])
+    it "should not resolve non-existing table" do
+      expect { resolve("test_xxx") }.to raise_error(ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException)
     end
 
-    it "should describe table in other schema if the schema and table are in different cases" do
-      expect(@conn.describe("SYS.dual")).to eq(["SYS", "DUAL"])
+    it "should resolve table in other schema" do
+      expect(resolve("sys.dual")).to eq(["SYS", "DUAL"])
     end
 
-    it "should describe existing view" do
-      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
-      @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
-      expect(@conn.describe("test_employees_v")).to eq([@owner, "TEST_EMPLOYEES_V"])
-      @conn.exec "DROP VIEW test_employees_v" rescue nil
-      @conn.exec "DROP TABLE test_employees" rescue nil
+    it "should resolve table in other schema if the schema and table are in different cases" do
+      expect(resolve("SYS.dual")).to eq(["SYS", "DUAL"])
     end
 
-    it "should describe view in other schema" do
-      expect(@conn.describe("sys.v_$version")).to eq(["SYS", "V_$VERSION"])
+    it "should resolve existing view" do
+      @conn.execute "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.execute "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
+      expect(resolve("test_employees_v")).to eq([@owner, "TEST_EMPLOYEES_V"])
+      @conn.execute "DROP VIEW test_employees_v" rescue nil
+      @conn.execute "DROP TABLE test_employees" rescue nil
     end
 
-    it "should describe existing private synonym" do
-      @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
-      expect(@conn.describe("test_dual")).to eq(["SYS", "DUAL"])
-      @conn.exec "DROP SYNONYM test_dual" rescue nil
+    it "should resolve view in other schema" do
+      expect(resolve("sys.v_$version")).to eq(["SYS", "V_$VERSION"])
     end
 
-    it "should describe existing public synonym" do
-      expect(@conn.describe("all_tables")).to eq(["SYS", "ALL_TABLES"])
+    it "should resolve existing materialized view" do
+      @conn.execute "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.execute "CREATE MATERIALIZED VIEW test_employees_mv AS SELECT * FROM test_employees" rescue nil
+      expect(resolve("test_employees_mv")).to eq([@owner, "TEST_EMPLOYEES_MV"])
+      @conn.execute "DROP MATERIALIZED VIEW test_employees_mv" rescue nil
+      @conn.execute "DROP TABLE test_employees" rescue nil
     end
 
-    if defined?(OCI8)
-      context "OCI8 adapter" do
-        it "should not fallback to SELECT-based logic when querying non-existent table information" do
-          expect(@conn).not_to receive(:select_one)
-          @conn.describe("non_existent") rescue ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException
-        end
+    it "should resolve existing private synonym" do
+      @conn.execute "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
+      expect(resolve("test_dual")).to eq(["SYS", "DUAL"])
+      @conn.execute "DROP SYNONYM test_dual" rescue nil
+    end
+
+    it "should resolve existing public synonym" do
+      expect(resolve("all_tables")).to eq(["SYS", "ALL_TABLES"])
+    end
+
+    # Exercises all five catalog paths (table, view, materialized view,
+    # private synonym, public synonym) for one underlying table in a single
+    # run. The individual cases above use disjoint fixtures; this one proves
+    # the DECODE-ordered all_objects lookup + synonym follow-through stays
+    # consistent when a private and a public synonym to the same table
+    # coexist, and that a materialized view created on the same base table
+    # resolves to the MV name (not the base table) as a sibling data source.
+    it "resolves table, view, materialized view, private synonym and public synonym for the same underlying table" do
+      @conn.execute "CREATE TABLE test_describe_all (id NUMBER)" rescue nil
+      @conn.execute "CREATE VIEW test_describe_all_v AS SELECT * FROM test_describe_all" rescue nil
+      @conn.execute "CREATE MATERIALIZED VIEW test_describe_all_mv AS SELECT * FROM test_describe_all" rescue nil
+      @conn.execute "CREATE SYNONYM test_describe_all_syn FOR test_describe_all" rescue nil
+      @conn.execute "CREATE PUBLIC SYNONYM test_describe_all_pub FOR #{@owner}.test_describe_all" rescue nil
+
+      expect(resolve("test_describe_all")).to eq([@owner, "TEST_DESCRIBE_ALL"])
+      expect(resolve("test_describe_all_v")).to eq([@owner, "TEST_DESCRIBE_ALL_V"])
+      expect(resolve("test_describe_all_mv")).to eq([@owner, "TEST_DESCRIBE_ALL_MV"])
+      expect(resolve("test_describe_all_syn")).to eq([@owner, "TEST_DESCRIBE_ALL"])
+      expect(resolve("test_describe_all_pub")).to eq([@owner, "TEST_DESCRIBE_ALL"])
+    ensure
+      @conn.execute "DROP PUBLIC SYNONYM test_describe_all_pub" rescue nil
+      @conn.execute "DROP SYNONYM test_describe_all_syn" rescue nil
+      @conn.execute "DROP MATERIALIZED VIEW test_describe_all_mv" rescue nil
+      @conn.execute "DROP VIEW test_describe_all_v" rescue nil
+      @conn.execute "DROP TABLE test_describe_all" rescue nil
+    end
+
+    it "raises when synonym resolution produces a looping chain" do
+      @conn.execute "CREATE SYNONYM test_cycle_a FOR test_cycle_b" rescue nil
+      @conn.execute "CREATE SYNONYM test_cycle_b FOR test_cycle_a" rescue nil
+      expect { resolve("test_cycle_a") }.to raise_error(
+        ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException,
+        /looping chain of synonyms/
+      )
+    ensure
+      @conn.execute "DROP SYNONYM test_cycle_a" rescue nil
+      @conn.execute "DROP SYNONYM test_cycle_b" rescue nil
+    end
+
+    it "raises when a multi-hop synonym chain eventually revisits an earlier link" do
+      @conn.execute "CREATE SYNONYM test_cycle_a FOR test_cycle_b" rescue nil
+      @conn.execute "CREATE SYNONYM test_cycle_b FOR test_cycle_c" rescue nil
+      @conn.execute "CREATE SYNONYM test_cycle_c FOR test_cycle_a" rescue nil
+      expect { resolve("test_cycle_a") }.to raise_error(
+        ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException,
+        /looping chain of synonyms/
+      )
+    ensure
+      @conn.execute "DROP SYNONYM test_cycle_a" rescue nil
+      @conn.execute "DROP SYNONYM test_cycle_b" rescue nil
+      @conn.execute "DROP SYNONYM test_cycle_c" rescue nil
+    end
+
+    it "raises ArgumentError when the name contains a db link" do
+      expect { resolve("test@db_link") }.to raise_error(ArgumentError, /db link is not supported/)
+    end
+
+    # The previous Connection#describe path bypassed the adapter's query machinery
+    # by driving a raw cursor, so its catalog lookup produced no sql.active_record
+    # event. Routing through select_one(..., "SCHEMA", ...) makes the lookup
+    # participate in logging, instrumentation, and the query cache. Lock that in
+    # so a future refactor can't silently regress to the raw-cursor path.
+    it "emits a SCHEMA sql.active_record event for the catalog lookup" do
+      @conn.execute "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      events = []
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        events << payload
       end
+      resolve("test_employees")
+      expect(events.map { |p| p[:name] }).to include("SCHEMA")
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+      @conn.execute "DROP TABLE test_employees" rescue nil
+    end
+  end
+
+  describe "extract_schema_qualified_name" do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      @conn = ActiveRecord::Base.connection
+    end
+
+    def extract(string)
+      @conn.send(:extract_schema_qualified_name, string)
+    end
+
+    it "returns [nil, identifier] for an unqualified name and upcases it" do
+      expect(extract("table_name")).to eq([nil, "TABLE_NAME"])
+    end
+
+    it "leaves an already upcased unqualified name as-is" do
+      expect(extract("TABLE_NAME")).to eq([nil, "TABLE_NAME"])
+    end
+
+    it "splits a schema-qualified name and upcases it" do
+      expect(extract("hr.dept")).to eq(["HR", "DEPT"])
+    end
+
+    it "upcases a qualified name whose parts are in different cases" do
+      expect(extract("SYS.dual")).to eq(["SYS", "DUAL"])
+    end
+
+    it "accepts a Symbol and coerces it to a string" do
+      expect(extract(:dept)).to eq([nil, "DEPT"])
+    end
+
+    it "raises ArgumentError when the name contains a db link" do
+      expect { extract("test@db_link") }.to raise_error(ArgumentError, /db link is not supported/)
+    end
+
+    it "does not upcase a name that is not a valid identifier" do
+      expect(extract('"Weird Name"')).to eq([nil, '"Weird Name"'])
     end
   end
 end

data/spec/active_record/connection_adapters/oracle_enhanced/schema_statements_spec.rb

@@ -296,6 +296,7 @@ describe "OracleEnhancedAdapter schema definition" do
     end
 
     after(:each) do
+      long_name = ("a" * (@conn.sequence_name_length - 3)).to_sym
       schema_define do
         drop_table :test_employees_no_primary_key, if_exists: true
         drop_table :test_employees, if_exists: true
@@ -303,6 +304,7 @@ describe "OracleEnhancedAdapter schema definition" do
         drop_table :test_employees_no_pkey, if_exists: true
         drop_table :new_test_employees_no_pkey, if_exists: true
         drop_table :aaaaaaaaaaaaaaaaaaaaaaaaaaa, if_exists: true
+        drop_table long_name, if_exists: true
       end
     end
 
@@ -329,6 +331,26 @@ describe "OracleEnhancedAdapter schema definition" do
         @conn.rename_table("test_employees_no_pkey", "new_test_employees_no_pkey")
       end.not_to raise_error
     end
+
+    it "renames the auto-generated sequence when the source table name is long enough to truncate it" do
+      long_source = "a" * (@conn.sequence_name_length - 3)
+      schema_define do
+        create_table long_source.to_sym, force: true do |t|
+          t.string :first_name
+        end
+      end
+
+      expected_old_seq = @conn.default_sequence_name(long_source).upcase
+      expected_new_seq = @conn.default_sequence_name("new_test_employees").upcase
+
+      @conn.rename_table(long_source, "new_test_employees")
+
+      sequences = @conn.select_values(
+        "SELECT sequence_name FROM user_sequences WHERE sequence_name IN ('#{expected_old_seq}', '#{expected_new_seq}')"
+      )
+      expect(sequences).to include(expected_new_seq)
+      expect(sequences).not_to include(expected_old_seq)
+    end
   end
 
   describe "add index" do

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -244,7 +244,7 @@ describe "OracleEnhancedAdapter" do
       class ::TestPost < ActiveRecord::Base
         has_many :test_comments
       end
-      @ids = (1..1010).to_a
+      @ids = (1..2010).to_a
       TestPost.transaction do
         @ids.each do |id|
           TestPost.create!(id: id, title: "Title #{id}")
@@ -272,6 +272,38 @@ describe "OracleEnhancedAdapter" do
       posts = TestPost.where(id: [*@ids, nil]).to_a
       expect(posts.size).to eq(@ids.size)
     end
+
+    # some frameworks like baby_squeel construct Arel objects directly
+    it "should allow more than 1000 items using Arel::Nodes::In" do
+      table = TestPost.arel_table
+      in_node = Arel::Nodes::In.new(table[:id], @ids)
+      query = table.where(in_node).project(Arel.star)
+
+      sql = query.to_sql
+      posts = TestPost.connection.select_all(sql).to_a
+      expect(posts.size).to eq(@ids.size)
+
+      # SQL contains multiple IN clauses (split due to 1000 limit)
+      expect(sql.scan(/IN \(/).size).to be > 1
+    end
+
+    it "should allow more than 1000 items using Arel::Nodes::NotIn" do
+      ids = @ids.dup
+      non_not_in = ids.pop
+
+      table = TestPost.arel_table
+      not_in_node = Arel::Nodes::NotIn.new(table[:id], ids)
+      query = table.where(not_in_node).project(Arel.star)
+
+      sql = query.to_sql
+      posts = TestPost.connection.select_all(sql).to_a
+
+      expect(posts.size).to eq(1)
+      expect(posts.first["id"]).to eq(non_not_in)
+
+      # SQL contains multiple NOT IN clauses (split due to 1000 limit)
+      expect(sql.scan(/NOT IN \(/).size).to be > 1
+    end
   end
 
   describe "with statement pool" do
@@ -806,10 +838,54 @@ describe "OracleEnhancedAdapter" do
       ActiveRecord::Base.clear_cache!
     end
 
+    before(:each) do
+      TestPost.delete_all
+      TestComment.delete_all
+    end
+
     it "should not raise undefined method length" do
       post = TestPost.create!
       post.test_comments << TestComment.create!
       expect(TestComment.where(test_post_id: TestPost.select(:id)).size).to eq(1)
     end
+
+    it "should handle IN with subquery using Arel::Nodes::In" do
+      post = TestPost.create!
+      post.test_comments << TestComment.create!
+
+      table = TestComment.arel_table
+      subquery = TestPost.select(:id).arel
+      in_node = Arel::Nodes::In.new(table[:test_post_id], subquery)
+      query = table.where(in_node).project(Arel.star)
+
+      sql = query.to_sql
+      comments = TestComment.connection.select_all(sql).to_a
+      expect(comments.size).to eq(1)
+
+      # SQL should contain IN with subquery, not split into multiple IN clauses
+      expect(sql).to match(/IN \(+SELECT/)
+      expect(sql.scan(/IN \(/).size).to eq(1)
+    end
+
+    it "should handle NOT IN with subquery using Arel::Nodes::NotIn" do
+      post = TestPost.create!
+      TestComment.create!(test_post_id: post.id)
+      orphan_comment = TestComment.create!(test_post_id: post.id + 1)
+
+      table = TestComment.arel_table
+      subquery = TestPost.select(:id).arel
+      not_in_node = Arel::Nodes::NotIn.new(table[:test_post_id], subquery)
+      query = table.where(not_in_node).project(Arel.star)
+
+      sql = query.to_sql
+      comments = TestComment.connection.select_all(sql).to_a
+
+      expect(comments.size).to eq(1)
+      expect(comments.first["id"]).to eq(orphan_comment.id)
+
+      # SQL should contain NOT IN with subquery, not split into multiple NOT IN clauses
+      expect(sql).to match(/NOT IN \(+SELECT/)
+      expect(sql.scan(/NOT IN \(/).size).to eq(1)
+    end
   end
 end

data/spec/support/create_oracle_enhanced_users.sql

@@ -4,28 +4,12 @@ CREATE USER oracle_enhanced IDENTIFIED BY oracle_enhanced;
 
 GRANT unlimited tablespace, create session, create table, create sequence,
 create procedure, create trigger, create view, create materialized view,
-create database link, create synonym, create type, ctxapp TO oracle_enhanced;
+create database link, create synonym, create type, ctxapp,
+create public synonym, drop public synonym TO oracle_enhanced;
 
 CREATE USER oracle_enhanced_schema IDENTIFIED BY oracle_enhanced_schema;
 
 GRANT unlimited tablespace, create session, create table, create sequence,
 create procedure, create trigger, create view, create materialized view,
-create database link, create synonym, create type, ctxapp TO oracle_enhanced_schema;
-
-CREATE USER arunit IDENTIFIED BY arunit;
-
-GRANT unlimited tablespace, create session, create table, create sequence,
-create procedure, create trigger, create view, create materialized view,
-create database link, create synonym, create type, ctxapp TO arunit;
-
-CREATE USER arunit2 IDENTIFIED BY arunit2;
-
-GRANT unlimited tablespace, create session, create table, create sequence,
-create procedure, create trigger, create view, create materialized view,
-create database link, create synonym, create type, ctxapp TO arunit2;
-
-CREATE USER ruby IDENTIFIED BY oci8;
-GRANT connect, resource, create view,create synonym TO ruby;
-GRANT EXECUTE ON dbms_lock TO ruby;
-GRANT CREATE VIEW TO ruby;
-GRANT unlimited tablespace to ruby;
+create database link, create synonym, create type, ctxapp,
+create public synonym, drop public synonym TO oracle_enhanced_schema;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-oracle_enhanced-adapter
 version: !ruby/object:Gem::Version
-  version: 8.1.2
+  version: 8.1.4
 platform: ruby
 authors:
 - Raimonds Simanovskis
@@ -103,6 +103,7 @@ files:
 - lib/arel/visitors/oracle12.rb
 - lib/arel/visitors/oracle_common.rb
 - spec/active_record/connection_adapters/emulation/oracle_adapter_spec.rb
+- spec/active_record/connection_adapters/oracle_enhanced/columns_for_distinct_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/compatibility_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/composite_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb
@@ -155,11 +156,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.11
 specification_version: 4
 summary: Oracle enhanced adapter for ActiveRecord
 test_files:
 - spec/active_record/connection_adapters/emulation/oracle_adapter_spec.rb
+- spec/active_record/connection_adapters/oracle_enhanced/columns_for_distinct_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/compatibility_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/composite_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb