[WIP] Add Oracle support

callback_create.go

@@ -50,7 +50,10 @@ func createCallback(scope *Scope) {
 		for _, field := range scope.Fields() {
 			if scope.changeableField(field) {
 				if field.IsNormal {
-					if field.IsBlank && field.HasDefaultValue {
+					if _, ok := field.TagSettings["SEQUENCE"]; ok {
+						columns = append(columns, scope.Quote(field.DBName))
+						placeholders = append(placeholders, scope.Dialect().NextSequenceSQL(scope.TableName(), field.DBName))
+					} else if field.IsBlank && field.HasDefaultValue {
 						blankColumnsWithDefaultValue = append(blankColumnsWithDefaultValue, scope.Quote(field.DBName))
 						scope.InstanceSet("gorm:blank_columns_with_default_value", blankColumnsWithDefaultValue)
 					} else if !field.IsPrimaryKey || !field.IsBlank {

dialect.go

@@ -34,8 +34,8 @@ type Dialect interface {
 	// HasColumn check has column or not
 	HasColumn(tableName string, columnName string) bool
 
-	// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql has special case
+	// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql and oracle has special case
-	LimitAndOffsetSQL(limit, offset interface{}) string
+	LimitAndOffsetSQL(limit, offset interface{}) (whereSQL, suffixSQL string)
 	// SelectFromDummyTable return select values, for most dbs, `SELECT values` just works, mysql needs `SELECT value FROM DUAL`
 	SelectFromDummyTable() string
 	// LastInsertIdReturningSuffix most dbs support LastInsertId, but postgres needs to use `RETURNING`
@@ -46,6 +46,13 @@ type Dialect interface {
 
 	// CurrentDatabase return current database name
 	CurrentDatabase() string
+
+	// CreateSequenceSQL returns the sequence name for a given table and column. Oracle only.
+	SequenceName(tableName, columnName string) string
+
+	// NextSequenceSQL returns the SQL to fetch the next sequence value.
+	// It will be used in INSERT statements. Oracle only.
+	NextSequenceSQL(tableName, columnName string) string
 }
 
 var dialectsMap = map[string]Dialect{}

dialect_common.go

@@ -123,15 +123,15 @@ func (s commonDialect) CurrentDatabase() (name string) {
 	return
 }
 
-func (commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string) {
+func (commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (whereSQL, suffixSQL string) {
 	if limit != nil {
-		if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit > 0 {
+		if parsedLimit, _ := strconv.ParseInt(fmt.Sprint(limit), 0, 0); parsedLimit > 0 {
-			sql += fmt.Sprintf(" LIMIT %d", parsedLimit)
+			suffixSQL += fmt.Sprintf(" LIMIT %d", parsedLimit)
 		}
 	}
 	if offset != nil {
-		if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset > 0 {
+		if parsedOffset, _ := strconv.ParseInt(fmt.Sprint(offset), 0, 0); parsedOffset > 0 {
-			sql += fmt.Sprintf(" OFFSET %d", parsedOffset)
+			suffixSQL += fmt.Sprintf(" OFFSET %d", parsedOffset)
 		}
 	}
 	return
@@ -150,3 +150,11 @@ func (DefaultForeignKeyNamer) BuildForeignKeyName(tableName, field, dest string)
 	keyName = regexp.MustCompile("(_*[^a-zA-Z]+_*|_+)").ReplaceAllString(keyName, "_")
 	return keyName
 }
+
+func (*commonDialect) SequenceName(tableName, columnName string) string {
+	return ""
+}
+
+func (*commonDialect) NextSequenceSQL(tableName, columnName string) string {
+	return ""
+}

dialect_oci8.go

@@ -0,0 +1,144 @@
+package gorm
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type oci8 struct {
+	commonDialect
+}
+
+func init() {
+	RegisterDialect("oci8", new(oci8))
+}
+
+func (*oci8) GetName() string {
+	return "oci8"
+}
+
+func (o *oci8) Quote(key string) string {
+	// oracle only support names with a maximum of 30 characters
+	key = o.buildSha(key)
+	return fmt.Sprintf(`"%s"`, strings.ToUpper(key))
+}
+
+func (*oci8) SelectFromDummyTable() string {
+	return "FROM DUAL"
+}
+
+func (*oci8) BindVar(i int) string {
+	return fmt.Sprintf(":%d", i)
+}
+
+func (o *oci8) DataTypeOf(field *StructField) string {
+	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field)
+
+	if len(sqlType) == 0 {
+		switch dataValue.Kind() {
+		case reflect.Bool:
+			sqlType = "CHAR(1)"
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
+				field.TagSettings["SEQUENCE"] = "SEQUENCE"
+			}
+			sqlType = "INTEGER"
+		case reflect.Int64, reflect.Uint64:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
+				field.TagSettings["SEQUENCE"] = "SEQUENCE"
+			}
+			sqlType = "NUMBER"
+		case reflect.Float32, reflect.Float64:
+			sqlType = "FLOAT"
+		case reflect.String:
+			if size > 0 && size < 255 {
+				sqlType = fmt.Sprintf("VARCHAR(%d)", size)
+			} else {
+				sqlType = "VARCHAR(255)"
+			}
+		case reflect.Struct:
+			if _, ok := dataValue.Interface().(time.Time); ok {
+				sqlType = "TIMESTAMP"
+			}
+		case reflect.Array, reflect.Slice:
+			if isByteArrayOrSlice(dataValue) {
+				sqlType = "BLOB"
+			}
+		}
+	}
+
+	if len(sqlType) == 0 {
+		panic(fmt.Sprintf("invalid sql type %s (%s) for oci8", dataValue.Type().Name(), dataValue.Kind().String()))
+	}
+
+	if len(strings.TrimSpace(additionalType)) == 0 {
+		return sqlType
+	}
+	return fmt.Sprintf("%v %v", sqlType, additionalType)
+}
+
+func (o *oci8) HasIndex(tableName string, indexName string) bool {
+	var count int
+	o.db.QueryRow("SELECT COUNT(*) FROM USER_INDEXES WHERE TABLE_NAME = :1 AND INDEX_NAME = :2", strings.ToUpper(tableName), strings.ToUpper(indexName)).Scan(&count)
+	return count > 0
+}
+
+func (o *oci8) HasForeignKey(tableName string, foreignKeyName string) bool {
+	var count int
+	o.db.QueryRow("SELECT COUNT(*) FROM USER_CONSTRAINTS WHERE CONSTRAINT_TYPE = 'R' AND TABLE_NAME = :1 AND CONSTRAINT_NAME = :2", strings.ToUpper(tableName), strings.ToUpper(foreignKeyName)).Scan(&count)
+	return count > 0
+}
+
+func (o *oci8) HasTable(tableName string) bool {
+	var count int
+	o.db.QueryRow("SELECT COUNT(*) FROM USER_TABLES WHERE TABLE_NAME = :1", strings.ToUpper(tableName)).Scan(&count)
+	return count > 0
+}
+
+func (o *oci8) HasColumn(tableName string, columnName string) bool {
+	var count int
+	o.db.QueryRow("SELECT COUNT(*) FROM USER_TAB_COLUMNS WHERE TABLE_NAME = :1 AND COLUMN_NAME = :2", strings.ToUpper(tableName), strings.ToUpper(columnName)).Scan(&count)
+	return count > 0
+}
+
+func (*oci8) LimitAndOffsetSQL(limit, offset interface{}) (whereSQL, suffixSQL string) {
+	// switch limit := limit.(type) {
+	// case int, uint, uint8, int8, uint16, int16, uint32, int32, uint64, int64:
+	// 	whereSQL += fmt.Sprintf("ROWNUM <= %d", limit)
+	// }
+	return
+}
+
+func (o *oci8) BuildForeignKeyName(tableName, field, dest string) string {
+	keyName := o.commonDialect.BuildForeignKeyName(tableName, field, dest)
+	return o.buildSha(keyName)
+}
+
+func (o *oci8) SequenceName(tableName, columnName string) string {
+	seqName := fmt.Sprintf("%s_%s", tableName, columnName)
+	return o.buildSha(seqName)
+}
+
+func (o *oci8) NextSequenceSQL(tableName, columnName string) string {
+	return fmt.Sprintf("%s.NEXTVAL", o.SequenceName(tableName, columnName))
+}
+
+func (*oci8) buildSha(str string) string {
+	if utf8.RuneCountInString(str) <= 30 {
+		return str
+	}
+
+	h := sha1.New()
+	h.Write([]byte(str))
+	bs := h.Sum(nil)
+
+	result := fmt.Sprintf("%x", bs)
+	if len(result) <= 30 {
+		return result
+	}
+	return result[:29]
+}

dialects/mssql/mssql.go

@@ -128,15 +128,15 @@ func (s mssql) CurrentDatabase() (name string) {
 	return
 }
 
-func (mssql) LimitAndOffsetSQL(limit, offset interface{}) (sql string) {
+func (mssql) LimitAndOffsetSQL(limit, offset interface{}) (whereSQL, suffixSQL string) {
 	if limit != nil {
 		if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit > 0 {
-			sql += fmt.Sprintf(" FETCH NEXT %d ROWS ONLY", parsedLimit)
+			suffixSQL += fmt.Sprintf(" FETCH NEXT %d ROWS ONLY", parsedLimit)
 		}
 	}
 	if offset != nil {
 		if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset > 0 {
-			sql += fmt.Sprintf(" OFFSET %d ROWS", parsedOffset)
+			suffixSQL += fmt.Sprintf(" OFFSET %d ROWS", parsedOffset)
 		}
 	}
 	return
@@ -149,3 +149,11 @@ func (mssql) SelectFromDummyTable() string {
 func (mssql) LastInsertIDReturningSuffix(tableName, columnName string) string {
 	return ""
 }
+
+func (*mssql) SequenceName(tableName, columnName string) string {
+	return ""
+}
+
+func (*mssql) NextSequenceSQL(tableName, columnName string) string {
+	return ""
+}

dialects/oci8/oracle.go

@@ -0,0 +1,3 @@
+package oci8
+
+import _ "github.com/mattn/go-oci8"

main.go

@@ -576,7 +576,15 @@ func (s *DB) RemoveIndex(indexName string) *DB {
 
 // AddForeignKey Add foreign key to the given scope, e.g:
 //     db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")
-func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB {
+func (s *DB) AddForeignKey(field string, dest string, options ...string) *DB {
+	var onDelete string
+	var onUpdate string
+	if len(options) >= 1 {
+		onDelete = options[0]
+	}
+	if len(options) >= 2 {
+		onUpdate = options[1]
+	}
 	scope := s.clone().NewScope(s.Value)
 	scope.addForeignKey(field, dest, onDelete, onUpdate)
 	return scope.db

main_test.go

@@ -60,11 +60,18 @@ func OpenTestConnection() (db *gorm.DB, err error) {
 	case "mssql":
 		fmt.Println("testing mssql...")
 		db, err = gorm.Open("mssql", "server=SERVER_HERE;database=rogue;user id=USER_HERE;password=PW_HERE;port=1433")
+	case "oci8":
+		// CREATE USER gorm IDENTIFIED BY gorm;
+		// GRANT RESOURCE TO gorm;
+		// GRANT CREATE SESSION TO gorm;
+		fmt.Println("testing oci8...")
+		db, err = gorm.Open("oci8", "gorm/gorm@localhost/XE")
 	default:
 		fmt.Println("testing sqlite3...")
 		db, err = gorm.Open("sqlite3", filepath.Join(os.TempDir(), "gorm.db"))
 	}
 
+	if db != nil {
 		// db.SetLogger(Logger{log.New(os.Stdout, "\r\n", 0)})
 		// db.SetLogger(log.New(os.Stdout, "\r\n", 0))
 		if os.Getenv("DEBUG") == "true" {
@@ -72,6 +79,7 @@ func OpenTestConnection() (db *gorm.DB, err error) {
 		}
 
 		db.DB().SetMaxIdleConns(10)
+	}
 
 	return
 }

migration_test.go

@@ -252,7 +252,7 @@ func runMigration() {
 	}
 
 	for _, table := range []string{"animals", "user_languages"} {
-		DB.Exec(fmt.Sprintf("drop table %v;", table))
+		DB.DropTable(table)
 	}
 
 	values := []interface{}{&Short{}, &ReallyLongThingThatReferencesShort{}, &ReallyLongTableNameToTestMySQLNameLengthLimit{}, &NotSoLongTableName{}, &Product{}, &Email{}, &Address{}, &CreditCard{}, &Company{}, &Role{}, &Language{}, &HNPost{}, &EngadgetPost{}, &Animal{}, &User{}, &JoinTable{}, &Post{}, &Category{}, &Comment{}, &Cat{}, &Dog{}, &Hamster{}, &Toy{}, &ElementWithIgnoredField{}}

oci8_test.go

@@ -0,0 +1,5 @@
+// +build oci8
+
+package gorm
+
+import _ "github.com/jinzhu/gorm/dialects/oci8"

scope.go

@@ -329,8 +329,12 @@ func (scope *Scope) QuotedTableName() (name string) {
 
 // CombinedConditionSql return combined condition sql
 func (scope *Scope) CombinedConditionSql() string {
+	limitWhereSQL, limitSuffixSQL := scope.limitAndOffsetSQL()
+	if len(limitWhereSQL) > 0 {
+		scope.Search = scope.Search.Where(limitWhereSQL)
+	}
 	return scope.joinsSQL() + scope.whereSQL() + scope.groupSQL() +
-		scope.havingSQL() + scope.orderSQL() + scope.limitAndOffsetSQL()
+		scope.havingSQL() + scope.orderSQL() + limitSuffixSQL
 }
 
 // Raw set raw sql
@@ -469,7 +473,7 @@ func (scope *Scope) scan(rows *sql.Rows, columns []string, fields []*Field) {
 		}
 
 		for fieldIndex, field := range selectFields {
-			if field.DBName == column {
+			if strings.EqualFold(field.DBName, column) {
 				if field.Field.Kind() == reflect.Ptr {
 					values[index] = field.Field.Addr().Interface()
 				} else {
@@ -668,7 +672,7 @@ func (scope *Scope) whereSQL() (sql string) {
 	)
 
 	if !scope.Search.Unscoped && scope.HasColumn("deleted_at") {
-		sql := fmt.Sprintf("%v.deleted_at IS NULL", quotedTableName)
+		sql := fmt.Sprintf("%s.%s IS NULL", quotedTableName, scope.Dialect().Quote("deleted_at"))
 		primaryConditions = append(primaryConditions, sql)
 	}
 
@@ -748,7 +752,7 @@ func (scope *Scope) orderSQL() string {
 	return " ORDER BY " + strings.Join(orders, ",")
 }
 
-func (scope *Scope) limitAndOffsetSQL() string {
+func (scope *Scope) limitAndOffsetSQL() (whereSQL, suffixSQL string) {
 	return scope.Dialect().LimitAndOffsetSQL(scope.Search.limit, scope.Search.offset)
 }
 
@@ -947,7 +951,7 @@ func (scope *Scope) trace(t time.Time) {
 func (scope *Scope) changeableField(field *Field) bool {
 	if selectAttrs := scope.SelectAttrs(); len(selectAttrs) > 0 {
 		for _, attr := range selectAttrs {
-			if field.Name == attr || field.DBName == attr {
+			if strings.EqualFold(field.Name, attr) || strings.EqualFold(field.DBName, attr) {
 				return true
 			}
 		}
@@ -1065,7 +1069,6 @@ func (scope *Scope) createJoinTable(field *StructField) {
 
 			scope.Err(scope.NewDB().Exec(fmt.Sprintf("CREATE TABLE %v (%v, PRIMARY KEY (%v)) %s", scope.Quote(joinTable), strings.Join(sqlTypes, ","), strings.Join(primaryKeys, ","), scope.getTableOptions())).Error)
 		}
-		scope.NewDB().Table(joinTable).AutoMigrate(joinTableHandler)
 	}
 }
 
@@ -1084,6 +1087,13 @@ func (scope *Scope) createTable() *Scope {
 				primaryKeyInColumnType = true
 			}
 
+			if _, ok := field.TagSettings["SEQUENCE"]; ok {
+				sequenceName := scope.Dialect().SequenceName(scope.TableName(), field.DBName)
+				if len(sequenceName) > 0 {
+					scope.Raw(fmt.Sprintf("CREATE SEQUENCE %s", scope.Dialect().Quote(sequenceName))).Exec()
+				}
+			}
+
 			tags = append(tags, scope.Quote(field.DBName)+" "+sqlTag)
 		}
 
@@ -1105,7 +1115,20 @@ func (scope *Scope) createTable() *Scope {
 }
 
 func (scope *Scope) dropTable() *Scope {
+	for _, field := range scope.Fields() {
+		if field.IsNormal {
+			scope.Dialect().DataTypeOf(field.StructField)
+			if _, ok := field.TagSettings["SEQUENCE"]; ok {
+				sequenceName := scope.Dialect().SequenceName(scope.TableName(), field.DBName)
+				if len(sequenceName) > 0 {
+					scope.Raw(fmt.Sprintf("DROP SEQUENCE %s", scope.Dialect().Quote(sequenceName))).Exec()
+				}
+			}
+		}
+	}
+
 	scope.Raw(fmt.Sprintf("DROP TABLE %v", scope.QuotedTableName())).Exec()
+
 	return scope
 }
 
@@ -1132,6 +1155,9 @@ func (scope *Scope) addIndex(unique bool, indexName string, column ...string) {
 		sqlCreate = "CREATE UNIQUE INDEX"
 	}
 
+	if scope.Dialect().GetName() == "oci8" {
+		indexName = scope.Dialect().Quote(indexName)
+	}
 	scope.Raw(fmt.Sprintf("%s %v ON %v (%v) %v", sqlCreate, indexName, scope.QuotedTableName(), strings.Join(columns, ", "), scope.whereSQL())).Exec()
 }
 
@@ -1141,8 +1167,14 @@ func (scope *Scope) addForeignKey(field string, dest string, onDelete string, on
 	if scope.Dialect().HasForeignKey(scope.TableName(), keyName) {
 		return
 	}
-	var query = `ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s ON DELETE %s ON UPDATE %s;`
+	var query = fmt.Sprintf("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s", scope.QuotedTableName(), scope.quoteIfPossible(keyName), scope.quoteIfPossible(field), dest)
-	scope.Raw(fmt.Sprintf(query, scope.QuotedTableName(), scope.quoteIfPossible(keyName), scope.quoteIfPossible(field), dest, onDelete, onUpdate)).Exec()
+	if len(onDelete) > 0 {
+		query += fmt.Sprintf(" ON DELETE %s", onDelete)
+	}
+	if len(onUpdate) > 0 {
+		query += fmt.Sprintf(" ON UPDATE %s", onUpdate)
+	}
+	scope.Raw(query).Exec()
 }
 
 func (scope *Scope) removeIndex(indexName string) {