tablet/gorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge 50e37061f7d292a8a7d7bcba8ded29f027857ed4 into 4a540f3ac83a6765b8876be67994ecde022c6198

Browse Source
This commit is contained in:
Andrey Nering 2016-10-31 23:29:10 +00:00 committed by GitHub
commit 136180974f
11 changed files with 254 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
callback_create.go
View File

@ -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 {

11
dialect.go
View File

@ -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(limit, offset interface{}) string
// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql and oracle has special case
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{}

18
dialect_common.go
View File

@ -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 {
sql += fmt.Sprintf(" LIMIT %d", parsedLimit)
if parsedLimit, _ := strconv.ParseInt(fmt.Sprint(limit), 0, 0); parsedLimit > 0 {
suffixSQL += fmt.Sprintf(" LIMIT %d", parsedLimit)
}
}
if offset != nil {
if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset > 0 {
sql += fmt.Sprintf(" OFFSET %d", parsedOffset)
if parsedOffset, _ := strconv.ParseInt(fmt.Sprint(offset), 0, 0); parsedOffset > 0 {
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 ""
}

144
dialect_oci8.go Normal file
View File

@ -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]
}

14
dialects/mssql/mssql.go
View File

@ -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 ""
}

3
dialects/oci8/oracle.go Normal file
View File

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

10
main.go
View File

@ -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

20
main_test.go
View File

@ -60,18 +60,26 @@ 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"))
}
// db.SetLogger(Logger{log.New(os.Stdout, "\r\n", 0)})
// db.SetLogger(log.New(os.Stdout, "\r\n", 0))
if os.Getenv("DEBUG") == "true" {
db.LogMode(true)
}
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" {
db.LogMode(true)
}
db.DB().SetMaxIdleConns(10)
db.DB().SetMaxIdleConns(10)
}
return
}

2
migration_test.go
View File

@ -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{}}

5
oci8_test.go Normal file
View File

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

50
scope.go
View File

@ -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,7 +1155,10 @@ func (scope *Scope) addIndex(unique bool, indexName string, column ...string) {
sqlCreate = "CREATE UNIQUE INDEX"
}
scope.Raw(fmt.Sprintf("%s %v ON %v(%v) %v", sqlCreate, indexName, scope.QuotedTableName(), strings.Join(columns, ", "), scope.whereSQL())).Exec()
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()
}
func (scope *Scope) addForeignKey(field string, dest string, onDelete string, onUpdate string) {
@ -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;`
scope.Raw(fmt.Sprintf(query, scope.QuotedTableName(), scope.quoteIfPossible(keyName), scope.quoteIfPossible(field), dest, onDelete, onUpdate)).Exec()
var query = fmt.Sprintf("ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s", scope.QuotedTableName(), scope.quoteIfPossible(keyName), scope.quoteIfPossible(field), dest)
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) {