Initalize

Author: jinzhu

License

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-NOW  Jinzhu <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,16 @@
+# GORM PostgreSQL Driver
+
+## USAGE
+
+```go
+import (
+  "gorm.io/driver/postgres"
+  "gorm.io/gorm"
+)
+
+// https://github.com/lib/pq
+dsn := "user=gorm password=gorm DB.name=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"
+db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
+```
+
+Checkout [https://gorm.io](https://gorm.io) for details.

go.mod

@@ -0,0 +1,5 @@
+module gorm.io/driver/postgres
+
+go 1.14
+
+require github.com/lib/pq v1.6.0

migrator.go

@@ -0,0 +1,139 @@
+package postgres
+
+import (
+	"fmt"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/migrator"
+	"gorm.io/gorm/schema"
+)
+
+type Migrator struct {
+	migrator.Migrator
+}
+
+func (m Migrator) CurrentDatabase() (name string) {
+	m.DB.Raw("SELECT CURRENT_DATABASE()").Row().Scan(&name)
+	return
+}
+
+func (m Migrator) BuildIndexOptions(opts []schema.IndexOption, stmt *gorm.Statement) (results []interface{}) {
+	for _, opt := range opts {
+		str := stmt.Quote(opt.DBName)
+		if opt.Expression != "" {
+			str = opt.Expression
+		}
+
+		if opt.Collate != "" {
+			str += " COLLATE " + opt.Collate
+		}
+
+		if opt.Sort != "" {
+			str += " " + opt.Sort
+		}
+		results = append(results, clause.Expr{SQL: str})
+	}
+	return
+}
+
+func (m Migrator) HasIndex(value interface{}, name string) bool {
+	var count int64
+	m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		if idx := stmt.Schema.LookIndex(name); idx != nil {
+			name = idx.Name
+		}
+
+		return m.DB.Raw(
+			"SELECT count(*) FROM pg_indexes WHERE tablename = ? AND indexname = ? AND schemaname = CURRENT_SCHEMA()", stmt.Table, name,
+		).Row().Scan(&count)
+	})
+
+	return count > 0
+}
+
+func (m Migrator) CreateIndex(value interface{}, name string) error {
+	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		if idx := stmt.Schema.LookIndex(name); idx != nil {
+			opts := m.BuildIndexOptions(idx.Fields, stmt)
+			values := []interface{}{clause.Column{Name: idx.Name}, clause.Table{Name: stmt.Table}, opts}
+
+			createIndexSQL := "CREATE "
+			if idx.Class != "" {
+				createIndexSQL += idx.Class + " "
+			}
+			createIndexSQL += "INDEX ?"
+
+			if idx.Type != "" {
+				createIndexSQL += " USING " + idx.Type
+			}
+			createIndexSQL += " ON ??"
+
+			if idx.Where != "" {
+				createIndexSQL += " WHERE " + idx.Where
+			}
+
+			return m.DB.Exec(createIndexSQL, values...).Error
+		}
+
+		return fmt.Errorf("failed to create index with name %v", name)
+	})
+}
+
+func (m Migrator) RenameIndex(value interface{}, oldName, newName string) error {
+	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		return m.DB.Exec(
+			"ALTER INDEX ? RENAME TO ?",
+			clause.Column{Name: oldName}, clause.Column{Name: newName},
+		).Error
+	})
+}
+
+func (m Migrator) DropIndex(value interface{}, name string) error {
+	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		if idx := stmt.Schema.LookIndex(name); idx != nil {
+			name = idx.Name
+		}
+
+		return m.DB.Exec("DROP INDEX ?", clause.Column{Name: name}).Error
+	})
+}
+
+func (m Migrator) HasTable(value interface{}) bool {
+	var count int64
+	m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		return m.DB.Raw("SELECT count(*) FROM information_schema.tables WHERE table_schema =  CURRENT_SCHEMA() AND table_name = ? AND table_type = ?", stmt.Table, "BASE TABLE").Row().Scan(&count)
+	})
+
+	return count > 0
+}
+
+func (m Migrator) DropTable(values ...interface{}) error {
+	values = m.ReorderModels(values, false)
+	tx := m.DB.Session(&gorm.Session{})
+	for i := len(values) - 1; i >= 0; i-- {
+		if err := m.RunWithValue(values[i], func(stmt *gorm.Statement) error {
+			return tx.Exec("DROP TABLE IF EXISTS ? CASCADE", clause.Table{Name: stmt.Table}).Error
+		}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (m Migrator) HasColumn(value interface{}, field string) bool {
+	var count int64
+	m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		name := field
+		if field := stmt.Schema.LookUpField(field); field != nil {
+			name = field.DBName
+		}
+
+		return m.DB.Raw(
+			"SELECT count(*) FROM INFORMATION_SCHEMA.columns WHERE table_schema = CURRENT_SCHEMA() AND table_name = ? AND column_name = ?",
+			stmt.Table, name,
+		).Row().Scan(&count)
+	})
+
+	return count > 0
+}

postgres.go

@@ -0,0 +1,102 @@
+package postgres
+
+import (
+	"database/sql"
+	"fmt"
+	"regexp"
+	"strconv"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/callbacks"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/migrator"
+	"gorm.io/gorm/schema"
+	_ "github.com/lib/pq"
+)
+
+type Dialector struct {
+	DSN string
+}
+
+func Open(dsn string) gorm.Dialector {
+	return &Dialector{DSN: dsn}
+}
+
+func (dialector Dialector) Name() string {
+	return "postgres"
+}
+
+func (dialector Dialector) Initialize(db *gorm.DB) (err error) {
+	// register callbacks
+	callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
+		WithReturning: true,
+	})
+	db.ConnPool, err = sql.Open("postgres", dialector.DSN)
+	return
+}
+
+func (dialector Dialector) Migrator(db *gorm.DB) gorm.Migrator {
+	return Migrator{migrator.Migrator{Config: migrator.Config{
+		DB:                          db,
+		Dialector:                   dialector,
+		CreateIndexAfterCreateTable: true,
+	}}}
+}
+
+func (dialector Dialector) BindVarTo(writer clause.Writer, stmt *gorm.Statement, v interface{}) {
+	writer.WriteByte('$')
+	writer.WriteString(strconv.Itoa(len(stmt.Vars)))
+}
+
+func (dialector Dialector) QuoteTo(writer clause.Writer, str string) {
+	writer.WriteByte('"')
+	writer.WriteString(str)
+	writer.WriteByte('"')
+}
+
+var numericPlaceholder = regexp.MustCompile("\\$(\\d+)")
+
+func (dialector Dialector) Explain(sql string, vars ...interface{}) string {
+	return logger.ExplainSQL(sql, numericPlaceholder, `'`, vars...)
+}
+
+func (dialector Dialector) DataTypeOf(field *schema.Field) string {
+	switch field.DataType {
+	case schema.Bool:
+		return "boolean"
+	case schema.Int, schema.Uint:
+		if field.AutoIncrement || field == field.Schema.PrioritizedPrimaryField {
+			switch {
+			case field.Size < 16:
+				return "smallserial"
+			case field.Size < 31:
+				return "serial"
+			default:
+				return "bigserial"
+			}
+		} else {
+			switch {
+			case field.Size < 16:
+				return "smallint"
+			case field.Size < 31:
+				return "integer"
+			default:
+				return "bigint"
+			}
+		}
+	case schema.Float:
+		return "decimal"
+	case schema.String:
+		if field.Size > 0 {
+			return fmt.Sprintf("varchar(%d)", field.Size)
+		}
+		return "text"
+	case schema.Time:
+		return "timestamptz"
+	case schema.Bytes:
+		return "bytea"
+	}
+
+	return ""
+}