intimate/autostore.go

package intimate

import (
	"database/sql"
	"encoding/binary"
	"fmt"
	"log"
	"reflect"
	"strconv"
	"time"
)

type Store struct {
	db *sql.DB
}

type Table struct {
	store   *Store
	name    string
	setting interface{}

	updatesql string
	selectsql string
	insertsql string
}

// const updatesql = "UPDATE %s SET %s WHERE %s = ?"

func NewStore(uri string) *Store {
	db, err := sql.Open("mysql", uri)
	if err != nil {
		panic(err)
	}
	s := &Store{db: db}
	return s
}

func (store *Store) Table(name string) *Table {
	table := &Table{store: store}
	table.name = name

	table.insertsql = `INSERT INTO ` + table.name + `(%s) values(%s)`
	table.updatesql = `UPDATE ` + table.name + ` SET %s WHERE %s = ?`
	// table.selectsql = `FROM ` + table.name + `WHERE operator`
	return table
}

type Queue struct {
	table     *Table
	obj       reflect.Type
	selected  string
	condition string
	uidname   string
	uididx    int
}

// OperatorType 字典Operator 标志位的类型
type OperatorType string

const (
	// OpOK 正常
	OpOK OperatorType = "0"
	// OpWAIT 等待处理
	OpWAIT OperatorType = "1000"
	// OpERROR 错误处理
	OpERROR OperatorType = "10000"
)

func (t *Table) Queue(obj interface{}, whereCondition string) *Queue {
	q := &Queue{}
	q.condition = whereCondition
	q.obj = reflect.TypeOf(obj)
	q.table = t

	for i := 0; i < q.obj.NumField(); i++ {
		field := q.obj.Field(i)
		if fname, ok := field.Tag.Lookup("field"); ok {
			q.selected += fname + ","
			if _, ok := field.Tag.Lookup("uid"); ok {
				q.uididx = i
				q.uidname = fname
			}
		}

	}

	q.selected = q.selected[:len(q.selected)-1]
	return q
}

func (t *Table) Insert(obj interface{}) error {
	ov := reflect.ValueOf(obj).Elem()
	ot := reflect.TypeOf(obj)

	fieldsql := ""
	argssql := ""

	var args []interface{}
	for i := 0; i < ov.NumField(); i++ {
		field := ov.Field(i)
		ftype := ot.Elem().Field(i)

		if fname, ok := ftype.Tag.Lookup("field"); ok {
			if flag, ok := ftype.Tag.Lookup("uid"); ok {
				if flag == "auto" {
					continue
				}
			}

			k := ftype.Type.Kind()
			if k == reflect.Ptr || k == reflect.Interface {
				if !field.IsNil() {
					felem := field.Elem()
					args = append(args, felem.Interface())
					fieldsql += fname + ","
					argssql += "?,"
				}
			} else {
				args = append(args, field.Interface())
				fieldsql += fname + ","
				argssql += "?,"
			}

		}

	}

	ssql := fmt.Sprintf(t.insertsql, fieldsql[:len(fieldsql)-1], argssql[:len(argssql)-1])
	_, err := t.store.db.Exec(ssql, args...)
	return err
}

func (t *Table) Update(obj interface{}) error {

	ov := reflect.ValueOf(obj).Elem()
	ot := reflect.TypeOf(obj)

	fieldsql := ""
	var uidname string
	var uidvalue interface{}

	var args []interface{}
	for i := 0; i < ov.NumField(); i++ {
		field := ov.Field(i)
		ftype := ot.Elem().Field(i)

		if fname, ok := ftype.Tag.Lookup("field"); ok {
			if _, ok := ftype.Tag.Lookup("uid"); ok {
				if uidvalue != nil {
					panic(fmt.Errorf("uid must unique, %s and %s", uidname, fname))
				}
				uidname = fname
				uidvalue = field.Interface()
				continue
			}

			k := ftype.Type.Kind()
			if k == reflect.Ptr || k == reflect.Interface {
				if !field.IsNil() {
					felem := field.Elem()
					args = append(args, felem.Interface())
					fieldsql += fname + " = ?,"
				}
			} else {
				args = append(args, field.Interface())
				fieldsql += fname + " = ?,"
			}

		}

	}

	if uidvalue == nil {
		panic(fmt.Errorf("update must contain `uid` tag"))
	}

	usql := fmt.Sprintf(t.updatesql, fieldsql[:len(fieldsql)-1], uidname)
	args = append(args, uidvalue)
	_, err := t.store.db.Exec(usql, args...)
	return err
}

func assign(field reflect.Value, src interface{}) (bool, error) {
	switch field.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		s := asString(src)
		i64, err := strconv.ParseInt(s, 10, field.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return false, fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, field.Kind(), err)
		}
		field.SetInt(i64)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:

		s := asString(src)
		u64, err := strconv.ParseUint(s, 10, field.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return false, fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, field.Kind(), err)
		}
		field.SetUint(u64)
	case reflect.Float32, reflect.Float64:
		s := asString(src)
		f64, err := strconv.ParseFloat(s, field.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return false, fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, field.Kind(), err)
		}
		field.SetFloat(f64)
	case reflect.String:
		field.SetString(string(src.([]byte)))
	case reflect.Interface:
		return true, nil
	}

	return false, nil
}

func convert(src interface{}, field reflect.Value, columntype *sql.ColumnType) error {

	log.Println("type:", field.Type(), ",kind:", field.Kind(), ",field:", field, "scanType:", columntype.ScanType(), "databaseType:", columntype.DatabaseTypeName())
	if field.Kind() == reflect.Ptr {
		fn := field.Type().Elem() // New 一个  field.Type().Elem() . 然后判断 columntype 转化 成 NullString Time
		field.Set(reflect.New(fn))
		field = field.Elem()
		log.Println("type:", fn.Name(), ",kind:", field.Kind(), ",fieldtype:", field.Type())
	}

	// log.Println(field.Kind(), field, reflect.TypeOf(field).Elem().Name(), columntype.ScanType().Kind())

	if src == nil {
		return fmt.Errorf("converting NULL to %s is unsupported", field.Kind())
	}

	switch columntype.DatabaseTypeName() {

	case "TINYINT", "SMALLINT", "MEDIUMINT", "INT", "BIGINT":
		isdefault, err := assign(field, src)
		if err != nil {
			return err
		}
		if isdefault {
			s := asString(src)
			i64, err := strconv.ParseInt(s, 10, 64)
			if err != nil {
				err = strconvErr(err)
				return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, field.Kind(), err)
			}
			// reflect.New(reflect.TypeOf(i64))
			field.Set(reflect.ValueOf(i64))
		}

	case "FLOAT", "DOUBLE", "DECIMAL":
		isdefault, err := assign(field, src)
		if err != nil {
			return err
		}
		if isdefault {
			s := asString(src)
			f64, err := strconv.ParseFloat(s, 64)
			if err != nil {
				err = strconvErr(err)
				return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, field.Kind(), err)
			}
			field.Set(reflect.ValueOf(f64))
		}

	case "BINARY", "VARBINARY", "TINYBLOB", "BLOB", "MEDIUMBLOB", "LONGBLOB", "JSON":
		isdefault, err := assign(field, src)
		if err != nil {
			return err
		}
		if isdefault {
			field.Set(reflect.ValueOf(src.([]byte)))
		}
	case "CHAR", "VARCHAR", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT":
		isdefault, err := assign(field, src)
		if err != nil {
			return err
		}
		if isdefault {
			field.Set(reflect.ValueOf(string(src.([]byte))))
		}

	case "BIT":
		var bits []byte = make([]byte, 8)
		copy(bits, src.([]byte))

		switch field.Kind() {
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			field.SetInt(int64(binary.LittleEndian.Uint64(bits)))

		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			field.SetUint(binary.LittleEndian.Uint64(bits))

		case reflect.Interface:
			field.Set(reflect.ValueOf(binary.LittleEndian.Uint64(bits)))

		}

	case "YEAR", "TIME", "DATE", "DATETIME", "TIMESTAMP":
		s := src.(time.Time)
		switch field.Interface().(type) {
		case time.Time:
			field.Set(reflect.ValueOf(src))
		case string:
			field.SetString(s.Format(time.RFC3339Nano))
		case []byte:
			field.SetBytes([]byte(s.Format(time.RFC3339Nano)))
		default:
		}
	}

	// log.Println(fv, columntype.ScanType().Kind())

	if iscan, ok := field.Addr().Interface().(sql.Scanner); ok {
		err := iscan.Scan(src)
		if err != nil {
			return err
		}
		return nil
	}

	return nil
}