fix: implement GetDBConn() interface for db.DB() method access

- Fixed critical issue where db.DB() method failed due to missing GetDBConnector interface
- Implemented GetDBConn() method in connection wrapper to provide proper *sql.DB access
- Maintains compatibility with existing time pointer conversion functionality
- Follows same pattern used by official GORM drivers (PostgreSQL, MySQL, SQLite)
- Enables downstream projects to access underlying *sql.DB for connection pooling and health checks
- Added standalone array utilities (ArrayLiteral, SimpleArrayScanner) for optional use
- Updated documentation and addressed array/vector support issue report

Fixes: db.DB() method compatibility
Version: 0.2.1

Author: greysquirr3l

.gitignore

@@ -40,3 +40,5 @@ Thumbs.db
 *.log
 
 next.md
+RELEASE.md
+bugs/

CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to the GORM DuckDB driver will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2025-06-25
+
+### Fixed
+
+- **Database Connection Access**: Fixed critical issue where `db.DB()` method failed due to missing `GetDBConnector` interface implementation
+- **Connection Wrapper**: Implemented `GetDBConn() (*sql.DB, error)` method in connection wrapper to provide proper access to underlying `*sql.DB`
+- **GORM Compatibility**: Ensures compatibility with applications requiring direct database access for connection pooling, health checks, and advanced operations
+- **Time Pointer Conversion**: Maintained existing time pointer conversion functionality while fixing `db.DB()` access
+
+#### Technical Notes
+
+- Connection wrapper now properly implements GORM's `GetDBConnector` interface
+- Follows same pattern used by official GORM drivers (PostgreSQL, MySQL, SQLite)
+- Enables downstream projects to call `db.DB()` for `*sql.DB` access while preserving DuckDB-specific features
+- All existing functionality (CRUD operations, extensions, time handling) remains unchanged
+
 ## [0.2.0] - 2025-06-23
 
 ### Added

README.md

@@ -239,6 +239,95 @@ type Config struct {
 - The driver follows DuckDB's SQL dialect and capabilities
 - For production use, consider DuckDB's performance characteristics for your specific use case
 
+## Known Limitations
+
+While this driver provides full GORM compatibility, there are some DuckDB-specific limitations to be aware of:
+
+### Migration Schema Validation
+
+**Issue:** DuckDB's `PRAGMA table_info()` returns slightly different column metadata format than PostgreSQL/MySQL.
+
+**Symptoms:**
+
+- GORM AutoMigrate occasionally reports false schema differences
+- Unnecessary migration attempts on startup  
+- Warnings in logs about column type mismatches
+
+**Example Warning:**
+
+```text
+[WARN] column type mismatch: expected 'VARCHAR', got 'STRING'
+```
+
+**Workaround:**
+
+```go
+// Disable automatic migration validation for specific cases
+db.AutoMigrate(&YourModel{})
+// Add manual validation if needed
+```
+
+**Impact:** Low - Cosmetic warnings, doesn't affect functionality
+
+### Transaction Isolation Levels
+
+**Issue:** DuckDB has limited transaction isolation level support compared to traditional databases.
+
+**Symptoms:**
+
+- `db.Begin().Isolation()` methods have limited options
+- Some GORM transaction patterns may not work as expected
+- Read phenomena behavior differs from PostgreSQL
+
+**Workaround:**
+
+```go
+// Use simpler transaction patterns
+tx := db.Begin()
+defer func() {
+    if r := recover(); r != nil {
+        tx.Rollback()
+    }
+}()
+
+// Perform operations...
+if err := tx.Commit().Error; err != nil {
+    return err
+}
+```
+
+**Impact:** Low - Simple transactions work fine, complex isolation scenarios need adjustment
+
+### Time Pointer Conversion
+
+**Issue:** Current implementation has limitations with `*time.Time` pointer conversion in some edge cases.
+
+**Symptoms:**
+
+- Potential issues when working with nullable time fields
+- Some time pointer operations may not behave identically to other GORM drivers
+
+**Workaround:**
+
+```go
+// Use time.Time instead of *time.Time when possible
+type Model struct {
+    ID        uint      `gorm:"primarykey"`
+    CreatedAt time.Time // Preferred
+    UpdatedAt time.Time // Preferred
+    DeletedAt gorm.DeletedAt `gorm:"index"` // This works fine
+}
+```
+
+**Impact:** Low - Standard GORM time handling works correctly
+
+## Performance Considerations
+
+- DuckDB is optimized for analytical workloads (OLAP) rather than transactional workloads (OLTP)
+- For high-frequency write operations, consider batching or using traditional OLTP databases
+- DuckDB excels at complex queries, aggregations, and read-heavy workloads
+- For production use, consider DuckDB's performance characteristics for your specific use case
+
 ## Contributing
 
 This DuckDB driver aims to become an official GORM driver. Contributions are welcome!

array_minimal.go

@@ -0,0 +1,234 @@
+package duckdb
+
+import (
+	"database/sql/driver"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// isSliceType checks if a type is a supported slice type for DuckDB arrays
+func isSliceType(t reflect.Type) bool {
+	if t.Kind() != reflect.Slice {
+		return false
+	}
+
+	elem := t.Elem()
+	switch elem.Kind() {
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return true
+	case reflect.Bool:
+		return true
+	default:
+		return false
+	}
+}
+
+// formatSliceForDuckDB converts a Go slice to DuckDB array literal syntax
+func formatSliceForDuckDB(value interface{}) (string, error) {
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice {
+		return "", fmt.Errorf("expected slice, got %T", value)
+	}
+
+	if v.Len() == 0 {
+		return "[]", nil
+	}
+
+	var elements []string
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i)
+		switch elem.Kind() {
+		case reflect.Float32, reflect.Float64:
+			elements = append(elements, fmt.Sprintf("%g", elem.Float()))
+		case reflect.String:
+			// Escape single quotes in strings
+			str := strings.ReplaceAll(elem.String(), "'", "''")
+			elements = append(elements, fmt.Sprintf("'%s'", str))
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			elements = append(elements, fmt.Sprintf("%d", elem.Int()))
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			elements = append(elements, fmt.Sprintf("%d", elem.Uint()))
+		case reflect.Bool:
+			if elem.Bool() {
+				elements = append(elements, "true")
+			} else {
+				elements = append(elements, "false")
+			}
+		default:
+			return "", fmt.Errorf("unsupported slice element type: %v", elem.Kind())
+		}
+	}
+
+	return "[" + strings.Join(elements, ", ") + "]", nil
+}
+
+// ArrayLiteral wraps a Go slice to be formatted as a DuckDB array literal
+type ArrayLiteral struct {
+	Data interface{}
+}
+
+// Value implements driver.Valuer for DuckDB array literals
+func (al ArrayLiteral) Value() (driver.Value, error) {
+	if al.Data == nil {
+		return nil, nil
+	}
+
+	return formatSliceForDuckDB(al.Data)
+}
+
+// SimpleArrayScanner provides basic array scanning functionality
+type SimpleArrayScanner struct {
+	Target interface{} // Pointer to slice
+}
+
+// Scan implements sql.Scanner for basic array types
+func (sas *SimpleArrayScanner) Scan(value interface{}) error {
+	if value == nil {
+		return nil
+	}
+
+	// Handle Go slice types directly (DuckDB returns []interface{})
+	if slice, ok := value.([]interface{}); ok {
+		targetValue := reflect.ValueOf(sas.Target)
+		if targetValue.Kind() != reflect.Ptr || targetValue.Elem().Kind() != reflect.Slice {
+			return fmt.Errorf("target must be pointer to slice")
+		}
+
+		sliceType := targetValue.Elem().Type()
+		elemType := sliceType.Elem()
+		result := reflect.MakeSlice(sliceType, len(slice), len(slice))
+
+		for i, elem := range slice {
+			elemValue := result.Index(i)
+
+			switch elemType.Kind() {
+			case reflect.Float64:
+				// Handle both float32 and float64 from DuckDB
+				switch f := elem.(type) {
+				case float64:
+					elemValue.SetFloat(f)
+				case float32:
+					elemValue.SetFloat(float64(f))
+				default:
+					return fmt.Errorf("expected float32/float64, got %T at index %d", elem, i)
+				}
+			case reflect.String:
+				if s, ok := elem.(string); ok {
+					elemValue.SetString(s)
+				} else {
+					return fmt.Errorf("expected string, got %T at index %d", elem, i)
+				}
+			case reflect.Int64:
+				// Handle various integer types from DuckDB
+				switch i := elem.(type) {
+				case int64:
+					elemValue.SetInt(i)
+				case int32:
+					elemValue.SetInt(int64(i))
+				case int:
+					elemValue.SetInt(int64(i))
+				default:
+					return fmt.Errorf("expected integer type, got %T at index %d", elem, i)
+				}
+			case reflect.Bool:
+				if b, ok := elem.(bool); ok {
+					elemValue.SetBool(b)
+				} else {
+					return fmt.Errorf("expected bool, got %T at index %d", elem, i)
+				}
+			default:
+				return fmt.Errorf("unsupported target element type: %v", elemType.Kind())
+			}
+		}
+
+		targetValue.Elem().Set(result)
+		return nil
+	}
+
+	// Fallback: Handle string representations of arrays
+	var arrayStr string
+	switch v := value.(type) {
+	case string:
+		arrayStr = v
+	case []byte:
+		arrayStr = string(v)
+	default:
+		return fmt.Errorf("cannot scan %T into SimpleArrayScanner", value)
+	}
+
+	// Parse DuckDB array format: [1.0, 2.0, 3.0] or [item1, item2, item3]
+	arrayStr = strings.TrimSpace(arrayStr)
+	if !strings.HasPrefix(arrayStr, "[") || !strings.HasSuffix(arrayStr, "]") {
+		return fmt.Errorf("invalid array format: %s", arrayStr)
+	}
+
+	// Remove brackets
+	content := arrayStr[1 : len(arrayStr)-1]
+	content = strings.TrimSpace(content)
+
+	if content == "" {
+		// Empty array
+		targetValue := reflect.ValueOf(sas.Target)
+		if targetValue.Kind() != reflect.Ptr || targetValue.Elem().Kind() != reflect.Slice {
+			return fmt.Errorf("target must be pointer to slice")
+		}
+		targetValue.Elem().Set(reflect.MakeSlice(targetValue.Elem().Type(), 0, 0))
+		return nil
+	}
+
+	// Split elements and parse based on target type
+	elements := strings.Split(content, ",")
+	targetValue := reflect.ValueOf(sas.Target)
+	if targetValue.Kind() != reflect.Ptr || targetValue.Elem().Kind() != reflect.Slice {
+		return fmt.Errorf("target must be pointer to slice")
+	}
+
+	sliceType := targetValue.Elem().Type()
+	elemType := sliceType.Elem()
+	result := reflect.MakeSlice(sliceType, len(elements), len(elements))
+
+	for i, elemStr := range elements {
+		elemStr = strings.TrimSpace(elemStr)
+		elemValue := result.Index(i)
+
+		switch elemType.Kind() {
+		case reflect.Float64:
+			var f float64
+			if _, err := fmt.Sscanf(elemStr, "%f", &f); err != nil {
+				return fmt.Errorf("failed to parse float: %s", elemStr)
+			}
+			elemValue.SetFloat(f)
+		case reflect.String:
+			// Remove quotes if present
+			if strings.HasPrefix(elemStr, "'") && strings.HasSuffix(elemStr, "'") {
+				elemStr = elemStr[1 : len(elemStr)-1]
+				elemStr = strings.ReplaceAll(elemStr, "''", "'") // Unescape quotes
+			}
+			elemValue.SetString(elemStr)
+		case reflect.Int64:
+			var i int64
+			if _, err := fmt.Sscanf(elemStr, "%d", &i); err != nil {
+				return fmt.Errorf("failed to parse int: %s", elemStr)
+			}
+			elemValue.SetInt(i)
+		case reflect.Bool:
+			var b bool
+			if _, err := fmt.Sscanf(elemStr, "%t", &b); err != nil {
+				return fmt.Errorf("failed to parse bool: %s", elemStr)
+			}
+			elemValue.SetBool(b)
+		default:
+			return fmt.Errorf("unsupported target element type: %v", elemType.Kind())
+		}
+	}
+
+	targetValue.Elem().Set(result)
+	return nil
+}