Merge branch 'main' into migrate_nullable_fix

# Conflicts:
#	tests/passed-tests.txt

Author: jawad-arb123

oracle/clause_builder.go

@@ -325,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)
@@ -335,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/create.go

@@ -267,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)
 		}
 	}
@@ -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 ")
@@ -425,7 +428,7 @@ func buildBulkMergePLSQL(db *gorm.DB, createValues clause.Values, onConflictClau
 		}
 		plsqlBuilder.WriteString("    WHEN MATCHED THEN UPDATE SET t.")
 		writeQuotedIdentifier(&plsqlBuilder, noopCol)
-		plsqlBuilder.WriteString(" = t.")
+		plsqlBuilder.WriteString(" = s.")
 		writeQuotedIdentifier(&plsqlBuilder, noopCol)
 		plsqlBuilder.WriteString("\n")
 	}

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())
 

oracle/query.go

@@ -0,0 +1,67 @@
+/*
+** Copyright (c) 2025 Oracle and/or its affiliates.
+**
+** The Universal Permissive License (UPL), Version 1.0
+**
+** Subject to the condition set forth below, permission is hereby granted to any
+** person obtaining a copy of this software, associated documentation and/or data
+** (collectively the "Software"), free of charge and under any and all copyright
+** rights in the Software, and any and all patent rights owned or freely
+** licensable by each licensor hereunder covering either (i) the unmodified
+** Software as contributed to or provided by such licensor, or (ii) the Larger
+** Works (as defined below), to deal in both
+**
+** (a) the Software, and
+** (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+** one is included with the Software (each a "Larger Work" to which the Software
+** is contributed by such licensors),
+**
+** without restriction, including without limitation the rights to copy, create
+** derivative works of, display, perform, and distribute the Software and make,
+** use, sell, offer for sale, import, export, have made, and have sold the
+** Software and the Larger Work(s), and to sublicense the foregoing rights on
+** either these or other terms.
+**
+** This license is subject to the following condition:
+** The above copyright notice and either this complete permission notice or at
+** a minimum a reference to the UPL must be included in all copies or
+** substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+** SOFTWARE.
+ */
+
+package oracle
+
+import (
+	"gorm.io/gorm"
+	"regexp"
+	"strings"
+)
+
+// Identifies the table name alias provided as
+// "\"users\" \"u\"" and "\"users\" u". Gorm already handles
+// the other formats like "users u", "users AS u" etc.
+var tableRegexp = regexp.MustCompile(`^"(\w+)"\s+"?(\w+)"?$`)
+
+func BeforeQuery(db *gorm.DB) {
+	if db == nil || db.Statement == nil || db.Statement.TableExpr == nil {
+		return
+	}
+	name := db.Statement.TableExpr.SQL
+	if strings.Contains(name, " ") || strings.Contains(name, "`") {
+		if results := tableRegexp.FindStringSubmatch(name); len(results) == 3 {
+			if results[2] != "" {
+				db.Statement.Table = results[2]
+			} else {
+				db.Statement.Table = results[1]
+			}
+		}
+	}
+	return
+}

tests/benchmark_test.go

@@ -43,6 +43,7 @@ import (
 	"testing"
 
 	. "github.com/oracle-samples/gorm-oracle/tests/utils"
+	
 )
 
 func BenchmarkCreate(b *testing.B) {
@@ -120,3 +121,113 @@ func BenchmarkDelete(b *testing.B) {
 		DB.Delete(&user)
 	}
 }
+
+func BenchmarkCreateInBatches(b *testing.B) {
+	users := make([]User, 100)
+	for i := 0; i < len(users); i++ {
+		users[i] = *GetUser(fmt.Sprintf("batch-%d", i), Config{})
+	}
+
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.CreateInBatches(users, 20)
+	}
+}
+
+func BenchmarkFirst(b *testing.B) {
+	user := *GetUser("first", Config{})
+	DB.Create(&user)
+
+	var u User
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.First(&u, user.ID)
+	}
+}
+
+func BenchmarkWhere(b *testing.B) {
+	user := *GetUser("where", Config{})
+	DB.Create(&user)
+
+	var u User
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.Where("name = ?", user.Name).First(&u)
+	}
+}
+
+func BenchmarkCount(b *testing.B) {
+	for i := 0; i < 1000; i++ {
+		user := *GetUser(fmt.Sprintf("count-%d", i), Config{})
+		DB.Create(&user)
+	}
+
+	var count int64
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.Model(&User{}).Count(&count)
+	}
+}
+
+func BenchmarkTransaction(b *testing.B) {
+	for x := 0; x < b.N; x++ {
+		DB.Transaction(func(tx *gorm.DB) error {
+			user := *GetUser(fmt.Sprintf("tx-%d", x), Config{})
+			return tx.Create(&user).Error
+		})
+	}
+}
+
+func BenchmarkJoin(b *testing.B) {
+	user := *GetUser("join-user", Config{})
+	DB.Create(&user)
+
+	type Profile struct {
+		ID     uint
+		UserID uint
+		Bio    string
+	}
+	DB.AutoMigrate(&Profile{})
+	DB.Create(&Profile{UserID: user.ID, Bio: "benchmark profile"})
+
+	var result struct {
+		User
+		Profile
+	}
+
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.Table("users").
+			Select("users.id, users.name, profiles.bio").
+			Joins("left join profiles on profiles.user_id = users.id").
+			Where("users.id = ?", user.ID).
+			Scan(&result)
+	}
+}
+
+func BenchmarkPagination(b *testing.B) {
+	DB.Exec("delete from users")
+	for i := 0; i < 10000; i++ {
+		user := *GetUser(fmt.Sprintf("page-%d", i), Config{})
+		DB.Create(&user)
+	}
+
+	var users []User
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.Limit(50).Offset(200).Find(&users)
+	}
+}
+
+func BenchmarkBulkDelete(b *testing.B) {
+	DB.Exec("delete from users")
+	for i := 0; i < 5000; i++ {
+		user := *GetUser(fmt.Sprintf("bulk-%d", i), Config{})
+		DB.Create(&user)
+	}
+
+	b.ResetTimer()
+	for x := 0; x < b.N; x++ {
+		DB.Where("id < ?", 2500).Delete(&User{})
+	}
+}