resolve conflict in tests/generics_test.go

Author: norah-li

oracle/clause_builder.go

@@ -300,7 +300,6 @@ func OnConflictClauseBuilder(c clause.Clause, builder clause.Builder) {
 			if len(conflictColumns) == 0 {
 				// If no columns specified, try to use primary key fields as default
 				if stmt.Schema == nil || len(stmt.Schema.PrimaryFields) == 0 {
-					stmt.AddError(fmt.Errorf("OnConflict requires either explicit columns or primary key fields"))
 					return
 				}
 				for _, primaryField := range stmt.Schema.PrimaryFields {
@@ -326,7 +325,16 @@ func OnConflictClauseBuilder(c clause.Clause, builder clause.Builder) {
 					missingColumns = append(missingColumns, conflictCol.Name)
 				}
 			}
+
 			if len(missingColumns) > 0 {
+				// primary keys with auto increment will always be missing from create values columns
+				for _, missingCol := range missingColumns {
+					field := stmt.Schema.LookUpField(missingCol)
+					if field != nil && field.PrimaryKey && field.AutoIncrement {
+						return
+					}
+				}
+
 				var selectedColumns []string
 				for col := range selectedColumnSet {
 					selectedColumns = append(selectedColumns, col)
@@ -336,6 +344,34 @@ func OnConflictClauseBuilder(c clause.Clause, builder clause.Builder) {
 				return
 			}
 
+			// exclude primary key, default value columns from merge update clause
+			if len(onConflict.DoUpdates) > 0 {
+				hasPrimaryKey := false
+
+				for _, assignment := range onConflict.DoUpdates {
+					field := stmt.Schema.LookUpField(assignment.Column.Name)
+					if field != nil && field.PrimaryKey {
+						hasPrimaryKey = true
+						break
+					}
+				}
+
+				if hasPrimaryKey {
+					onConflict.DoUpdates = nil
+					columns := make([]string, 0, len(values.Columns)-1)
+					for _, col := range values.Columns {
+						field := stmt.Schema.LookUpField(col.Name)
+
+						if field != nil && !field.PrimaryKey && (!field.HasDefaultValue || field.DefaultValueInterface != nil ||
+							strings.EqualFold(field.DefaultValue, "NULL")) && field.AutoCreateTime == 0 {
+							columns = append(columns, col.Name)
+						}
+
+					}
+					onConflict.DoUpdates = append(onConflict.DoUpdates, clause.AssignmentColumns(columns)...)
+				}
+			}
+
 			// Build MERGE statement
 			buildMergeInClause(stmt, onConflict, values, conflictColumns)
 		}

oracle/common.go

@@ -424,6 +424,50 @@ func writeQuotedIdentifier(builder *strings.Builder, identifier string) {
 	builder.WriteByte('"')
 }
 
+// writeTableRecordCollectionDecl writes the PL/SQL declarations needed to
+// define a custom record type and a collection of that record type,
+// based on the schema of the given table.
+//
+// Specifically, it generates:
+//   - A RECORD type (`t_record`) with fields corresponding to the table's columns.
+//   - A nested TABLE type (`t_records`) of `t_record`.
+//
+// The declarations are written into the provided strings.Builder in the
+// correct PL/SQL syntax, so they can be used as part of a larger PL/SQL block.
+//
+// Example output:
+//
+//	TYPE t_record IS RECORD (
+//	  "id" "users"."id"%TYPE,
+//	  "created_at" "users"."created_at"%TYPE,
+//	  ...
+//	);
+//	TYPE t_records IS TABLE OF t_record;
+//
+// Parameters:
+//   - plsqlBuilder: The builder to write the PL/SQL code into.
+//   - dbNames: The slice containing the column names.
+//   - table: The table name
+func writeTableRecordCollectionDecl(plsqlBuilder *strings.Builder, dbNames []string, table string) {
+	// Declare a record where each element has the same structure as a row from the given table
+	plsqlBuilder.WriteString("  TYPE t_record IS RECORD (\n")
+	for i, field := range dbNames {
+		if i > 0 {
+			plsqlBuilder.WriteString(",\n")
+		}
+		plsqlBuilder.WriteString("    ")
+		writeQuotedIdentifier(plsqlBuilder, field)
+		plsqlBuilder.WriteString(" ")
+		writeQuotedIdentifier(plsqlBuilder, table)
+		plsqlBuilder.WriteString(".")
+		writeQuotedIdentifier(plsqlBuilder, field)
+		plsqlBuilder.WriteString("%TYPE")
+	}
+	plsqlBuilder.WriteString("\n")
+	plsqlBuilder.WriteString("  );\n")
+	plsqlBuilder.WriteString("  TYPE t_records IS TABLE OF t_record;\n")
+}
+
 // Helper function to check if a value represents NULL
 func isNullValue(value interface{}) bool {
 	if value == nil {

oracle/create.go

@@ -176,6 +176,8 @@ func validateCreateData(stmt *gorm.Statement) error {
 
 // Build PL/SQL block for bulk INSERT/MERGE with RETURNING
 func buildBulkInsertPLSQL(db *gorm.DB, createValues clause.Values) {
+	sanitizeCreateValuesForBulkArrays(db.Statement, &createValues)
+
 	stmt := db.Statement
 	schema := stmt.Schema
 
@@ -217,7 +219,6 @@ func buildBulkInsertPLSQL(db *gorm.DB, createValues clause.Values) {
 		conflictColumns := onConflict.Columns
 		if len(conflictColumns) == 0 {
 			if len(schema.PrimaryFields) == 0 {
-				db.AddError(fmt.Errorf("OnConflict requires either explicit columns or primary key fields"))
 				return
 			}
 			for _, primaryField := range schema.PrimaryFields {
@@ -238,6 +239,8 @@ func buildBulkInsertPLSQL(db *gorm.DB, createValues clause.Values) {
 
 // Build PL/SQL block for bulk MERGE with RETURNING (OnConflict case)
 func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClause clause.Clause) {
+	sanitizeCreateValuesForBulkArrays(db.Statement, &createValues)
+
 	stmt := db.Statement
 	schema := stmt.Schema
 
@@ -251,7 +254,6 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 	conflictColumns := onConflict.Columns
 	if len(conflictColumns) == 0 {
 		if schema == nil || len(schema.PrimaryFields) == 0 {
-			db.AddError(fmt.Errorf("OnConflict requires either explicit columns or primary key fields"))
 			return
 		}
 		for _, primaryField := range schema.PrimaryFields {
@@ -265,9 +267,11 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 		valuesColumnMap[strings.ToUpper(column.Name)] = true
 	}
 
+	// Filter conflict columns to remove non unique columns
 	var filteredConflictColumns []clause.Column
 	for _, conflictCol := range conflictColumns {
-		if valuesColumnMap[strings.ToUpper(conflictCol.Name)] {
+		field := stmt.Schema.LookUpField(conflictCol.Name)
+		if valuesColumnMap[strings.ToUpper(conflictCol.Name)] && (field.Unique || field.AutoIncrement) {
 			filteredConflictColumns = append(filteredConflictColumns, conflictCol)
 		}
 	}
@@ -285,9 +289,7 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 
 	// Start PL/SQL block
 	plsqlBuilder.WriteString("DECLARE\n")
-	plsqlBuilder.WriteString("  TYPE t_records IS TABLE OF ")
-	writeQuotedIdentifier(&plsqlBuilder, stmt.Table)
-	plsqlBuilder.WriteString("%ROWTYPE;\n")
+	writeTableRecordCollectionDecl(&plsqlBuilder, stmt.Schema.DBNames, stmt.Table)
 	plsqlBuilder.WriteString("  l_affected_records t_records;\n")
 
 	// Create array types and variables for each column
@@ -336,6 +338,7 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 
 	// Build ON clause using conflict columns
 	plsqlBuilder.WriteString("    ON (")
+
 	for idx, conflictCol := range conflictColumns {
 		if idx > 0 {
 			plsqlBuilder.WriteString(" AND ")
@@ -409,6 +412,25 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 			}
 		}
 		plsqlBuilder.WriteString("\n")
+	} else {
+		onCols := map[string]struct{}{}
+		for _, c := range conflictColumns {
+			onCols[strings.ToUpper(c.Name)] = struct{}{}
+		}
+
+		// Picking the first non-ON column from the INSERT/MERGE columns
+		var noopCol string
+		for _, c := range createValues.Columns {
+			if _, inOn := onCols[strings.ToUpper(c.Name)]; !inOn {
+				noopCol = c.Name
+				break
+			}
+		}
+		plsqlBuilder.WriteString("    WHEN MATCHED THEN UPDATE SET t.")
+		writeQuotedIdentifier(&plsqlBuilder, noopCol)
+		plsqlBuilder.WriteString(" = s.")
+		writeQuotedIdentifier(&plsqlBuilder, noopCol)
+		plsqlBuilder.WriteString("\n")
 	}
 
 	// WHEN NOT MATCHED THEN INSERT (unless DoNothing for inserts)
@@ -526,9 +548,7 @@ func buildBulkInsertOnlyPLSQL(db *gorm.DB, createValues clause.Values) {
 
 	// Start PL/SQL block
 	plsqlBuilder.WriteString("DECLARE\n")
-	plsqlBuilder.WriteString("  TYPE t_records IS TABLE OF ")
-	writeQuotedIdentifier(&plsqlBuilder, stmt.Table)
-	plsqlBuilder.WriteString("%ROWTYPE;\n")
+	writeTableRecordCollectionDecl(&plsqlBuilder, stmt.Schema.DBNames, stmt.Table)
 	plsqlBuilder.WriteString("  l_inserted_records t_records;\n")
 
 	// Create array types and variables for each column
@@ -791,19 +811,6 @@ func handleSingleRowReturning(db *gorm.DB) {
 	}
 }
 
-// Simplified RETURNING clause addition for single row operations
-func addReturningClause(db *gorm.DB, fields []*schema.Field) {
-	if len(fields) == 0 {
-		return
-	}
-
-	columns := make([]clause.Column, len(fields))
-	for idx, field := range fields {
-		columns[idx] = clause.Column{Name: field.DBName}
-	}
-	db.Statement.AddClauseIfNotExists(clause.Returning{Columns: columns})
-}
-
 // Handle bulk RETURNING results for PL/SQL operations
 func getBulkReturningValues(db *gorm.DB, rowCount int) {
 	if db.Statement.Schema == nil {
@@ -923,3 +930,34 @@ func handleLastInsertId(db *gorm.DB, result sql.Result) {
 		}
 	}
 }
+
+// This replaces expressions (clause.Expr) in bulk insert values
+// with appropriate NULL placeholders based on the column's data type. This ensures that
+// PL/SQL array binding remains consistent and avoids unsupported expressions during
+// FORALL bulk operations.
+func sanitizeCreateValuesForBulkArrays(stmt *gorm.Statement, cv *clause.Values) {
+	for r := range cv.Values {
+		for c, col := range cv.Columns {
+			v := cv.Values[r][c]
+			switch v.(type) {
+			case clause.Expr:
+				if f := findFieldByDBName(stmt.Schema, col.Name); f != nil {
+					switch f.DataType {
+					case schema.Int, schema.Uint:
+						cv.Values[r][c] = sql.NullInt64{}
+					case schema.Float:
+						cv.Values[r][c] = sql.NullFloat64{}
+					case schema.String:
+						cv.Values[r][c] = sql.NullString{}
+					case schema.Time:
+						cv.Values[r][c] = sql.NullTime{}
+					default:
+						cv.Values[r][c] = nil
+					}
+				} else {
+					cv.Values[r][c] = nil
+				}
+			}
+		}
+	}
+}

oracle/delete.go

@@ -93,6 +93,22 @@ func Delete(db *gorm.DB) {
 		addPrimaryKeyWhereClause(db)
 	}
 
+	// redirect soft-delete to update clause with bulk returning
+	if stmt.Schema != nil {
+		if deletedAtField := stmt.Schema.LookUpField("deleted_at"); deletedAtField != nil && !stmt.Unscoped {
+			for _, c := range stmt.Schema.DeleteClauses {
+				stmt.AddClause(c)
+			}
+			delete(stmt.Clauses, "DELETE")
+			delete(stmt.Clauses, "FROM")
+			stmt.SQL.Reset()
+			stmt.Vars = stmt.Vars[:0]
+			stmt.AddClauseIfNotExists(clause.Update{})
+			Update(db)
+			return
+		}
+	}
+
 	// This prevents soft deletes from bypassing the safety check
 	checkMissingWhereConditions(db)
 	if db.Error != nil {
@@ -239,9 +255,7 @@ func buildBulkDeletePLSQL(db *gorm.DB) {
 
 	// Start PL/SQL block
 	plsqlBuilder.WriteString("DECLARE\n")
-	plsqlBuilder.WriteString("  TYPE t_records IS TABLE OF ")
-	writeQuotedIdentifier(&plsqlBuilder, stmt.Table)
-	plsqlBuilder.WriteString("%ROWTYPE;\n")
+	writeTableRecordCollectionDecl(&plsqlBuilder, stmt.Schema.DBNames, stmt.Table)
 	plsqlBuilder.WriteString("  l_deleted_records t_records;\n")
 	plsqlBuilder.WriteString("BEGIN\n")
 
@@ -434,25 +448,7 @@ func executeDelete(db *gorm.DB) {
 	_, hasReturning := stmt.Clauses["RETURNING"]
 
 	if hasReturning {
-		// For RETURNING, we need to check if it's a soft delete or hard delete
-		if stmt.Schema != nil {
-			if deletedAtField := stmt.Schema.LookUpField("deleted_at"); deletedAtField != nil && !stmt.Unscoped {
-				// Soft delete with RETURNING - use QueryContext
-				if rows, err := stmt.ConnPool.QueryContext(stmt.Context, stmt.SQL.String(), stmt.Vars...); err == nil {
-					defer rows.Close()
-					gorm.Scan(rows, db, gorm.ScanInitialized)
-
-					if stmt.Result != nil {
-						stmt.Result.RowsAffected = db.RowsAffected
-					}
-				} else {
-					db.AddError(err)
-				}
-				return
-			}
-		}
-
-		// Hard delete with RETURNING - use ExecContext (for PL/SQL blocks)
+		// Hard delete & soft delete with RETURNING - use ExecContext (for PL/SQL blocks)
 		result, err := stmt.ConnPool.ExecContext(stmt.Context, stmt.SQL.String(), stmt.Vars...)
 		if err == nil {
 			db.RowsAffected, _ = result.RowsAffected()

oracle/oracle.go

@@ -102,6 +102,7 @@ func (d Dialector) Initialize(db *gorm.DB) (err error) {
 	callback.Create().Replace("gorm:create", Create)
 	callback.Delete().Replace("gorm:delete", Delete)
 	callback.Update().Replace("gorm:update", Update)
+	callback.Query().Before("gorm:query").Register("oracle:before_query", BeforeQuery)
 
 	maps.Copy(db.ClauseBuilders, OracleClauseBuilders())