Support ROWID-based LOB writes for tables without primary keys

Add ability to write LOB data to tables that don't have a primary key by:

1. Exposing cursor.rowid method in OCI connection wrapper
2. Capturing ROWID after INSERT in exec_insert (@last_insert_rowid)
3. Using ROWID in write_lobs WHERE clause when no PK is available
4. Supporting composite primary keys (Array) in write_lobs

The ROWID approach works because:
- Ruby-oci8's cursor.rowid returns the ROWID of the last inserted row
- ROWID uniquely identifies any row regardless of table structure
- The after_create callback fires immediately after INSERT on same connection

Also includes ORA-01741 diagnostic logging for empty column detection.

Author: andynu

lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -122,6 +122,18 @@ def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, retu
           sql, binds = sql_for_insert(sql, pk, binds, returning)
           type_casted_binds = type_casted_binds(binds)
 
+          # Check for empty column names in the SQL (diagnostic for ORA-01741)
+          if sql =~ /INSERT INTO.*?\(([^)]+)\)/i
+            columns = $1.split(",").map(&:strip)
+            empty_columns = columns.select { |c| c.empty? || c == '""' || c == "''" }
+            if empty_columns.any? || columns.any? { |c| c =~ /^\s*$/ }
+              Rails.logger.error "ORA-01741 DEBUG: Empty column detected in INSERT!"
+              Rails.logger.error "  SQL: #{sql[0..500]}"
+              Rails.logger.error "  Columns parsed: #{columns.inspect}"
+              Rails.logger.error "  pk: #{pk.inspect}, returning: #{returning.inspect}"
+            end
+          end
+
           log(sql, name, binds, type_casted_binds) do
             cached = false
             cursor = nil
@@ -155,6 +167,13 @@ def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, retu
               returning_id = cursor.get_returning_param(returning_id_index, Integer).to_i
               rows << [returning_id]
             end
+
+            # Capture ROWID for LOB writes on tables without primary keys
+            # This must happen right after exec_update while the cursor still has the rowid
+            if cursor.respond_to?(:rowid)
+              @last_insert_rowid = cursor.rowid
+            end
+
             cursor.close unless cached
             build_result(columns: returning_id_col || [], rows: rows)
           end
@@ -280,7 +299,28 @@ def empty_insert_statement_value
 
         # Writes LOB values from attributes for specified columns
         def write_lobs(table_name, klass, attributes, columns) # :nodoc:
-          id = quote(attributes[klass.primary_key])
+          pk = klass.primary_key
+
+          # Build WHERE clause based on what's available
+          where_clause = if pk.nil? && @last_insert_rowid
+            # Use ROWID when no primary key is defined but we have the rowid from INSERT
+            "ROWID = #{quote(@last_insert_rowid)}"
+          elsif pk.nil?
+            # No primary key and no ROWID - cannot locate the row
+            if columns.any? { |col| attributes[col.name].present? }
+              @logger&.warn "Cannot write LOB columns for #{table_name} - table has no primary key " \
+                            "and ROWID is not available. LOB data may be truncated. Consider adding " \
+                            "a primary key constraint or explicitly setting self.primary_key on the model."
+            end
+            return
+          elsif pk.is_a?(Array)
+            # Composite primary key - build AND conditions for each column
+            pk.map { |col| "#{quote_column_name(col)} = #{quote(attributes[col])}" }.join(" AND ")
+          else
+            # Single primary key
+            "#{quote_column_name(pk)} = #{quote(attributes[pk])}"
+          end
+
           columns.each do |col|
             value = attributes[col.name]
             # changed sequence of next two lines - should check if value is nil before converting to yaml
@@ -289,16 +329,18 @@ def write_lobs(table_name, klass, attributes, columns) # :nodoc:
             # value can be nil after serialization because ActiveRecord serializes [] and {} as nil
             next unless value
             uncached do
-              unless lob_record = select_one(sql = <<~SQL.squish, "Writable Large Object")
-                SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)}
-                WHERE #{quote_column_name(klass.primary_key)} = #{id} FOR UPDATE
-              SQL
+              sql = "SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)} " \
+                    "WHERE #{where_clause} FOR UPDATE"
+              unless lob_record = select_one(sql, "Writable Large Object")
                 raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
               end
               lob = lob_record[col.name]
               _connection.write_lob(lob, value.to_s, col.type == :binary)
             end
           end
+
+          # Clear the stored ROWID after use to prevent it being used for wrong row
+          @last_insert_rowid = nil
         end
 
         private

lib/active_record/connection_adapters/oracle_enhanced/oci_connection.rb

@@ -193,6 +193,12 @@ def get_returning_param(position, type)
           def close
             @raw_cursor.close
           end
+
+          # Returns the ROWID of the last inserted/updated/deleted row
+          # This is useful for LOB writes on tables without primary keys
+          def rowid
+            @raw_cursor.rowid
+          end
         end
 
         def select(sql, name = nil, return_column_names = false)