Merge remote-tracking branch 'origin/main' into joboon-SupportUnquotedIdentifiers

Author: ting-lan-wang

.github/workflows/run-tests.yaml

@@ -47,4 +47,4 @@ jobs:
         cd tests
         go get -t github.com/oracle-samples/gorm-oracle/tests
         go get .
-        go test -failfast
+        go test -failfast

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

oracle/migrator.go

@@ -308,15 +308,47 @@ func (m Migrator) DropColumn(value interface{}, name string) error {
 func (m Migrator) AlterColumn(value interface{}, field string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
 		if stmt.Schema != nil {
-			if field := stmt.Schema.LookUpField(field); field != nil {
-				fileType := m.FullDataTypeOf(field)
+			if f := stmt.Schema.LookUpField(field); f != nil {
+				columnTypes, err := m.ColumnTypes(value)
+				if err != nil {
+					return err
+				}
+
+				var currentNullable bool
+				var currentType string
+				for _, col := range columnTypes {
+					if strings.EqualFold(col.Name(), f.DBName) {
+						currentNullable, _ = col.Nullable()
+						currentType = strings.ToUpper(col.DatabaseTypeName())
+						break
+					}
+				}
+
+				desiredNullable := !f.NotNull
+				desiredType := strings.ToUpper(m.DataTypeOf(f))
+
+				// nullable → non-nullable → skip
+				if currentNullable && !desiredNullable {
+					return nil
+				}
+
+				// same type + same nullability → skip
+				if currentNullable == desiredNullable && strings.Contains(currentType, desiredType) {
+					return nil
+				}
+
+				sql := "ALTER TABLE ? MODIFY ? " + m.DataTypeOf(f)
+				if f.NotNull {
+					sql += " NOT NULL"
+				} else if !currentNullable && desiredNullable {
+					sql += " NULL"
+				}
+
 				return m.DB.Exec(
-					"ALTER TABLE ? MODIFY ? ?",
+					sql,
 					clause.Table{Name: stmt.Schema.Table},
-					clause.Column{Name: field.DBName},
-					fileType,
+					clause.Column{Name: f.DBName},
 				).Error
-
 			}
 		}
 		return fmt.Errorf("failed to look up field with name: %s", field)

tests/associations_many2many_test.go

@@ -461,3 +461,179 @@ func TestMany2ManyDuplicateBelongsToAssociation(t *testing.T) {
 	tests.AssertEqual(t, nil, err)
 	tests.AssertEqual(t, user2, findUser2)
 }
+
+func TestMany2ManyEmptyAssociations(t *testing.T) {
+	user := User{Name: "TestEmptyAssociations"}
+
+	// Create user with no associations
+	if err := DB.Create(&user).Error; err != nil {
+		t.Fatalf("errors happened when create user: %v", err)
+	}
+
+	var languages []Language
+	if err := DB.Model(&user).Association("Languages").Find(&languages); err != nil {
+		t.Errorf("Error finding empty associations: %v", err)
+	}
+
+	if len(languages) != 0 {
+		t.Errorf("Expected 0 languages, got %d", len(languages))
+	}
+
+	count := DB.Model(&user).Association("Languages").Count()
+	if count != 0 {
+		t.Errorf("Expected count 0 for empty association, got %d", count)
+	}
+
+	if err := DB.Model(&user).Association("Languages").Clear(); err != nil {
+		t.Errorf("Error clearing empty association: %v", err)
+	}
+
+	if err := DB.Model(&user).Association("Languages").Delete(&Language{}); err != nil {
+		t.Errorf("Error deleting from empty association: %v", err)
+	}
+}
+
+func TestMany2ManyAssociationCountValidation(t *testing.T) {
+	user := *GetUser("count-validation", Config{Languages: 3})
+
+	if err := DB.Create(&user).Error; err != nil {
+		t.Fatalf("errors happened when create: %v", err)
+	}
+
+	// Initial count check
+	initialCount := DB.Model(&user).Association("Languages").Count()
+	if initialCount != 3 {
+		t.Fatalf("Expected initial count 3, got %d", initialCount)
+	}
+
+	newLanguages := []Language{
+		{Code: "count-test-1", Name: "Count Test 1"},
+		{Code: "count-test-2", Name: "Count Test 2"},
+	}
+	DB.Create(&newLanguages)
+
+	if err := DB.Model(&user).Association("Languages").Append(&newLanguages); err != nil {
+		t.Fatalf("Error appending languages: %v", err)
+	}
+
+	// Check count after append
+	countAfterAppend := DB.Model(&user).Association("Languages").Count()
+	if countAfterAppend != 5 {
+		t.Errorf("Expected count 5 after append, got %d", countAfterAppend)
+	}
+
+	replaceLanguage := Language{Code: "count-replace", Name: "Count Replace"}
+	DB.Create(&replaceLanguage)
+
+	if err := DB.Model(&user).Association("Languages").Replace(&replaceLanguage); err != nil {
+		t.Fatalf("Error replacing languages: %v", err)
+	}
+
+	// Check count after replace
+	countAfterReplace := DB.Model(&user).Association("Languages").Count()
+	if countAfterReplace != 1 {
+		t.Errorf("Expected count 1 after replace, got %d", countAfterReplace)
+	}
+
+	// Verify actual data matches count
+	var actualLanguages []Language
+	DB.Model(&user).Association("Languages").Find(&actualLanguages)
+	if len(actualLanguages) != int(countAfterReplace) {
+		t.Errorf("Count mismatch: Count() returned %d but Find() returned %d languages",
+			countAfterReplace, len(actualLanguages))
+	}
+}
+
+func TestMany2ManyConstraintViolations(t *testing.T) {
+	user := *GetUser("constraint-test", Config{Languages: 1})
+
+	if err := DB.Create(&user).Error; err != nil {
+		t.Fatalf("errors happened when create: %v", err)
+	}
+
+	existingLanguage := user.Languages[0]
+
+	// append the same language again
+	if err := DB.Model(&user).Association("Languages").Append(&existingLanguage); err != nil {
+		t.Logf("Appending duplicate language resulted in: %v", err)
+	}
+
+	// Verify count is still correct after duplicate append attempt
+	count := DB.Model(&user).Association("Languages").Count()
+	if count > 1 {
+		t.Errorf("Expected count 1 after duplicate append, got %d", count)
+	}
+
+	tempLanguage := Language{Code: "temp-invalid", Name: "Temp Invalid"}
+	if err := DB.Create(&tempLanguage).Error; err != nil {
+		t.Logf("Could not create temp language for FK test: %v", err)
+		return
+	}
+
+	// append, then delete the language record to create inconsistency
+	if err := DB.Model(&user).Association("Languages").Append(&tempLanguage); err != nil {
+		t.Logf("Could not append temp language: %v", err)
+	}
+
+	// Delete the language record directly
+	DB.Unscoped().Delete(&tempLanguage)
+
+	// access associations after deleting referenced record
+	var languages []Language
+	if err := DB.Model(&user).Association("Languages").Find(&languages); err != nil {
+		t.Logf("Finding associations after FK deletion resulted in: %v", err)
+	}
+
+	// Get count before mass operation for verification
+	countBeforeMass := DB.Model(&user).Association("Languages").Count()
+	t.Logf("Language count before mass operation: %d", countBeforeMass)
+
+	var manyLanguages []Language
+	for i := 0; i < 10; i++ {
+		manyLanguages = append(manyLanguages, Language{
+			Code: fmt.Sprintf("mass-test-%d", i),
+			Name: fmt.Sprintf("Mass Test %d", i),
+		})
+	}
+
+	// Create the languages first
+	if err := DB.Create(&manyLanguages).Error; err != nil {
+		t.Logf("Creating many languages failed: %v", err)
+		return
+	}
+
+	// append all at once
+	if err := DB.Model(&user).Association("Languages").Append(&manyLanguages); err != nil {
+		t.Logf("Mass append operation resulted in: %v", err)
+	}
+
+	// Verify the operation completed with proper count validation
+	finalCount := DB.Model(&user).Association("Languages").Count()
+	// Should have at least the previous count + 10 new languages
+	expectedMinCount := countBeforeMass + 10
+
+	t.Logf("Final language count after mass operation: %d (expected at least %d)", finalCount, expectedMinCount)
+
+	if finalCount < expectedMinCount {
+		t.Errorf("Expected at least %d languages after mass append, got %d", expectedMinCount, finalCount)
+	}
+
+	var actualLanguages []Language
+	if err := DB.Model(&user).Association("Languages").Find(&actualLanguages); err == nil {
+		actualCount := len(actualLanguages)
+		if actualCount != int(finalCount) {
+			t.Errorf("Count mismatch: Count() returned %d but Find() returned %d languages",
+				finalCount, actualCount)
+		}
+	}
+
+	if err := DB.Model(&user).Association("Languages").Clear(); err != nil {
+		t.Errorf("Error clearing associations after mass operation: %v", err)
+	}
+
+	// Verify clear worked
+	countAfterClear := DB.Model(&user).Association("Languages").Count()
+	if countAfterClear != 0 {
+		t.Errorf("Expected count 0 after clear, got %d", countAfterClear)
+	}
+}