fix(go.sum): update ResolveSpec dependency to v1.0.87

vendor/gorm.io/driver/sqlserver/sqlserver.go

@@ -0,0 +1,245 @@
+package sqlserver
+
+import (
+	"database/sql"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	_ "github.com/microsoft/go-mssqldb"
+	"gorm.io/gorm"
+	"gorm.io/gorm/callbacks"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/migrator"
+	"gorm.io/gorm/schema"
+)
+
+type Config struct {
+	DriverName        string
+	DSN               string
+	DefaultStringSize int
+	Conn              gorm.ConnPool
+}
+
+type Dialector struct {
+	*Config
+}
+
+func (dialector Dialector) Name() string {
+	return "sqlserver"
+}
+
+func Open(dsn string) gorm.Dialector {
+	return &Dialector{Config: &Config{DSN: dsn}}
+}
+
+func New(config Config) gorm.Dialector {
+	return &Dialector{Config: &config}
+}
+
+func (dialector Dialector) Initialize(db *gorm.DB) (err error) {
+	// register callbacks
+	callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
+		CreateClauses: []string{"INSERT", "VALUES", "ON CONFLICT"},
+		QueryClauses:  []string{"SELECT", "FROM", "WHERE", "GROUP BY", "ORDER BY", "LIMIT", "FOR"},
+		UpdateClauses: []string{"UPDATE", "SET", "RETURNING", "FROM", "WHERE"},
+		DeleteClauses: []string{"DELETE", "FROM", "RETURNING", "WHERE"},
+	})
+	db.Callback().Create().Replace("gorm:create", Create)
+	db.Callback().Update().Replace("gorm:update", Update)
+
+	if dialector.DriverName == "" {
+		dialector.DriverName = "sqlserver"
+	}
+
+	if dialector.Conn != nil {
+		db.ConnPool = dialector.Conn
+	} else {
+		db.ConnPool, err = sql.Open(dialector.DriverName, dialector.DSN)
+		if err != nil {
+			return err
+		}
+	}
+
+	for k, v := range dialector.ClauseBuilders() {
+		db.ClauseBuilders[k] = v
+	}
+	return
+}
+
+func (dialector Dialector) ClauseBuilders() map[string]clause.ClauseBuilder {
+	return map[string]clause.ClauseBuilder{
+		"LIMIT": func(c clause.Clause, builder clause.Builder) {
+			if limit, ok := c.Expression.(clause.Limit); ok {
+				if stmt, ok := builder.(*gorm.Statement); ok {
+					if _, ok := stmt.Clauses["ORDER BY"]; !ok {
+						if stmt.Schema != nil && stmt.Schema.PrioritizedPrimaryField != nil {
+							builder.WriteString("ORDER BY ")
+							builder.WriteQuoted(stmt.Schema.PrioritizedPrimaryField.DBName)
+							builder.WriteByte(' ')
+						} else {
+							builder.WriteString("ORDER BY (SELECT NULL) ")
+						}
+					}
+				}
+
+				if limit.Offset > 0 {
+					builder.WriteString("OFFSET ")
+					builder.WriteString(strconv.Itoa(limit.Offset))
+					builder.WriteString(" ROWS")
+				}
+
+				if limit.Limit != nil && *limit.Limit >= 0 {
+					if limit.Offset == 0 {
+						builder.WriteString("OFFSET 0 ROW")
+					}
+					builder.WriteString(" FETCH NEXT ")
+					builder.WriteString(strconv.Itoa(*limit.Limit))
+					builder.WriteString(" ROWS ONLY")
+				}
+			}
+		},
+		"RETURNING": func(c clause.Clause, builder clause.Builder) {
+			if returning, ok := c.Expression.(clause.Returning); ok {
+				if stmt, ok := builder.(*gorm.Statement); ok {
+					var outputTable string
+					if _, ok := stmt.Clauses["UPDATE"]; ok {
+						outputTable = "INSERTED"
+					} else if _, ok := stmt.Clauses["DELETE"]; ok {
+						outputTable = "DELETED"
+					}
+
+					if outputTable != "" {
+						stmt.WriteString("OUTPUT ")
+
+						if len(returning.Columns) > 0 {
+							columns := []clause.Column{}
+							for _, column := range returning.Columns {
+								column.Table = outputTable
+								columns = append(columns, column)
+							}
+							returning.Columns = columns
+							returning.Build(stmt)
+						} else {
+							stmt.WriteString(outputTable + ".*")
+						}
+					}
+				}
+			}
+		},
+	}
+}
+
+func (dialector Dialector) DefaultValueOf(field *schema.Field) clause.Expression {
+	return clause.Expr{SQL: "NULL"}
+}
+
+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.WriteString("@p")
+	writer.WriteString(strconv.Itoa(len(stmt.Vars)))
+}
+
+func (dialector Dialector) QuoteTo(writer clause.Writer, str string) {
+	writer.WriteByte('"')
+	if strings.Contains(str, ".") {
+		for idx, str := range strings.Split(str, ".") {
+			if idx > 0 {
+				writer.WriteString(`."`)
+			}
+			writer.WriteString(str)
+			writer.WriteByte('"')
+		}
+	} else {
+		writer.WriteString(str)
+		writer.WriteByte('"')
+	}
+}
+
+var numericPlaceholder = regexp.MustCompile("@p(\\d+)")
+
+func (dialector Dialector) Explain(sql string, vars ...interface{}) string {
+	for idx, v := range vars {
+		if b, ok := v.(bool); ok {
+			if b {
+				vars[idx] = 1
+			} else {
+				vars[idx] = 0
+			}
+		}
+	}
+
+	return logger.ExplainSQL(sql, numericPlaceholder, `'`, vars...)
+}
+
+func (dialector Dialector) DataTypeOf(field *schema.Field) string {
+	switch field.DataType {
+	case schema.Bool:
+		return "bit"
+	case schema.Int, schema.Uint:
+		var sqlType string
+		switch {
+		case field.Size < 16:
+			sqlType = "smallint"
+		case field.Size < 31:
+			sqlType = "int"
+		default:
+			sqlType = "bigint"
+		}
+
+		if field.AutoIncrement {
+			return sqlType + " IDENTITY(1,1)"
+		}
+		return sqlType
+	case schema.Float:
+		if field.Precision > 0 {
+			if field.Scale > 0 {
+				return fmt.Sprintf("decimal(%d, %d)", field.Precision, field.Scale)
+			}
+			return fmt.Sprintf("decimal(%d)", field.Precision)
+		}
+		return "float"
+	case schema.String:
+		size := field.Size
+		hasIndex := field.TagSettings["INDEX"] != "" || field.TagSettings["UNIQUE"] != ""
+		if (field.PrimaryKey || hasIndex) && size == 0 {
+			if dialector.DefaultStringSize > 0 {
+				size = dialector.DefaultStringSize
+			} else {
+				size = 256
+			}
+		}
+		if size > 0 && size <= 4000 {
+			return fmt.Sprintf("nvarchar(%d)", size)
+		}
+		return "nvarchar(MAX)"
+	case schema.Time:
+		if field.Precision > 0 {
+			return fmt.Sprintf("datetimeoffset(%d)", field.Precision)
+		}
+		return "datetimeoffset"
+	case schema.Bytes:
+		return "varbinary(MAX)"
+	}
+
+	return string(field.DataType)
+}
+
+func (dialectopr Dialector) SavePoint(tx *gorm.DB, name string) error {
+	tx.Exec("SAVE TRANSACTION " + name)
+	return nil
+}
+
+func (dialectopr Dialector) RollbackTo(tx *gorm.DB, name string) error {
+	tx.Exec("ROLLBACK TRANSACTION " + name)
+	return nil
+}