package gen_mysql

import (
	"bufio"
	"fmt"
	"gitee.com/ha666/gen_sqlx_code/app"
	"gitee.com/ha666/gen_sqlx_code/gen_mysql/models"
	"gitee.com/ha666/gen_sqlx_code/utils"
	"log"
	"os"
	"os/exec"
	"runtime"
	"strings"
)

var (
	p            = ""
	name         = ""
	conn_name    = ""
	conn_string  = ""
	table_infos  []models.TableInfo
	column_infos map[string][]models.ColumnInfo
	index_infos  map[string][]models.IndexInfo
	err          error
)

func Gen(_p string) {
	defer func() {
		if err := recover(); err != nil {
			log.Fatalf("【Gen】ex:%v\n", err)
			return
		}
	}()
	p = _p
	load_param()
}

func load_param() {
	defer func() {
		if err := recover(); err != nil {
			log.Fatalf("【load_param】ex:%v\n", err)
			return
		}
	}()

	var (
		address  = ""
		port     = -1
		account  = ""
		password = ""
		err      error
	)

	// 验证address参数
	{
		address, err = app.Cfg.GetValue(p, "address")
		if err != nil {
			log.Fatalf("【load_param】address解析出错:%s\n", err.Error())
		}
		if len(address) <= 0 {
			log.Fatal("【load_param】address不能为空\n")
		}
	}

	// 验证port参数
	{
		port, err = app.Cfg.Int(p, "port")
		if err != nil {
			log.Fatalf("【load_param】port解析出错:%s\n", err.Error())
		}
		if port <= 1024 {
			log.Fatal("【load_param】port不能小于1024\n")
		}
	}

	// 验证name参数
	{
		name, err = app.Cfg.GetValue(p, "name")
		if err != nil {
			log.Fatalf("【load_param】name解析出错:%s\n", err.Error())
		}
		if len(name) <= 0 {
			log.Fatal("【load_param】name不能为空\n")
		}
	}

	// 验证account参数
	{
		account, err = app.Cfg.GetValue(p, "account")
		if err != nil {
			log.Fatalf("【load_param】account解析出错:%s\n", err.Error())
		}
		if len(account) <= 0 {
			log.Fatal("【load_param】account不能为空\n")
		}
	}

	// 验证password参数
	{
		password, err = app.Cfg.GetValue(p, "password")
		if err != nil {
			log.Fatalf("【load_param】password解析出错:%s\n", err.Error())
		}
		if len(password) <= 0 {
			log.Fatal("【load_param】password不能为空\n")
		}
	}

	// 验证conn_name参数
	{
		conn_name, err = app.Cfg.GetValue(p, "conn_name")
		if err != nil {
			log.Fatalf("【load_param】conn_name解析出错:%s\n", err.Error())
		}
		if len(conn_name) <= 0 {
			log.Fatal("【load_param】conn_name不能为空\n")
		}
	}

	conn_string = fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=true&loc=Asia%%2fShanghai", account, password, address, port, name)

	log.Println(conn_string)
	get_database_info()
}

func get_database_info() {
	defer func() {
		if err := recover(); err != nil {
			log.Fatalf("【get_database_info】ex:%v\n", err)
			return
		}
	}()

	// 连接数据库
	{
		models.InitMainDB(conn_string)
	}

	// 查询所有的表
	{
		table_infos, err = models.GetTableInfos(name)
		if err != nil {
			log.Fatalf("【get_database_info】查询表出错:%s\n", err.Error())
		}
		if len(table_infos) <= 0 || len(table_infos[0].TableName) <= 0 {
			log.Fatal("【get_database_info】查询表出错:没有找到表\n")
		}
	}

	// 加载所有的列
	{
		var column_info []models.ColumnInfo
		column_infos = make(map[string][]models.ColumnInfo, len(table_infos))
		for _, table := range table_infos {
			column_info, err = models.GetColumnInfos(name, table.TableName)
			if err != nil {
				log.Fatalf("【get_database_info】查询表%s出错:%s\n", table.TableName, err.Error())
			}
			if len(column_info) <= 0 {
				log.Fatalf("【get_database_info】查询表%s出错:没有找到列\n", table.TableName)
			}
			column_infos[table.TableName] = column_info
		}
	}

	// 加载所有的索引
	{
		var index_info []models.IndexInfo
		index_infos = make(map[string][]models.IndexInfo, len(table_infos))
		for _, table := range table_infos {
			index_info, err = models.GetIndexInfos(name, table.TableName)
			if err != nil {
				log.Fatalf("【get_database_info】查询索引%s出错:%s\n", table.TableName, err.Error())
			}
			if len(index_info) <= 0 {
				//log.Fatalf("【get_database_info】查询索引%s出错:没有找到\n", table.TableName)
				continue
			}
			index_infos[table.TableName] = index_info
		}
	}

	// 处理所有的表
	{
		count := len(table_infos)
		for index, table := range table_infos {
			log.Printf("【get_database_info】%d/%d，%s", index+1, count, table.TableName)
			generator_model(&table)
			generator_dao(&table)
		}
	}

	// 执行gofmt
	{
		os_name := runtime.GOOS
		switch os_name {
		case "darwin", "linux":
			{
				cmd := exec.Command("sh", "-c", "gofmt -w model")
				_, err := cmd.Output()
				if err != nil {
					log.Fatalf("【get_database_info】执行gofmt结果出错:%s\n", err.Error())
				}
				cmd = exec.Command("sh", "-c", "gofmt -w dao")
				_, err = cmd.Output()
				if err != nil {
					log.Fatalf("【get_database_info】执行gofmt结果出错:%s\n", err.Error())
				}
			}
		case "windows":
			{
				_, err := exec.Command("cmd", "/c", `gofmt -w model`).Output()
				if err != nil {
					log.Fatalf("【get_database_info】执行gofmt结果出错:%s\n", err.Error())
				}
				_, err = exec.Command("cmd", "/c", `gofmt -w dao`).Output()
				if err != nil {
					log.Fatalf("【get_database_info】执行gofmt结果出错:%s\n", err.Error())
				}
			}
		default:
			{
				log.Println("【get_database_info】未知系统")
			}
		}
	}

}

func generator_model(table *models.TableInfo) {
	defer func() {
		if err := recover(); err != nil {
			log.Fatalf("【generator_model】表:%s,ex:%v\n", table.TableName, err)
			return
		}
	}()

	var (
		folder             = "model"
		fd                 *os.File
		w                  *bufio.Writer
		column_info        []models.ColumnInfo
		index_info         map[string][]models.IndexInfo
		ok                 bool
		is_exist_time_type = false
		struct_name        = table.TableName
	)

	// 获取列
	{
		column_info, ok = column_infos[table.TableName]
		if !ok {
			log.Fatalf("【generator_model】表:%s,没有找到列信息1", table.TableName)
		}
		if len(column_info) <= 0 {
			log.Fatalf("【generator_model】表:%s,没有找到列信息2", table.TableName)
		}
	}

	// 获取索引
	{
		if len(index_infos) > 0 {
			index_info_s, ok := index_infos[table.TableName]
			if ok && len(index_info_s) > 0 {
				index_info = make(map[string][]models.IndexInfo)
				for _, index := range index_info_s {
					if tmp_index, ok := index_info[index.IndexName]; ok {
						tmp_index = append(tmp_index, index)
						index_info[index.IndexName] = tmp_index
					} else {
						index_info[index.IndexName] = []models.IndexInfo{index}
					}
				}
			}
		}
	}

	// 判断是否有主键
	{
		is_pk := false
		for _, column := range column_info {
			if strings.EqualFold(column.ColumnKey, "PRI") {
				is_pk = true
				break
			}
		}
		if !is_pk && name != "mysql" {
			log.Fatalf("【generator_model】表:%s,没有主键", table.TableName)
		}
	}

	// 初始化操作
	{
		utils.ToBigHump(&struct_name)
		for _, column := range column_info {
			tmp_type := get_field_type(column.DataType)
			if tmp_type == "time.Time" {
				is_exist_time_type = true
			}
		}
		err = utils.PathCreate("./" + folder)
		if err != nil {
			log.Fatalf("【generator_model】生成表:%s,创建目录出错:%s\n", table.TableName, err.Error())
		}
		fd, err = os.OpenFile("./"+folder+"/"+table.TableName+".go", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
		if err != nil {
			log.Fatalf("【generator_model】生成表:%s,打开文件出错:%s\n", table.TableName, err.Error())
		}
		defer fd.Close()
		fd, err = os.Create("./" + folder + "/" + table.TableName + ".go")
		if err != nil {
			log.Fatalf("【generator_model】生成表:%s,打开文件出错:%s\n", table.TableName, err.Error())
		}
		defer fd.Close()
		w = bufio.NewWriter(fd)
	}

	// Package
	{
		fmt.Fprintln(w, fmt.Sprintf("package %s\n", folder))
		if is_exist_time_type {
			fmt.Fprintln(w, "import (")
			fmt.Fprintln(w, "\t\"time\"")
			fmt.Fprintln(w, ")")
		}
	}

	// Struct
	{
		fmt.Fprintln(w, "")
		if len(table.TableComment) > 0 {
			fmt.Fprintln(w, fmt.Sprintf("// %s", table.TableComment))
		}
		fmt.Fprintln(w, fmt.Sprintf("type %s struct {", struct_name))
		for _, column := range column_info {
			fmt.Fprint(w, fmt.Sprintf("\t%s\t%s\t`db:\"%s\"`", column.ColumnNameCase, get_field_type(column.DataType), column.ColumnName))
			if len(column.ColumnComment) > 0 {
				fmt.Fprint(w, fmt.Sprintf("\t//%s", column.ColumnComment))
			}
			fmt.Fprintln(w, "")
		}
		fmt.Fprintln(w, "}")
	}

	// 写入文件
	{
		err = w.Flush()
		if err != nil {
			log.Fatalf("【generator_model】生成表:%s,刷新文件出错:%s\n", table.TableName, err.Error())
		}
	}

	log.Printf("【generator_model】表:%s,成功!", table.TableName)
}

func generator_dao(table *models.TableInfo) {
	defer func() {
		if err := recover(); err != nil {
			log.Fatalf("【generator_dao】表:%s,ex:%v\n", table.TableName, err)
			return
		}
	}()

	var (
		folder                = "dao"
		fd                    *os.File
		w                     *bufio.Writer
		column_info           []models.ColumnInfo
		index_info            map[string][]models.IndexInfo
		ok                    bool
		is_auto_increment     = false
		is_exist_deleteStatus = false
		struct_name           = table.TableName
		init_index            = 0
		pk_count              = 0
		pk_column             models.ColumnInfo
	)

	// 获取列
	{
		column_info, ok = column_infos[table.TableName]
		if !ok {
			log.Fatalf("【generator_dao】表:%s,没有找到列信息1", table.TableName)
		}
		if len(column_info) <= 0 {
			log.Fatalf("【generator_dao】表:%s,没有找到列信息2", table.TableName)
		}
	}

	// 获取索引
	{
		if len(index_infos) > 0 {
			index_info_s, ok := index_infos[table.TableName]
			if ok && len(index_info_s) > 0 {
				index_info = make(map[string][]models.IndexInfo)
				for _, index := range index_info_s {
					if tmp_index, ok := index_info[index.IndexName]; ok {
						tmp_index = append(tmp_index, index)
						index_info[index.IndexName] = tmp_index
					} else {
						index_info[index.IndexName] = []models.IndexInfo{index}
					}
				}
			}
		}
	}

	// 判断是否有主键
	{
		is_pk := false
		for _, column := range column_info {
			if strings.EqualFold(column.ColumnKey, "PRI") {
				is_pk = true
				break
			}
		}
		if !is_pk && name != "mysql" {
			log.Fatalf("【generator_dao】表:%s,没有主键", table.TableName)
		}
	}

	// 判断是否有deleteStatus字段
	{
		is_exist_deleteStatus = false
		for _, column := range column_info {
			if strings.EqualFold(column.ColumnName, "deleteStatus") {
				is_exist_deleteStatus = true
				break
			}
		}
	}

	// 初始化操作
	{
		utils.ToBigHump(&struct_name)
		for _, column := range column_info {
			if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
				is_auto_increment = true
			}
		}
		pk_count = 0
		err = utils.PathCreate("./" + folder)
		if err != nil {
			log.Fatalf("【generator_dao】生成表:%s,创建目录出错:%s\n", table.TableName, err.Error())
		}
		fd, err = os.OpenFile("./"+folder+"/"+table.TableName+".go", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
		if err != nil {
			log.Fatalf("【generator_dao】生成表:%s,打开文件出错:%s\n", table.TableName, err.Error())
		}
		defer fd.Close()
		fd, err = os.Create("./" + folder + "/" + table.TableName + ".go")
		if err != nil {
			log.Fatalf("【generator_dao】生成表:%s,打开文件出错:%s\n", table.TableName, err.Error())
		}
		defer fd.Close()
		w = bufio.NewWriter(fd)
	}

	// Package
	{
		fmt.Fprintln(w, fmt.Sprintf("package %s\n", folder))
		fmt.Fprintln(w, "import (")
		fmt.Fprintln(w, "\t\"bytes\"")
		fmt.Fprintln(w, "\t\"database/sql\"")
		fmt.Fprintln(w, "\t\"errors\"")
		fmt.Fprintln(w, "\t\"github.com/jmoiron/sqlx\"")
		fmt.Fprintln(w, "\t\"strings\"")
		fmt.Fprintln(w, ")")
	}

	// DB
	{
		fmt.Fprintln(w, "")
		fmt.Fprintln(w, fmt.Sprintf("var %sDao = %s{}", struct_name, table.TableName))
		fmt.Fprintln(w, "")
		fmt.Fprintln(w, fmt.Sprintf("type %s struct{}", table.TableName))
	}

	// IndexList
	{
		pk_count = 0
		for key, index := range index_info {
			if strings.EqualFold(key, "PRIMARY") {
				for _, index_a := range index {
					col, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,IndexList查询出错:%s\n", table.TableName, err.Error())
					}
					if len(col.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,IndexList没有找到列:%s\n", table.TableName, index_a.ColumnName)
					}
					pk_count += 1
					pk_column = col
				}
			}
		}
	}

	// Exist
	{
		fmt.Fprintln(w, "")
		fmt.Fprint(w, "// 根据【")
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, ",")
			}
			if len(column.ColumnComment) > 0 {
				fmt.Fprint(w, column.ColumnComment)
			} else {
				fmt.Fprint(w, column.ColumnName)
			}
		}
		fmt.Fprint(w, "】查询【")
		if len(table.TableComment) > 0 {
			fmt.Fprint(w, table.TableComment)
		} else {
			fmt.Fprint(w, table.TableName)
		}
		fmt.Fprintln(w, "】表中是否存在相关记录")
		fmt.Fprint(w, fmt.Sprintf("func (d *%s) Exist(", table.TableName))
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, ",")
			}
			fmt.Fprint(w, fmt.Sprintf("%s %s", column.ColumnName, get_field_type(column.DataType)))
		}
		fmt.Fprintln(w, ") (bool, error) {")
		fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select count(0) Count from %s where ", conn_name, table.TableName))
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, " and ")
			}
			fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
		}
		fmt.Fprint(w, "\",")
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, column.ColumnName)
		}
		fmt.Fprintln(w, ")")
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprintln(w, "\t\treturn false, err")
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\tdefer rows.Close()")
		fmt.Fprintln(w, "\tcount := 0")
		fmt.Fprintln(w, "\tif rows.Next() {")
		fmt.Fprintln(w, "\t\terr = rows.Scan(&count)")
		fmt.Fprintln(w, "\t\tif err != nil {")
		fmt.Fprintln(w, "\t\t\treturn false, err")
		fmt.Fprintln(w, "\t\t}")
		fmt.Fprintln(w, "\t\treturn count > 0, nil")
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\treturn false, nil")
		fmt.Fprintln(w, "}")
	}

	// Insert
	{
		fmt.Fprintln(w, "")
		fmt.Fprint(w, "// 插入单条记录到【")
		if len(table.TableComment) > 0 {
			fmt.Fprint(w, table.TableComment)
		} else {
			fmt.Fprint(w, table.TableName)
		}
		fmt.Fprintln(w, "】表中")
		fmt.Fprint(w, fmt.Sprintf("func (d *%s) Insert(m *model.%s) (", table.TableName, struct_name))
		if is_auto_increment {
			fmt.Fprint(w, "int64")
		} else {
			fmt.Fprint(w, "bool")
		}
		fmt.Fprintln(w, ", error) {")
		fmt.Fprint(w, fmt.Sprintf("\tresult, err := %s.Exec(\"insert into %s(", conn_name, table.TableName))
		init_index = 0
		for _, column := range column_info {
			if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ",")
			}
			fmt.Fprint(w, column.ColumnName)
			init_index++
		}
		fmt.Fprint(w, ") values(")
		init_index = 0
		for _, column := range column_info {
			if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ",")
			}
			fmt.Fprint(w, "?")
			init_index++
		}
		fmt.Fprint(w, ")\",")
		init_index = 0
		for _, column := range column_info {
			if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ",")
			}
			fmt.Fprint(w, fmt.Sprintf("m.%s", column.ColumnNameCase))
			init_index++
		}
		fmt.Fprintln(w, ")")
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprint(w, "\t\treturn ")
		if is_auto_increment {
			fmt.Fprint(w, "-1")
		} else {
			fmt.Fprint(w, "false")
		}
		fmt.Fprintln(w, ", err")
		fmt.Fprintln(w, "\t}")
		if is_auto_increment {
			fmt.Fprintln(w, "\treturn result.LastInsertId()")
		} else {
			fmt.Fprintln(w, "\taffected, err := result.RowsAffected()")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn false, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\treturn affected > 0, nil")
		}
		fmt.Fprintln(w, "}")
	}

	// Update
	{
		fmt.Fprintln(w, "")
		fmt.Fprint(w, "// 根据【")
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, ",")
			}
			if len(column.ColumnComment) > 0 {
				fmt.Fprint(w, column.ColumnComment)
			} else {
				fmt.Fprint(w, column.ColumnName)
			}
		}
		fmt.Fprint(w, "】修改【")
		if len(table.TableComment) > 0 {
			fmt.Fprint(w, table.TableComment)
		} else {
			fmt.Fprint(w, table.TableName)
		}
		fmt.Fprintln(w, "】表的单条记录")
		fmt.Fprintln(w, fmt.Sprintf("func (d *%s) Update(m *model.%s) (bool, error) {", table.TableName, struct_name))
		fmt.Fprint(w, fmt.Sprintf("\tresult, err := %s.Exec(\"update %s set ", conn_name, table.TableName))
		init_index = 0
		for _, column := range column_info {
			if strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
			init_index++
		}
		fmt.Fprint(w, " where ")
		init_index = 0
		for _, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, " and ")
			}
			fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
			init_index++
		}
		fmt.Fprint(w, "\", ")
		init_index = 0
		for _, column := range column_info {
			if strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, fmt.Sprintf("m.%s", column.ColumnNameCase))
			init_index++
		}
		for _, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
				continue
			}
			fmt.Fprint(w, ", ")
			fmt.Fprint(w, fmt.Sprintf("m.%s", column.ColumnNameCase))
		}
		fmt.Fprintln(w, ")")
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprintln(w, "\t\treturn false, err")
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\taffected, err := result.RowsAffected()")
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprintln(w, "\t\treturn false, err")
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\treturn affected > 0, nil")
		fmt.Fprintln(w, "}")
	}

	// InsertUpdate
	{
		if !is_auto_increment {
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 插入或修改【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表的单条记录")
			fmt.Fprintln(w, fmt.Sprintf("func (d *%s) InsertUpdate(m *model.%s) (bool, error) {", table.TableName, struct_name))
			fmt.Fprint(w, fmt.Sprintf("\tresult, err := %s.Exec(\"insert into %s(", conn_name, table.TableName))
			init_index = 0
			for _, column := range column_info {
				if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
					continue
				}
				if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, ",")
				}
				fmt.Fprint(w, column.ColumnName)
				init_index++
			}
			fmt.Fprint(w, ") values(")
			init_index = 0
			for _, column := range column_info {
				if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
					continue
				}
				if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, ",")
				}
				fmt.Fprint(w, "?")
				init_index++
			}
			fmt.Fprint(w, ") ON DUPLICATE KEY UPDATE ")
			init_index = 0
			for _, column := range column_info {
				if strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, ",")
				}
				fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
				init_index++
			}
			fmt.Fprint(w, "\",")
			init_index = 0
			for i := 0; i < 2; i++ {
				for _, column := range column_info {
					if i > 0 && strings.EqualFold(column.ColumnKey, "PRI") {
						continue
					}
					if len(column.Extra) > 0 && strings.Contains(column.Extra, "auto_increment") {
						continue
					}
					if strings.EqualFold(column.ColumnName, "createTime") || strings.EqualFold(column.ColumnName, "updateTime") {
						continue
					}
					if init_index > 0 {
						fmt.Fprint(w, ",")
					}
					fmt.Fprint(w, fmt.Sprintf("m.%s", column.ColumnNameCase))
					init_index++
				}
			}
			fmt.Fprintln(w, ")")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn false, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\taffected, err := result.RowsAffected()")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn false, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\treturn affected > 0, nil")
			fmt.Fprintln(w, "}")
		}
	}

	// Delete
	{
		if is_exist_deleteStatus {
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 根据【")
			for index, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if index > 0 {
					fmt.Fprint(w, ",")
				}
				if len(column.ColumnComment) > 0 {
					fmt.Fprint(w, column.ColumnComment)
				} else {
					fmt.Fprint(w, column.ColumnName)
				}
			}
			fmt.Fprint(w, "】软删除【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表中的单条记录")
			fmt.Fprint(w, fmt.Sprintf("func (d *%s) Delete(", table.TableName))
			init_index = 0
			for _, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, fmt.Sprintf("%s %s", column.ColumnName, get_field_type(column.DataType)))
				init_index++
			}
			fmt.Fprintln(w, ") (bool, error) {")
			fmt.Fprint(w, fmt.Sprintf("\tresult, err := %s.Exec(\"update %s set deleteStatus=2 where ", conn_name, table.TableName))
			init_index = 0
			for _, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, " and ")
				}
				fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
				init_index++
			}
			fmt.Fprint(w, "\", ")
			init_index = 0
			for _, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, column.ColumnName)
				init_index++
			}
			fmt.Fprintln(w, ")")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn false, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\taffected, err := result.RowsAffected()")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn false, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\treturn affected > 0, nil")
			fmt.Fprintln(w, "}")
		}
	}

	// DeleteIn
	{
		if is_exist_deleteStatus && pk_count == 1 {
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 根据【")
			for index, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if index > 0 {
					fmt.Fprint(w, ",")
				}
				if len(column.ColumnComment) > 0 {
					fmt.Fprint(w, column.ColumnComment)
				} else {
					fmt.Fprint(w, column.ColumnName)
				}
			}
			fmt.Fprint(w, "】数组软删除【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表中的多条记录")
			fmt.Fprintln(w, fmt.Sprintf("func (d *%s) DeleteIn(%ss []%s) (count int64, err error) {", table.TableName, pk_column.ColumnName, get_field_type(pk_column.DataType)))
			fmt.Fprintln(w, fmt.Sprintf("\tif len(%ss) <= 0 {", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\t\treturn count, errors.New(\"%ss is empty\")", pk_column.ColumnName))
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tsql_str := bytes.Buffer{}")
			fmt.Fprintln(w, fmt.Sprintf("\tsql_str.WriteString(\"update %s set deleteStatus=2\")", table.TableName))
			fmt.Fprintln(w, fmt.Sprintf("\tsql_str.WriteString(\" where %s in(\")", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\tquestion_mark := strings.Repeat(\"?,\", len(%ss))", pk_column.ColumnName))
			fmt.Fprintln(w, "\tsql_str.WriteString(question_mark[:len(question_mark)-1])")
			fmt.Fprintln(w, "\tsql_str.WriteString(\")\")")
			fmt.Fprintln(w, "\tvar result sql.Result")
			fmt.Fprintln(w, fmt.Sprintf("\tvals := make([]interface{}, 0, len(%ss))", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\tfor _, v := range %ss {", pk_column.ColumnName))
			fmt.Fprintln(w, "\t\tvals = append(vals, v)")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, fmt.Sprintf("result, err = %s.Exec(sql_str.String(), vals...)", conn_name))
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn count, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\taffected, err := result.RowsAffected()")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn count, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\treturn affected, nil")
			fmt.Fprintln(w, "}")
		}
	}

	// Get
	{
		fmt.Fprintln(w, "")
		fmt.Fprint(w, "// 根据【")
		for index, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if index > 0 {
				fmt.Fprint(w, ",")
			}
			if len(column.ColumnComment) > 0 {
				fmt.Fprint(w, column.ColumnComment)
			} else {
				fmt.Fprint(w, column.ColumnName)
			}
		}
		fmt.Fprint(w, "】查询【")
		if len(table.TableComment) > 0 {
			fmt.Fprint(w, table.TableComment)
		} else {
			fmt.Fprint(w, table.TableName)
		}
		fmt.Fprintln(w, "】表中的单条记录")
		fmt.Fprint(w, fmt.Sprintf("func (d *%s) Get(", table.TableName))
		init_index = 0
		for _, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, fmt.Sprintf("%s %s", column.ColumnName, get_field_type(column.DataType)))
			init_index++
		}
		fmt.Fprintln(w, fmt.Sprintf(") (%s model.%s, err error) {", table.TableName, struct_name))
		fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select ", conn_name))
		init_index = 0
		for _, column := range column_info {
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, column.ColumnName)
			init_index++
		}
		fmt.Fprint(w, fmt.Sprintf(" from %s where ", table.TableName))
		init_index = 0
		for _, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, " and ")
			}
			fmt.Fprint(w, fmt.Sprintf("%s=?", column.ColumnName))
			init_index++
		}
		fmt.Fprint(w, "\", ")
		init_index = 0
		for _, column := range column_info {
			if !strings.EqualFold(column.ColumnKey, "PRI") {
				continue
			}
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, column.ColumnName)
			init_index++
		}
		fmt.Fprintln(w, ")")
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprintln(w, fmt.Sprintf("\t\treturn %s, err", table.TableName))
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\tdefer rows.Close()")
		fmt.Fprintln(w, fmt.Sprintf("\t%ss, err := d._RowsToArray(rows)", table.TableName))
		fmt.Fprintln(w, "\tif err != nil {")
		fmt.Fprintln(w, fmt.Sprintf("\t\treturn %s, err", table.TableName))
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, fmt.Sprintf("\tif len(%ss) <= 0 {", table.TableName))
		fmt.Fprintln(w, fmt.Sprintf("\t\treturn %s, err", table.TableName))
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, fmt.Sprintf("\treturn %ss[0], nil", table.TableName))
		fmt.Fprintln(w, "}")
	}

	// In
	{
		if pk_count == 1 {
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 根据【")
			for index, column := range column_info {
				if !strings.EqualFold(column.ColumnKey, "PRI") {
					continue
				}
				if index > 0 {
					fmt.Fprint(w, ",")
				}
				if len(column.ColumnComment) > 0 {
					fmt.Fprint(w, column.ColumnComment)
				} else {
					fmt.Fprint(w, column.ColumnName)
				}
			}
			fmt.Fprint(w, "】数组查询【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表中的多条记录")
			fmt.Fprintln(w, fmt.Sprintf("func (d *%s) GetIn(%ss []%s) (%ss []model.%s, err error) {", table.TableName, pk_column.ColumnName, get_field_type(pk_column.DataType), table.TableName, struct_name))
			fmt.Fprintln(w, fmt.Sprintf("\tif len(%ss) <= 0 {", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\t\treturn %ss, errors.New(\"%ss is empty\")", table.TableName, pk_column.ColumnName))
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tsql_str := bytes.Buffer{}")
			fmt.Fprint(w, "\tsql_str.WriteString(\"select ")
			init_index = 0
			for _, column := range column_info {
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, column.ColumnName)
				init_index++
			}
			fmt.Fprintln(w, " from \")")
			fmt.Fprintln(w, fmt.Sprintf("\tsql_str.WriteString(\"%s\")", table.TableName))
			fmt.Fprintln(w, fmt.Sprintf("\tsql_str.WriteString(\" where %s in(\")", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\tparam_keys := strings.Repeat(\"?,\", len(%ss))", pk_column.ColumnName))
			fmt.Fprintln(w, "\tsql_str.WriteString(param_keys[:len(param_keys)-1])")
			fmt.Fprintln(w, "\tsql_str.WriteString(\")\")")
			fmt.Fprintln(w, "\tvar rows *sqlx.Rows")
			fmt.Fprintln(w, fmt.Sprintf("\tvals := make([]interface{}, 0, len(%ss))", pk_column.ColumnName))
			fmt.Fprintln(w, fmt.Sprintf("\tfor _, v := range %ss {", pk_column.ColumnName))
			fmt.Fprintln(w, "\t\tvals = append(vals, v)")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, fmt.Sprintf("\trows, err = %s.Queryx(sql_str.String(), vals...)", conn_name))
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, fmt.Sprintf("\t\treturn %ss, err", table.TableName))
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tdefer rows.Close()")
			fmt.Fprintln(w, "\treturn d._RowsToArray(rows)")
			fmt.Fprintln(w, "}")
		}
	}

	// Index
	{
		for key, index := range index_info {
			if strings.Contains(key, "PRIMARY") {
				continue
			}
			if len(index) <= 0 {
				continue
			}
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 根据【")
			for index, index_a := range index {
				tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
				if err != nil {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
				}
				if len(tmp_column.ColumnName) <= 0 {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
				}
				if index > 0 {
					fmt.Fprint(w, ",")
				}
				if len(tmp_column.ColumnComment) > 0 {
					fmt.Fprint(w, tmp_column.ColumnComment)
				} else {
					fmt.Fprint(w, tmp_column.ColumnName)
				}
			}
			fmt.Fprint(w, "】查询【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprint(w, "】表中的")
			if index[0].NonUnique == 0 {
				fmt.Fprint(w, "单")
			} else {
				fmt.Fprint(w, "多")
			}
			fmt.Fprint(w, "条记录，使用索引【")
			fmt.Fprintln(w, fmt.Sprintf("%s,%s】", index[0].IndexName, index[0].IndexComment))
			fmt.Fprint(w, fmt.Sprintf("func (d *%s) GetBy", table.TableName))
			for _, index_a := range index {
				tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
				if err != nil {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
				}
				if len(tmp_column.ColumnName) <= 0 {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
				}
				fmt.Fprint(w, tmp_column.ColumnNameCase)
			}
			fmt.Fprint(w, "(")
			init_index = 0
			for _, index_a := range index {
				tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
				if err != nil {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
				}
				if len(tmp_column.ColumnName) <= 0 {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
				}
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, fmt.Sprintf("%s %s", tmp_column.ColumnName, get_field_type(tmp_column.DataType)))
				init_index++
			}
			fmt.Fprint(w, fmt.Sprintf(") (%s", table.TableName))
			if index[0].NonUnique > 0 {
				fmt.Fprint(w, "s []")
			} else {
				fmt.Fprint(w, " ")
			}
			fmt.Fprintln(w, fmt.Sprintf("model.%s, err error) {", struct_name))
			fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select ", conn_name))
			init_index = 0
			for _, column := range column_info {
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, column.ColumnName)
				init_index++
			}
			fmt.Fprint(w, fmt.Sprintf(" from %s force index(%s) where ", table.TableName, key))
			init_index = 0
			for _, index_a := range index {
				tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
				if err != nil {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
				}
				if len(tmp_column.ColumnName) <= 0 {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
				}
				if init_index > 0 {
					fmt.Fprint(w, " and ")
				}
				fmt.Fprint(w, fmt.Sprintf("%s=?", tmp_column.ColumnName))
				init_index++
			}
			if is_exist_deleteStatus && index[0].NonUnique != 0 {
				fmt.Fprint(w, " and deleteStatus = 1")
			}
			fmt.Fprint(w, "\",")
			init_index = 0
			for _, index_a := range index {
				tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
				if err != nil {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
				}
				if len(tmp_column.ColumnName) <= 0 {
					log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
				}
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, tmp_column.ColumnName)
				init_index++
			}
			fmt.Fprintln(w, ")")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprint(w, fmt.Sprintf("\t\treturn %s", table.TableName))
			if index[0].NonUnique > 0 {
				fmt.Fprint(w, "s")
			}
			fmt.Fprintln(w, ", err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tdefer rows.Close()")
			if index[0].NonUnique == 0 {
				fmt.Fprintln(w, fmt.Sprintf("\t%ss, err := d._RowsToArray(rows)", table.TableName))
				fmt.Fprintln(w, "\tif err != nil {")
				fmt.Fprintln(w, fmt.Sprintf("\t\treturn %s, err", table.TableName))
				fmt.Fprintln(w, "\t}")
				fmt.Fprintln(w, fmt.Sprintf("\tif len(%ss) <= 0 {", table.TableName))
				fmt.Fprintln(w, fmt.Sprintf("\t\treturn %s, err", table.TableName))
				fmt.Fprintln(w, "\t}")
				fmt.Fprintln(w, fmt.Sprintf("\treturn %ss[0], nil", table.TableName))
			} else {
				fmt.Fprintln(w, "\treturn d._RowsToArray(rows)")
			}
			fmt.Fprintln(w, "}")
		}

	}

	// RowCount
	{

		// 查询全部记录数
		{
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 查询【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表总记录数")
			fmt.Fprintln(w, fmt.Sprintf("func (d *%s) GetRowCount() (count int, err error) {", table.TableName))
			fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select count(0) Count from %s", conn_name, table.TableName))
			if is_exist_deleteStatus {
				fmt.Fprint(w, " where deleteStatus = 1")
			}
			fmt.Fprintln(w, "\")")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, "\t\treturn -1, err")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tdefer rows.Close()")
			fmt.Fprintln(w, "\tif rows.Next() {")
			fmt.Fprintln(w, "\t\terr = rows.Scan(&count)")
			fmt.Fprintln(w, "\t\tif err != nil {")
			fmt.Fprintln(w, "\t\t\treturn -1, err")
			fmt.Fprintln(w, "\t\t}")
			fmt.Fprintln(w, "\t\treturn count, nil")
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\treturn -1, nil")
			fmt.Fprintln(w, "}")
		}

		// Index
		{
			for key, index := range index_info {
				if strings.Contains(key, "PRIMARY") {
					continue
				}
				if len(index) <= 0 {
					continue
				}
				if index[0].NonUnique == 0 {
					continue
				}
				fmt.Fprintln(w, "")
				fmt.Fprint(w, "// 根据【")
				for index, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if index > 0 {
						fmt.Fprint(w, ",")
					}
					if len(tmp_column.ColumnComment) > 0 {
						fmt.Fprint(w, tmp_column.ColumnComment)
					} else {
						fmt.Fprint(w, tmp_column.ColumnName)
					}
				}
				fmt.Fprint(w, "】查询【")
				if len(table.TableComment) > 0 {
					fmt.Fprint(w, table.TableComment)
				} else {
					fmt.Fprint(w, table.TableName)
				}
				fmt.Fprint(w, "】表总记录数，使用索引【")
				fmt.Fprintln(w, fmt.Sprintf("%s,%s】", index[0].IndexName, index[0].IndexComment))
				fmt.Fprint(w, fmt.Sprintf("func (d *%s) GetRowCountBy", table.TableName))
				for _, index_a := range index {
					fmt.Fprint(w, index_a.ColumnNameCase)
				}
				fmt.Fprint(w, "(")
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, ", ")
					}
					fmt.Fprint(w, fmt.Sprintf("%s %s", tmp_column.ColumnName, get_field_type(tmp_column.DataType)))
					init_index++
				}
				fmt.Fprintln(w, ") (count int, err error) {")
				fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select count(0) Count from %s force index(%s) where ", conn_name, table.TableName, index[0].IndexName))
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, " and ")
					}
					fmt.Fprint(w, fmt.Sprintf("%s=?", tmp_column.ColumnName))
					init_index++
				}
				if is_exist_deleteStatus {
					fmt.Fprint(w, " and deleteStatus = 1")
				}
				fmt.Fprint(w, "\",")
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, ", ")
					}
					fmt.Fprint(w, tmp_column.ColumnName)
					init_index++
				}
				fmt.Fprintln(w, ")")
				fmt.Fprintln(w, "\tif err != nil {")
				fmt.Fprintln(w, "\t\treturn -1, err")
				fmt.Fprintln(w, "\t}")
				fmt.Fprintln(w, "\tdefer rows.Close()")
				fmt.Fprintln(w, "\tif rows.Next() {")
				fmt.Fprintln(w, "\t\terr = rows.Scan(&count)")
				fmt.Fprintln(w, "\t\tif err != nil {")
				fmt.Fprintln(w, "\t\t\treturn -1, err")
				fmt.Fprintln(w, "\t\t}")
				fmt.Fprintln(w, "\t\treturn count, nil")
				fmt.Fprintln(w, "\t}")
				fmt.Fprintln(w, "\treturn -1, nil")
				fmt.Fprintln(w, "}")
			}
		}

	}

	// RowList
	{

		// NonIndex
		{
			fmt.Fprintln(w, "")
			fmt.Fprint(w, "// 分页查询【")
			if len(table.TableComment) > 0 {
				fmt.Fprint(w, table.TableComment)
			} else {
				fmt.Fprint(w, table.TableName)
			}
			fmt.Fprintln(w, "】表的记录")
			fmt.Fprint(w, fmt.Sprintf("func (d *%s) GetRowList", table.TableName))
			fmt.Fprint(w, "(PageIndex, PageSize int) (")
			fmt.Fprintln(w, fmt.Sprintf("%ss []model.%s, err error) {", table.TableName, struct_name))
			fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select ", conn_name))
			init_index = 0
			for _, column := range column_info {
				if init_index > 0 {
					fmt.Fprint(w, ", ")
				}
				fmt.Fprint(w, column.ColumnName)
				init_index++
			}
			fmt.Fprint(w, fmt.Sprintf(" from %s", table.TableName))
			if is_exist_deleteStatus {
				fmt.Fprint(w, " where deleteStatus = 1")
			}
			fmt.Fprint(w, " limit ?,?\"")
			fmt.Fprint(w, ", (PageIndex-1)*PageSize, PageSize")
			fmt.Fprintln(w, ")")
			fmt.Fprintln(w, "\tif err != nil {")
			fmt.Fprintln(w, fmt.Sprintf("\t\treturn %ss, err", table.TableName))
			fmt.Fprintln(w, "\t}")
			fmt.Fprintln(w, "\tdefer rows.Close()")
			fmt.Fprintln(w, "\treturn d._RowsToArray(rows)")
			fmt.Fprintln(w, "}")
		}

		// Index
		{
			for key, index := range index_info {
				if strings.Contains(key, "PRIMARY") {
					continue
				}
				if len(index) <= 0 {
					continue
				}
				if index[0].NonUnique == 0 {
					continue
				}
				fmt.Fprintln(w, "")
				fmt.Fprint(w, "// 根据【")
				for index, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if index > 0 {
						fmt.Fprint(w, ",")
					}
					if len(tmp_column.ColumnComment) > 0 {
						fmt.Fprint(w, tmp_column.ColumnComment)
					} else {
						fmt.Fprint(w, tmp_column.ColumnName)
					}
				}
				fmt.Fprint(w, "】分页查询【")
				if len(table.TableComment) > 0 {
					fmt.Fprint(w, table.TableComment)
				} else {
					fmt.Fprint(w, table.TableName)
				}
				fmt.Fprint(w, "】表的记录，使用索引【")
				fmt.Fprintln(w, fmt.Sprintf("%s,%s】", index[0].IndexName, index[0].IndexComment))
				fmt.Fprint(w, fmt.Sprintf("func (d *%s) GetRowListBy", table.TableName))
				for _, index_a := range index {
					fmt.Fprint(w, index_a.ColumnNameCase)
				}
				fmt.Fprint(w, "(")
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, ", ")
					}
					fmt.Fprint(w, fmt.Sprintf("%s %s", tmp_column.ColumnName, get_field_type(tmp_column.DataType)))
					init_index++
				}
				fmt.Fprint(w, ", PageIndex, PageSize int) (")
				fmt.Fprintln(w, fmt.Sprintf("%ss []model.%s, err error) {", table.TableName, struct_name))
				fmt.Fprint(w, fmt.Sprintf("\trows, err := %s.Queryx(\"select ", conn_name))
				init_index = 0
				for _, column := range column_info {
					if init_index > 0 {
						fmt.Fprint(w, ", ")
					}
					fmt.Fprint(w, column.ColumnName)
					init_index++
				}
				fmt.Fprint(w, fmt.Sprintf(" from %s force index(%s) where ", table.TableName, index[0].IndexName))
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, " and ")
					}
					fmt.Fprint(w, fmt.Sprintf("%s=?", tmp_column.ColumnName))
					init_index++
				}
				if is_exist_deleteStatus {
					fmt.Fprint(w, " and deleteStatus = 1")
				}
				fmt.Fprint(w, " limit ?,?\",")
				init_index = 0
				for _, index_a := range index {
					tmp_column, err := get_column_by_name(index_a.ColumnName, column_info)
					if err != nil {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:%s\n", table.TableName, key, index_a.ColumnName, err.Error())
					}
					if len(tmp_column.ColumnName) <= 0 {
						log.Fatalf("【generator_dao】生成表:%s,index:%s,column_name:%s,err:没有找到\n", table.TableName, key, index_a.ColumnName)
					}
					if init_index > 0 {
						fmt.Fprint(w, ", ")
					}
					fmt.Fprint(w, tmp_column.ColumnName)
					init_index++
				}
				fmt.Fprint(w, ", (PageIndex-1)*PageSize, PageSize")
				fmt.Fprintln(w, ")")
				fmt.Fprintln(w, "\tif err != nil {")
				fmt.Fprintln(w, fmt.Sprintf("\t\treturn %ss, err", table.TableName))
				fmt.Fprintln(w, "\t}")
				fmt.Fprintln(w, "\tdefer rows.Close()")
				fmt.Fprintln(w, "\treturn d._RowsToArray(rows)")
				fmt.Fprintln(w, "}")
			}
		}

	}

	// RowsToStruct
	{
		fmt.Fprintln(w, "")
		fmt.Fprint(w, "// 解析【")
		if len(table.TableComment) > 0 {
			fmt.Fprint(w, table.TableComment)
		} else {
			fmt.Fprint(w, table.TableName)
		}
		fmt.Fprintln(w, "】表记录")
		fmt.Fprintln(w, fmt.Sprintf("func (m *%s) _RowsToArray(rows *sqlx.Rows) (models []model.%s, err error) {", table.TableName, struct_name))
		fmt.Fprintln(w, "\tfor rows.Next() {")
		fmt.Fprintln(w, fmt.Sprintf("\t\tmo := model.%s{}", struct_name))
		fmt.Fprint(w, "\t\terr = rows.Scan(")
		init_index = 0
		for _, column := range column_info {
			if init_index > 0 {
				fmt.Fprint(w, ", ")
			}
			fmt.Fprint(w, fmt.Sprintf("&mo.%s", column.ColumnNameCase))
			init_index++
		}
		fmt.Fprintln(w, ")")
		fmt.Fprintln(w, "\t\tif err != nil {")
		fmt.Fprintln(w, "\t\t\treturn models, err")
		fmt.Fprintln(w, "\t\t}")
		fmt.Fprintln(w, "\t\tmodels = append(models, mo)")
		fmt.Fprintln(w, "\t}")
		fmt.Fprintln(w, "\treturn models, err")
		fmt.Fprintln(w, "}")
	}

	// 写入文件
	{
		err = w.Flush()
		if err != nil {
			log.Fatalf("【generator_dao】生成表:%s,刷新文件出错:%s\n", table.TableName, err.Error())
		}
	}

	log.Printf("【generator_dao】表:%s,成功!", table.TableName)
}

func get_column_by_name(column_name string, column_info []models.ColumnInfo) (column models.ColumnInfo, err error) {
	for _, col := range column_info {
		if strings.EqualFold(col.ColumnName, column_name) {
			return col, nil
		}
	}
	return
}

func get_field_type(field_type string) string {
	type_result := ""
	switch field_type {
	case "bit":
		type_result = "bool"
	case "tinyint":
		type_result = "int8"
	case "smallint":
		type_result = "int16"
	case "int":
		type_result = "int"
	case "bigint":
		type_result = "int64"
	case "float", "decimal", "double", "numeric":
		type_result = "float64"
	case "char", "nchar", "varchar", "nvarchar", "text", "longtext", "mediumtext", "enum", "set":
		type_result = "string"
	case "blob", "longblob", "mediumblob", "tinyblob":
		type_result = "[]byte"
	case "date", "datetime", "datetime2", "timestamp":
		type_result = "time.Time"
	default:
		type_result = "不支持的类型"
	}
	return type_result
}