Merge branch 'main' into hkhasnis_boolean_type

Merge with main

Author: Harshit-Khasnis

oracle/common.go

@@ -39,19 +39,30 @@
 package oracle
 
 import (
+	"bytes"
 	"database/sql"
 	"encoding/json"
 	"fmt"
+	"math"
 	"reflect"
 	"strings"
 	"time"
 
+	"github.com/godror/godror"
 	"github.com/google/uuid"
 	"gorm.io/datatypes"
 	"gorm.io/gorm"
 	"gorm.io/gorm/schema"
 )
 
+// Extra data types for the data type that are not declared in the
+// default DataType list
+const (
+	JSON                  schema.DataType = "json"
+	Timestamp             schema.DataType = "timestamp"
+	TimestampWithTimeZone schema.DataType = "timestamp with time zone"
+)
+
 // Helper function to get Oracle array type for a field
 func getOracleArrayType(field *schema.Field, values []any) string {
 	switch field.DataType {
@@ -61,6 +72,10 @@ func getOracleArrayType(field *schema.Field, values []any) string {
 		return "TABLE OF NUMBER"
 	case schema.Float:
 		return "TABLE OF NUMBER"
+	case JSON:
+		// PL/SQL does not yet allow declaring collections of JSON (TABLE OF JSON) directly.
+		// Workaround for JSON type
+		fallthrough
 	case schema.String:
 		if field.Size > 0 && field.Size <= 4000 {
 			return fmt.Sprintf("TABLE OF VARCHAR2(%d)", field.Size)
@@ -79,7 +94,7 @@ func getOracleArrayType(field *schema.Field, values []any) string {
 	case schema.Bytes:
 		return "TABLE OF BLOB"
 	default:
-		return "TABLE OF VARCHAR2(4000)" // Safe default
+		return "TABLE OF " + strings.ToUpper(string(field.DataType))
 	}
 }
 
@@ -113,8 +128,37 @@ func findFieldByDBName(schema *schema.Schema, dbName string) *schema.Field {
 // Create typed destination for OUT parameters
 func createTypedDestination(f *schema.Field) interface{} {
 	if f == nil {
-		var s string
-		return &s
+		return new(string)
+	}
+
+	// If the field has a serializer, the field type may not be directly related to the column type in the database.
+	// In this case, determine the destination type using the field's data type, which is the column type in the
+	// database.
+	if f.Serializer != nil {
+		dt := strings.ToLower(string(f.DataType))
+		switch schema.DataType(dt) {
+		case schema.Bool:
+			return new(bool)
+		case schema.Uint:
+			return new(uint64)
+		case schema.Int:
+			return new(int64)
+		case schema.Float:
+			return new(float64)
+		case schema.String:
+			return new(string)
+		case Timestamp:
+			fallthrough
+		case TimestampWithTimeZone:
+			fallthrough
+		case schema.Time:
+			return new(time.Time)
+		case schema.Bytes:
+			return new([]byte)
+		default:
+			// Fallback
+			return new(string)
+		}
 	}
 
 	ft := f.FieldType
@@ -163,8 +207,7 @@ func createTypedDestination(f *schema.Field) interface{} {
 	}
 
 	// Fallback
-	var s string
-	return &s
+	return new(string)
 }
 
 // Convert values for Oracle-specific types
@@ -206,6 +249,14 @@ func convertValue(val interface{}) interface{} {
 			return 0
 		}
 	case string:
+		if len(v) > math.MaxInt16 {
+			return godror.Lob{IsClob: true, Reader: strings.NewReader(v)}
+		}
+		return v
+	case []byte:
+		if len(v) > math.MaxInt16 {
+			return godror.Lob{IsClob: false, Reader: bytes.NewReader(v)}
+		}
 		return v
 	default:
 		return val
@@ -218,6 +269,13 @@ func convertFromOracleToField(value interface{}, field *schema.Field) interface{
 		return nil
 	}
 
+	// Deserialize data into objects when a serializer is used
+	if field.Serializer != nil {
+		serializerField := field.NewValuePool.Get().(sql.Scanner)
+		serializerField.Scan(value)
+		return serializerField
+	}
+
 	targetType := field.FieldType
 	var converted any
 

oracle/migrator.go

@@ -202,7 +202,7 @@ func (m Migrator) CreateTable(values ...interface{}) error {
 			createTableSQL += ")"
 
 			if tableOption, ok := m.DB.Get("gorm:table_options"); ok {
-				createTableSQL += fmt.Sprint(tableOption)
+				createTableSQL += " " + fmt.Sprint(tableOption)
 			}
 
 			err = tx.Exec(createTableSQL, values...).Error
@@ -484,6 +484,81 @@ func (m Migrator) DropConstraint(value interface{}, name string) error {
 	return m.Migrator.DropConstraint(value, name)
 }
 
+// CreateType creates or replaces an Oracle user-defined type
+func (m Migrator) CreateType(typeName string, args ...string) error {
+	typeName = strings.TrimSpace(typeName)
+	if typeName == "" {
+		return fmt.Errorf("typeName is required")
+	}
+	var typeKind, typeOf string
+	if len(args) > 0 {
+		typeKind = args[0]
+	}
+	if len(args) > 1 {
+		typeOf = args[1]
+	}
+
+	name := strings.ToLower(typeName)
+	typeKind = strings.TrimSpace(typeKind)
+	typeOf = strings.TrimSpace(typeOf)
+
+	// Incomplete object type
+	if typeKind == "" && typeOf == "" {
+		ddl := fmt.Sprintf(`CREATE TYPE "%s"`, name)
+		return m.DB.Exec(ddl).Error
+	}
+
+	k := strings.ToUpper(typeKind)
+	var ddl string
+
+	switch {
+	// Standalone varying array (varray) type and Standalone nested table type
+	case strings.HasPrefix(k, "VARRAY") || strings.HasPrefix(k, "TABLE "):
+		if typeOf == "" {
+			return fmt.Errorf("typeof is required for collection types (VARRAY/TABLE)")
+		}
+		ddl = fmt.Sprintf(`CREATE OR REPLACE TYPE "%s" AS %s OF %s`, name, typeKind, typeOf)
+
+	// Abstract Data Type (ADT)
+	case k == "OBJECT" || strings.HasPrefix(k, "OBJECT"):
+		if typeOf == "" {
+			return fmt.Errorf("attributes definition is required for OBJECT types")
+		}
+		attrs := typeOf
+		if !strings.HasPrefix(attrs, "(") {
+			attrs = "(" + attrs + ")"
+		}
+		ddl = fmt.Sprintf(`CREATE OR REPLACE TYPE "%s" AS OBJECT %s`, name, attrs)
+
+	default:
+		// Invalid or unsupported types
+		return fmt.Errorf("unsupported type kind %q (must be OBJECT, VARRAY, or TABLE)", typeKind)
+	}
+
+	return m.DB.Exec(ddl).Error
+}
+
+// DropType drops a user-defined type
+func (m Migrator) DropType(typeName string) error {
+	typeName = strings.TrimSpace(typeName)
+	if typeName == "" {
+		return fmt.Errorf("dropType: typeName is required")
+	}
+	ddl := fmt.Sprintf(`DROP TYPE "%s" FORCE`, strings.ToLower(typeName))
+	return m.DB.Exec(ddl).Error
+}
+
+// HasType checks whether a user-defined type exists
+func (m Migrator) HasType(typeName string) bool {
+	if typeName == "" {
+		return false
+	}
+
+	var count int
+	err := m.DB.Raw(`SELECT COUNT(*) FROM USER_TYPES WHERE UPPER(TYPE_NAME) = UPPER(?)`, typeName).Scan(&count).Error
+	return err == nil && count > 0
+}
+
 // DropIndex drops the index with the specified `name` from the table associated with `value`
 func (m Migrator) DropIndex(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {

oracle/query.go

@@ -57,11 +57,7 @@ func BeforeQuery(db *gorm.DB) {
 	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]
-			}
+			db.Statement.Table = results[2]
 		}
 	}
 }

oracle/update.go

@@ -109,6 +109,11 @@ func Update(db *gorm.DB) {
 			// Always use PL/SQL for RETURNING, just like delete callback
 			buildUpdatePLSQL(db)
 		} else {
+			if updateClause, ok := stmt.Clauses["UPDATE"].Expression.(clause.Update); ok {
+				if updateClause.Table.Name != "" {
+					stmt.Table = updateClause.Table.Name
+				}
+			}
 			// Use GORM's standard build for non-RETURNING updates
 			stmt.Build("UPDATE", "SET", "WHERE")
 			// Convert values for Oracle
@@ -163,7 +168,6 @@ func checkMissingWhereConditions(db *gorm.DB) {
 					}
 					// Has non-soft-delete equality condition, this is valid
 					hasMeaningfulConditions = true
-					break
 				case clause.IN:
 					// Has IN condition with values, this is valid
 					if len(e.Values) > 0 {
@@ -182,11 +186,9 @@ func checkMissingWhereConditions(db *gorm.DB) {
 					}
 					// Has non-soft-delete expression condition, consider it valid
 					hasMeaningfulConditions = true
-					break
 				case clause.AndConditions, clause.OrConditions:
 					// Complex conditions are likely valid (but we could be more thorough here)
 					hasMeaningfulConditions = true
-					break
 				case clause.Where:
 					// Handle nested WHERE clauses - recursively check their expressions
 					if len(e.Exprs) > 0 {
@@ -203,7 +205,6 @@ func checkMissingWhereConditions(db *gorm.DB) {
 				default:
 					// Unknown condition types - assume they're meaningful for safety
 					hasMeaningfulConditions = true
-					break
 				}
 
 				// If we found meaningful conditions, we can stop checking

tests/blob_test.go

@@ -41,33 +41,44 @@ package tests
 import (
 	"bytes"
 	"crypto/rand"
+	"strings"
 	"testing"
 	"time"
 
 	"gorm.io/gorm"
 )
 
 type BlobTestModel struct {
-	ID          uint   `gorm:"primaryKey;autoIncrement"`
-	Name        string `gorm:"size:100;not null"`
-	Data        []byte `gorm:"type:blob"`
+	ID           uint    `gorm:"primaryKey;autoIncrement"`
+	Name         string  `gorm:"size:100;not null"`
+	Data         []byte  `gorm:"type:blob"`
 	OptionalData *[]byte `gorm:"type:blob"`
-	CreatedAt   time.Time
-	UpdatedAt   time.Time
+	CreatedAt    time.Time
+	UpdatedAt    time.Time
 }
 
 type BlobVariantModel struct {
-	ID       uint   `gorm:"primaryKey"`
+	ID        uint   `gorm:"primaryKey"`
 	SmallBlob []byte `gorm:"type:blob"`
 	LargeBlob []byte `gorm:"type:blob"`
 }
 
+type BlobOneToManyModel struct {
+	ID       uint             `gorm:"primaryKey"`
+	Children []BlobChildModel `gorm:"foreignKey:ID"`
+}
+
+type BlobChildModel struct {
+	ID   uint   `gorm:"primaryKey"`
+	Data []byte `gorm:"type:blob"`
+}
+
 func setupBlobTestTables(t *testing.T) {
 	t.Log("Setting up BLOB test tables")
 
-	DB.Migrator().DropTable(&BlobTestModel{}, &BlobVariantModel{})
+	DB.Migrator().DropTable(&BlobTestModel{}, &BlobVariantModel{}, &BlobOneToManyModel{}, &BlobChildModel{})
 
-	err := DB.AutoMigrate(&BlobTestModel{}, &BlobVariantModel{})
+	err := DB.AutoMigrate(&BlobTestModel{}, &BlobVariantModel{}, &BlobOneToManyModel{}, &BlobChildModel{})
 	if err != nil {
 		t.Fatalf("Failed to migrate BLOB test tables: %v", err)
 	}
@@ -423,6 +434,23 @@ func TestBlobWithReturning(t *testing.T) {
 	}
 }
 
+func TestBlobOnConflict(t *testing.T) {
+	setupBlobTestTables(t)
+
+	model := &BlobOneToManyModel{
+		ID: 1,
+		Children: []BlobChildModel{
+			{
+				Data: []byte(strings.Repeat("X", 32768)),
+			},
+		},
+	}
+	err := DB.Create(model).Error
+	if err != nil {
+		t.Fatalf("Failed to create BLOB record with ON CONFLICT: %v", err)
+	}
+}
+
 func TestBlobErrorHandling(t *testing.T) {
 	setupBlobTestTables(t)