import "time"

// Model a basic GoLang struct which includes the following fields: ID, CreatedAt, UpdatedAt, DeletedAt
// It may be embedded into your model or you may build your own model without it
//
//	type User struct {
//	  gorm.Model
//	}
type Model struct {
	ID        uint `gorm:"primarykey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt DeletedAt `gorm:"index"`

}

func format(v []byte, escaper string) string {
	return escaper + strings.ReplaceAll(string(v), escaper, escaper+escaper) + escaper
}

func TestExplainSQL(t *testing.T) {
	type role string
	type password []byte
	type intType int
	type floatType float64
	var (
		tt                 = now.MustParse("2020-02-23 11:10:10")
		myrole             = role("admin")
		pwd                = password("pass")

package tests_test

import (
	"testing"
	"time"

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func TestCustomizeColumn(t *testing.T) {
	type CustomizeColumn struct {
		ID   int64      `gorm:"column:mapped_id; primary_key:yes"`
		Name string     `gorm:"column:mapped_name"`
		Date *time.Time `gorm:"column:mapped_time"`
	}

	DB.Migrator().DropTable(&CustomizeColumn{})
	DB.AutoMigrate(&CustomizeColumn{})

	return fnames[len(fnames)-1]
}

func c1(*gorm.DB) {}
func c2(*gorm.DB) {}
func c3(*gorm.DB) {}
func c4(*gorm.DB) {}
func c5(*gorm.DB) {}
func c6(*gorm.DB) {}

func TestCallbacks(t *testing.T) {
	type callback struct {
		name    string
		before  string
		after   string
		remove  bool
		replace bool
		err     string
		match   func(*gorm.DB) bool
		h       func(*gorm.DB)
	}

	datas := []struct {

	case "mysql", "sqlserver":
		// these dialects do not support the "returning" clause
		return
	default:
		// This user struct will leverage the existing users table, but override
		// the Name field to default to null.
		type user struct {
			gorm.Model
			Name string `gorm:"default:null"`
		}
		u1 := user{}

		if results := DB.Create(&u1); results.Error != nil {
			t.Fatalf("errors happened on create: %v", results.Error)

		}

		for column, v := range selectColumns {
			if !v {
				continue
			}

			rel, ok := db.Statement.Schema.Relationships.Relations[column]
			if !ok {
				continue
			}

			switch rel.Type {
			case schema.HasOne, schema.HasMany:
				queryConds := rel.ToQueryConditions(db.Statement.Context, db.Statement.ReflectValue)
				modelValue := reflect.New(rel.FieldSchema.ModelType).Interface()

		t.Errorf("invalid table name generated, got %v", tableName)
	}

	columdName := ns.ColumnName("", "NameCID")
	if columdName != "name_cid" {
		t.Errorf("invalid column name generated, got %v", columdName)
	}
}

type CustomReplacer struct {
	f func(string) string
}

func (r CustomReplacer) Replace(name string) string {
	return r.f(name)
}

func TestCustomReplacer(t *testing.T) {
	ns := NamingStrategy{

          "pattern": "/(critical|urgent)/i"
        },
        {
          "type": "titleMatches",
          "pattern": "/(critical|urgent)/i"
        }
      ]
    },
    "question": {
      "requires": 1,
      "conditions": [
        {
          "type": "titleMatches",
          "pattern": "/question/i"
        },
        {
          "type": "descriptionMatches",

	CompIdxLevel2C
}

type CompIdxLevel1C struct {
	CompIdxLevel1B
	Data1C string `gorm:"index:,composite:comp_id1"`
}

type CompIdxLevel1B struct {
	Data1B string `gorm:"index:,composite:comp_id1"`
}

type CompIdxLevel2C struct {
	CompIdxLevel2B
	Data2C string `gorm:"index:,unique,composite:comp_id2,priority:1"`
}

type CompIdxLevel2B struct {

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type Index struct {
	Name    string
	Class   string // UNIQUE | FULLTEXT | SPATIAL
	Type    string // btree, hash, gist, spgist, gin, and brin
	Where   string
	Comment string
	Option  string        // WITH PARSER parser_name
	Fields  []IndexOption // Note: IndexOption's Field maybe the same
}

type IndexOption struct {
	*Field
	Expression string