activerecord-oracle_enhanced-adapter 7.2.1-java → 8.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cfadd132a282a5e63722276b5a13c8f32e7d10ce9766db397e1b256113ac070
-  data.tar.gz: 7183ed3e0bd92ba99f9eade30e9b07f3673b43970fe9de718693ec0db21adfd2
+  metadata.gz: '0228707379728bbeb32011a85bd19154279fb442d234e08ef5a5dc2445b391d3'
+  data.tar.gz: 05e7d21d330955e2227120e7dc2b1c59fd0de7e8feb162fb3c6a2acc514c692f
 SHA512:
-  metadata.gz: 58a1bbc68da126583e22c3a2b3436ed3c144637540de12d63aeeaa7565c5d0e2c02529dfb1aac1facff5cd13cb1b3c68b9a30bb392404b541c50196b20476bf0
-  data.tar.gz: ba5141eb3d77088066282646a8b9179dc728c46f9693a958a66cb3c56267f3db01b6417b59ee0284e8f1f01d480d1eaa0baed72f9dfcfd66ffdbeb56af6cd488
+  metadata.gz: 1e0531e2d250815dc629d7c78871bb30bad58687a47429e34b6ab024cd713a9a1b3f60c855a571bd2090811afea82cfd0618778c4ecba901960c842cbb676391
+  data.tar.gz: a357e405eaa4a7b226c02638b968c0cf92fbbc5404c573de144c92361eb79a38f864e7f45b1e3837c5fd9801949d3a402982e092e13b85b3f886557cc9d5f3cb

data/History.md

@@ -1,10 +1,4 @@
-## 7.2.1 / 2026-07-26
-
-* Changes and bug fixes
-  * Accept `allow_retry` keyword argument in JDBC connection `exec`
-  * Add `reset` method to JDBC connection
-  * Skip `ObjectSpace::WeakMap` workaround on JRuby that implements `#values`
-  * Run tests on JRuby 9.4.15.0
+This file is no longer being updated. For the latest updates and release information, please see: https://github.com/rsim/oracle-enhanced/releases
 
 ## 7.2.0 / 2025-06-23
 

data/README.md

@@ -6,10 +6,30 @@ Oracle enhanced adapter for ActiveRecord
 DESCRIPTION
 -----------
 
-Oracle enhanced ActiveRecord adapter provides Oracle database access from Ruby on Rails applications. Oracle enhanced adapter can be used from Ruby on Rails versions between 2.3.x and 7.2 and it is working with Oracle database versions 10g and higher
+Oracle enhanced ActiveRecord adapter provides Oracle database access from Ruby on Rails applications. Oracle enhanced adapter can be used from Ruby on Rails versions between 2.3.x and 8.1 and it is working with Oracle database versions 10g and higher
 
 INSTALLATION
 ------------
+### Rails 8.1
+
+Oracle enhanced adapter version 8.1 supports Rails 8.1
+When using Ruby on Rails version 8.1 then in Gemfile include
+
+```ruby
+# Use oracle as the database for Active Record
+gem 'activerecord-oracle_enhanced-adapter', '~> 8.1.0'
+```
+
+### Rails 8.0
+
+Oracle enhanced adapter version 8.0 supports Rails 8.0
+When using Ruby on Rails version 8.0 then in Gemfile include
+
+```ruby
+# Use oracle as the database for Active Record
+gem 'activerecord-oracle_enhanced-adapter', '~> 8.0.0'
+```
+
 ### Rails 7.2
 
 Oracle enhanced adapter version 7.2 supports Rails 7.2
@@ -823,6 +843,70 @@ complete.
 
 See the **Timeouts** section above.
 
+Development with Devcontainer
+------------------------------
+
+This project includes a devcontainer configuration that provides a complete development environment with Oracle Database and all necessary dependencies pre-configured. The devcontainer supports both x64 and ARM64 architectures.
+
+### Prerequisites
+
+- [Docker](https://www.docker.com/get-started) installed and running
+- [VS Code](https://code.visualstudio.com/) with the [Dev Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
+
+### Getting Started
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/rsim/oracle-enhanced.git
+   cd oracle-enhanced
+   ```
+
+2. Open the project in VS Code:
+   ```bash
+   code .
+   ```
+
+3. When prompted, click "Reopen in Container" or use the Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`) and select "Dev Containers: Reopen in Container"
+
+4. VS Code will build and start the development environment automatically. This includes:
+   - Ruby 3.4
+   - Oracle Database Free
+   - Oracle Instant Client 23.8
+   - All required gems installed via `bundle install`
+
+### What's Included
+
+The devcontainer provides:
+
+- **Ruby**: 3.4
+- **Oracle Database**: Oracle Database Free (23c)
+- **Oracle Instant Client**: Version 23.8
+- **Database Configuration**:
+  - Database: `FREEPDB1`
+  - System password: `Oracle18`
+  - TNS configuration in `ci/network/admin`
+
+### Database Access
+
+The Oracle database is automatically started and configured with:
+- Port: `1521` (forwarded from container)
+- Service Name: `FREEPDB1`
+- System Password: `Oracle18`
+- Test users are created automatically from `spec/support/create_oracle_enhanced_users.sql`
+
+
+### Running Tests
+
+Once the devcontainer is running, you can run tests directly:
+
+```bash
+# Run all tests
+bundle exec rspec
+
+# Run specific test files
+bundle exec rspec spec/test_file_spec.rb
+```
+
 RUNNING TESTS
 -------------
 

data/VERSION

@@ -1 +1 @@
-7.2.1
+8.1.0

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

@@ -6,8 +6,8 @@ module ActiveRecord
       class Column < ActiveRecord::ConnectionAdapters::Column
         delegate :virtual, to: :sql_type_metadata, allow_nil: true
 
-        def initialize(name, default, sql_type_metadata = nil, null = true, comment: nil) # :nodoc:
-          super(name, default, sql_type_metadata, null, comment: comment)
+        def initialize(name, cast_type, default, sql_type_metadata = nil, null = true, comment: nil) # :nodoc:
+          super(name, cast_type, default, sql_type_metadata, null, comment: comment)
         end
 
         def virtual?

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

@@ -330,8 +330,23 @@ module ActiveRecord
             # Add context index condition.
             def contains(column, query, options = {})
               score_label = options[:label].to_i || 1
-              where("CONTAINS(#{connection.quote_table_name(column)}, ?, #{score_label}) > 0", query).
-                order(Arel.sql("SCORE(#{score_label}) DESC"))
+              quoted_column = connection.quote_table_name(column)
+
+              # Create an Arel node for the CONTAINS function
+              contains_node = Arel::Nodes::NamedFunction.new(
+                "CONTAINS",
+                [
+                  Arel::Nodes::SqlLiteral.new(quoted_column),
+                  Arel::Nodes::BindParam.new(query),
+                  Arel::Nodes::SqlLiteral.new(score_label.to_s)
+                ]
+              )
+
+              # Create comparison node: CONTAINS(...) > 0
+              condition = Arel::Nodes::GreaterThan.new(contains_node, Arel::Nodes::SqlLiteral.new("0"))
+
+              # Create the where clause and order by score
+              where(condition).order(Arel.sql("SCORE(#{score_label}) DESC"))
             end
           end
       end

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

@@ -8,58 +8,79 @@ module ActiveRecord
         #
         # see: abstract/database_statements.rb
 
-        # Executes a SQL statement
-        def execute(sql, name = nil, async: false, allow_retry: false)
-          sql = transform_query(sql)
+        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
 
-          log(sql, name, async: async) { _connection.exec(sql, allow_retry: allow_retry) }
+        # Executes a SQL statement
+        def execute(...)
+          super
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false)
-          sql = transform_query(sql)
+        # Low level execution of a SQL statement on the connection returning adapter specific result object.
+        def raw_execute(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: false)
+          sql = preprocess_query(sql)
 
           type_casted_binds = type_casted_binds(binds)
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            log(sql, name, binds, type_casted_binds, async: async) do
+              cursor = nil
+              cached = false
+              with_retry do
+                if binds.nil? || binds.empty?
+                  cursor = conn.prepare(sql)
+                else
+                  unless @statements.key? sql
+                    @statements[sql] = conn.prepare(sql)
+                  end
 
-          log(sql, name, binds, type_casted_binds, async: async) do
-            cursor = nil
-            cached = false
-            with_retry do
-              if without_prepared_statement?(binds)
-                cursor = _connection.prepare(sql)
-              else
-                unless @statements.key? sql
-                  @statements[sql] = _connection.prepare(sql)
-                end
-
-                cursor = @statements[sql]
-
-                cursor.bind_params(type_casted_binds)
+                  cursor = @statements[sql]
+                  cursor.bind_params(type_casted_binds)
 
-                cached = true
+                  cached = true
+                end
+                cursor.exec
               end
 
-              cursor.exec
-            end
-
-            if (name == "EXPLAIN") && sql.start_with?("EXPLAIN")
-              res = true
-            else
               columns = cursor.get_col_names.map do |col_name|
                 oracle_downcase(col_name)
               end
+
               rows = []
-              fetch_options = { get_lob_value: (name != "Writable Large Object") }
-              while row = cursor.fetch(fetch_options)
-                rows << row
+              if cursor.select_statement?
+                fetch_options = { get_lob_value: (name != "Writable Large Object") }
+                while row = cursor.fetch(fetch_options)
+                  rows << row
+                end
               end
-              res = build_result(columns: columns, rows: rows)
+
+              affected_rows_count = cursor.row_count
+
+              cursor.close unless cached
+
+              { columns: columns, rows: rows, affected_rows_count: affected_rows_count }
             end
+          end
+        end
 
-            cursor.close unless cached
-            res
+        def cast_result(result)
+          if result.nil?
+            ActiveRecord::Result.empty
+          else
+            ActiveRecord::Result.new(result[:columns], result[:rows])
           end
         end
-        alias_method :internal_exec_query, :exec_query
+
+        def affected_rows(result)
+          result[:affected_rows_count]
+        end
 
         def supports_explain?
           true
@@ -106,7 +127,7 @@ module ActiveRecord
             cursor = nil
             returning_id_col = returning_id_index = nil
             with_retry do
-              if without_prepared_statement?(binds)
+              if binds.nil? || binds.empty?
                 cursor = _connection.prepare(sql)
               else
                 unless @statements.key?(sql)
@@ -146,7 +167,7 @@ module ActiveRecord
           log(sql, name, binds, type_casted_binds) do
             with_retry do
               cached = false
-              if without_prepared_statement?(binds)
+              if binds.nil? || binds.empty?
                 cursor = _connection.prepare(sql)
               else
                 if @statements.key?(sql)
@@ -289,6 +310,15 @@ module ActiveRecord
               raise
             end
           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
       end
     end
   end

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

@@ -32,7 +32,7 @@ module ActiveRecord
 
       private
         def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false, &block)
-          @instrumenter.instrument(
+          instrumenter.instrument(
             "sql.active_record",
             sql:               sql,
             name:              name,

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

@@ -17,7 +17,8 @@ begin
   # Oracle 12c Release 1 client provides ojdbc7.jar
   # Oracle 12c Release 2 client provides ojdbc8.jar
   # Oracle 21c provides ojdbc11.jar for Java 11 and above
-  ojdbc_jars = %w(ojdbc11.jar ojdbc8.jar ojdbc7.jar ojdbc6.jar)
+  # Oracle 23c provides ojdbc17.jar for Java 17 and above
+  ojdbc_jars = %w(ojdbc17.jar ojdbc11.jar ojdbc8.jar ojdbc7.jar ojdbc6.jar)
 
   if !ENV_JAVA["java.class.path"]&.match?(Regexp.new(ojdbc_jars.join("|")))
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
@@ -60,6 +61,8 @@ module ActiveRecord
         alias :auto_retry? :auto_retry
         @auto_retry = false
 
+        attr_reader :session_time_zone
+
         def initialize(config)
           @active = true
           @config = config
@@ -154,8 +157,10 @@ module ActiveRecord
             # Set session time zone to current time zone
             if ActiveRecord.default_timezone == :local
               @raw_connection.setSessionTimeZone(time_zone)
+              @session_time_zone = time_zone
             elsif ActiveRecord.default_timezone == :utc
               @raw_connection.setSessionTimeZone("UTC")
+              @session_time_zone = "UTC"
             end
 
             if config[:jdbc_statement_cache_size]
@@ -236,12 +241,11 @@ module ActiveRecord
           raise OracleEnhanced::ConnectionException, e.message
         end
 
+        # Resets connection, by logging off and creating a new connection.
         def reset
-          # tentative
           reset!
         end
 
-        # Resets connection, by logging off and creating a new connection.
         def reset!
           logoff rescue nil
           begin
@@ -259,7 +263,7 @@ module ActiveRecord
           begin
             yield if block_given?
           rescue Java::JavaSql::SQLException => e
-            raise unless /^(Closed Connection|Io exception:|No more data to read from socket|IO Error:)/.match?(e.message)
+            raise unless /^(Closed Connection|Io exception:|No more data to read from socket|IO Error:|ORA-03113:|ORA-03114:|ORA-17008:)/.match?(e.message)
             @active = false
             raise unless should_retry
             should_retry = false
@@ -268,7 +272,11 @@ module ActiveRecord
           end
         end
 
-        def exec(sql, allow_retry: false)
+        def exec(sql, *bindvars, allow_retry: false)
+          # The signature mirrors the OCI implementation for polymorphic
+          # callers, but the JDBC path here has no bindvar handling. Fail
+          # loudly rather than silently dropping values on the floor.
+          raise ArgumentError, "JDBC exec does not support bindvars" unless bindvars.empty?
           with_retry(allow_retry: allow_retry) do
             exec_no_retry(sql)
           end
@@ -298,7 +306,16 @@ module ActiveRecord
         end
 
         def prepare(sql)
-          Cursor.new(self, @raw_connection.prepareStatement(sql))
+          # Use a plain Statement for DDL and PL/SQL blocks: PreparedStatement
+          # interprets colons as bind-parameter markers which breaks trigger
+          # definitions (:NEW/:OLD) and PL/SQL with named parameters.
+          if /\A\s*(CREATE|DROP|BEGIN|DECLARE)/i.match?(sql)
+            s = @raw_connection.createStatement()
+            s.setEscapeProcessing(false)
+            Cursor.new(self, s, sql)
+          else
+            Cursor.new(self, @raw_connection.prepareStatement(sql))
+          end
         end
 
         def database_version
@@ -306,9 +323,10 @@ module ActiveRecord
         end
 
         class Cursor
-          def initialize(connection, raw_statement)
+          def initialize(connection, raw_statement, exec_sql = nil)
             @raw_connection = connection
             @raw_statement = raw_statement
+            @exec_sql = exec_sql  # non-nil for DDL/PL/SQL using createStatement
           end
 
           def bind_params(*bind_vars)
@@ -348,8 +366,14 @@ module ActiveRecord
             when Java::JavaSql::Timestamp
               @raw_statement.setTimestamp(position, value)
             when Time
-              new_value = Java::java.sql.Timestamp.new(value.year - 1900, value.month - 1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
-              @raw_statement.setTimestamp(position, new_value)
+              new_value = java.sql.Timestamp.new(value.to_i * 1000)
+              new_value.setNanos(value.nsec)
+              # Oracle JDBC getTimestamp uses the session timezone, but setTimestamp
+              # (without Calendar) uses the JVM default timezone. Pass a Calendar
+              # matching the session timezone so both sides use the same reference.
+              tz_id = @raw_connection.session_time_zone || java.util.TimeZone.default.getID
+              cal = java.util.Calendar.getInstance(java.util.TimeZone.getTimeZone(tz_id))
+              @raw_statement.setTimestamp(position, new_value, cal)
             when NilClass
               # TODO: currently nil is always bound as NULL with VARCHAR type.
               # When nils will actually be used by ActiveRecord as bound parameters
@@ -369,7 +393,13 @@ module ActiveRecord
           end
 
           def exec
-            @raw_result_set = @raw_statement.executeQuery
+            if @exec_sql
+              # DDL / PL/SQL block executed via createStatement — never returns rows
+              @raw_statement.execute(@exec_sql)
+            elsif @raw_statement.execute
+              # execute() returns true when the result is a ResultSet (SELECT)
+              @raw_result_set = @raw_statement.getResultSet
+            end
             true
           end
 
@@ -378,18 +408,28 @@ module ActiveRecord
           end
 
           def metadata
-            @metadata ||= @raw_result_set.getMetaData
+            @metadata ||= @raw_result_set&.getMetaData
           end
 
           def column_types
+            return [] unless @raw_result_set
             @column_types ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnTypeName(i).to_sym }
           end
 
           def column_names
+            return [] unless @raw_result_set
             @column_names ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnName(i) }
           end
           alias :get_col_names :column_names
 
+          def select_statement?
+            !@raw_result_set.nil?
+          end
+
+          def row_count
+            @raw_statement.getUpdateCount
+          end
+
           def fetch(options = {})
             if @raw_result_set.next
               get_lob_value = options[:get_lob_value]
@@ -419,6 +459,17 @@ module ActiveRecord
 
           def close
             @raw_statement.close
+          rescue Java::JavaSql::SQLException => e
+            # Tolerate closing a statement whose underlying connection or
+            # statement has already been torn down (typical after with_retry
+            # has reset the connection). Re-raise anything else so genuine
+            # driver/resource bugs surface.
+            #
+            #   ORA-17002 "Io exception"        - network/socket failure
+            #   ORA-17008 "Closed Connection"   - connection already closed
+            #   ORA-17009 "Closed Statement"    - statement already closed
+            raise unless [17_002, 17_008, 17_009].include?(e.getErrorCode)
+            nil
           end
         end
 
@@ -514,10 +565,27 @@ module ActiveRecord
             else
               nil
             end
-          when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ, :"TIMESTAMP WITH TIME ZONE", :"TIMESTAMP WITH LOCAL TIME ZONE"
+          when :TIMESTAMP
+            # Oracle JDBC getTimestamp for plain TIMESTAMP uses the JVM default timezone,
+            # but we store values using the session timezone. Pass a matching Calendar so
+            # the driver interprets the stored wall-clock value in the session timezone.
+            tz_id = @session_time_zone || java.util.TimeZone.default.getID
+            cal = java.util.Calendar.getInstance(java.util.TimeZone.getTimeZone(tz_id))
+            ts = rset.getTimestamp(i, cal)
+            if ts
+              instant = ts.toInstant
+              t = Time.at(instant.getEpochSecond, instant.getNano, :nanosecond)
+              ActiveRecord.default_timezone == :utc ? t.utc : t.localtime
+            end
+          when :TIMESTAMPTZ, :TIMESTAMPLTZ, :"TIMESTAMP WITH TIME ZONE", :"TIMESTAMP WITH LOCAL TIME ZONE"
+            # TIMESTAMPTZ/TIMESTAMPLTZ include timezone info so getTimestamp returns
+            # the correct UTC epoch without needing a Calendar.
             ts = rset.getTimestamp(i)
-            ts && Time.send(ActiveRecord.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
-              ts.nanos / 1000)
+            if ts
+              instant = ts.toInstant
+              t = Time.at(instant.getEpochSecond, instant.getNano, :nanosecond)
+              ActiveRecord.default_timezone == :utc ? t.utc : t.localtime
+            end
           when :CLOB
             get_lob_value ? lob_to_ruby_value(rset.getClob(i)) : rset.getClob(i)
           when :NCLOB

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

@@ -11,6 +11,8 @@ module ActiveRecord # :nodoc:
 
           # After setting large objects to empty, select the OCI8::LOB
           # and write back the data.
+          before_create :record_lobs_for_create
+          after_create :enhanced_write_lobs
           before_update :record_changed_lobs
           after_update :enhanced_write_lobs
         end
@@ -25,11 +27,21 @@ module ActiveRecord # :nodoc:
 
         private
           def enhanced_write_lobs
+            # Skip if using prepared statements - LOB data is already written via temp LOB binding
+            return if self.class.connection.prepared_statements
+
             if self.class.connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
                 !(self.class.custom_create_method || self.class.custom_update_method)
               self.class.connection.write_lobs(self.class.table_name, self.class, attributes, @changed_lob_columns)
             end
           end
+
+          def record_lobs_for_create
+            @changed_lob_columns = self.class.lob_columns.select do |col|
+              !attributes[col.name].nil? && !self.class.readonly_attributes.to_a.include?(col.name)
+            end
+          end
+
           def record_changed_lobs
             @changed_lob_columns = self.class.lob_columns.select do |col|
               self.will_save_change_to_attribute?(col.name) && !self.class.readonly_attributes.to_a.include?(col.name)

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

@@ -158,6 +158,14 @@ module ActiveRecord
             @raw_cursor.get_col_names
           end
 
+          def row_count
+            @raw_cursor.row_count
+          end
+
+          def select_statement?
+            @raw_cursor.type == :select_stmt
+          end
+
           def fetch(options = {})
             if row = @raw_cursor.fetch
               get_lob_value = options[:get_lob_value]

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

@@ -12,6 +12,7 @@ module ActiveRecord
                 @lob_tablespaces[o.name] = tablespace
               end
             end
+            o.cast_type = lookup_cast_type(sql_type)
             super
           end
 

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

@@ -219,9 +219,9 @@ module ActiveRecord
           unless create_sequence
             class << td
               attr_accessor :create_sequence
-              def primary_key(*args)
+              def primary_key(name, type = :primary_key, **options)
                 self.create_sequence = true
-                super(*args)
+                super(name, type, **options)
               end
             end
           end
@@ -284,7 +284,7 @@ module ActiveRecord
             } << "SELECT * FROM DUAL\n"
           else
             if versions.is_a?(Array)
-              # called from ActiveRecord::Base.connection#dump_schema_information
+              # called from ActiveRecord::Base.connection#dump_schema_versions
               versions.map { |version|
                 "INSERT INTO #{sm_table} (version) VALUES (#{quote(version)})"
               }.join("\n\n/\n\n")
@@ -674,6 +674,7 @@ module ActiveRecord
             default_value = extract_value_from_default(field["data_default"])
             default_value = nil if is_virtual
             OracleEnhanced::Column.new(oracle_downcase(field["name"]),
+                             lookup_cast_type(field["sql_type"]),
                              default_value,
                              type_metadata,
                              field["nullable"] == "Y",
@@ -698,7 +699,7 @@ module ActiveRecord
           end
 
           def default_tablespace_for(type)
-            (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+            default_tablespaces[type]
           end
 
           def column_for(table_name, column_name)

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

@@ -51,6 +51,7 @@ module ActiveRecord # :nodoc:
             structure << ddl
             structure << structure_dump_indexes(table_name)
             structure << structure_dump_unique_keys(table_name)
+            structure << structure_dump_check_constraints(table_name)
             structure << structure_dump_table_comments(table_name)
             structure << structure_dump_column_comments(table_name)
           end
@@ -161,6 +162,33 @@ module ActiveRecord # :nodoc:
           join_with_statement_token(fks)
         end
 
+        # Only user-named CHECK constraints are preserved. Anonymous
+        # constraints created via `ALTER TABLE ... ADD CHECK (...)` receive
+        # Oracle-generated names (e.g. SYS_C00123) and are skipped to avoid
+        # also emitting the implicit NOT NULL check constraints that Oracle
+        # stores with constraint_type = 'C'.
+        def structure_dump_check_constraints(table_name) # :nodoc:
+          # `search_condition` is a LONG column, so it cannot appear in a
+          # WHERE clause (ORA-00997). The driver reads it as a String on
+          # SELECT. Implicit NOT NULL constraints Oracle stores with
+          # constraint_type = 'C' are excluded by `generated = 'USER NAME'`
+          # since they receive system-generated names.
+          check_constraints = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase)])
+            SELECT constraint_name, search_condition
+            FROM all_constraints
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+              AND table_name = :table_name
+              AND constraint_type = 'C'
+              AND generated = 'USER NAME'
+            ORDER BY constraint_name
+          SQL
+          check_constraints.filter_map do |row|
+            condition = row["search_condition"]
+            next if condition.nil?
+            "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(row["constraint_name"])} CHECK (#{condition})"
+          end
+        end
+
         def structure_dump_table_comments(table_name)
           comments = []
           comment = table_comment(table_name)