{{$dao := . -}}
let _{{$dao.DBName}}Dao = {_daoInstances:{}, _daoActions:{}}

function _make{{$dao.DBName}}Dao(conn, tx, rd) {
    let dao = {_tableInstances:{}}
    let daoActions =  _{{$dao.DBName}}Dao._daoActions
    // let tableActions =  _{{$dao.DBName}}Dao._tableActions
    for(let k in _{{$dao.DBName}}Dao) if(typeof _{{$dao.DBName}}Dao[k]==='function') dao[k] = _{{$dao.DBName}}Dao[k]
    for(let k in daoActions) if(typeof daoActions[k]==='function') dao[k] = daoActions[k]
	{{- range $t := .Tables }}
	Object.defineProperty(dao, "{{$t.TableName}}", {get: function(){return dao._getTable("{{$t.TableName}}")}})
	{{- end }}
    //for(let tableName in _{{$dao.DBName}}Dao._table) Object.defineProperty(dao, tableName, {get: function(){return dao._getTable(tableName)}})
    dao._conn = conn
    dao._tx = tx
    dao._rd = rd
    return dao
}

function get{{$dao.FixedDBName}}Dao(connectionName, redisName) {
    let cachedDaoName = (connectionName||'')+'_'+(redisName||'')
    if(_{{$dao.DBName}}Dao._daoInstances[cachedDaoName]) return _{{$dao.DBName}}Dao._daoInstances[cachedDaoName]
    let conn = typeof db==='object' ? (connectionName ? db.fetch(connectionName) : db.fetch()) : null
    let rd = typeof redis==='object' ? (redisName ? redis.fetch(redisName) : redis.fetch()) : null
    let dao = _make{{$dao.DBName}}Dao(conn, null, rd)
    _{{$dao.DBName}}Dao._daoInstances[cachedDaoName] = dao
    return dao
}

_{{$dao.DBName}}Dao._getTable = function(tableName){
    if(this._tableInstances[tableName]) return this._tableInstances[tableName]
    let tb = _{{$dao.DBName}}Dao[tableName]
    let t = {}
    let daoActions =  _{{$dao.DBName}}Dao._daoActions
    for(let k in tb) if(typeof tb[k]==='function') t[k] = tb[k]
    for(let k in daoActions) if(typeof daoActions[k]==='function') t[k] = daoActions[k]
    // for(let k in tableActions) if(typeof tableActions[k]==='function') t[k] = tableActions[k]
    t._tableName = tableName
    t._conn = this._conn
    t._tx = this._tx
    t._rd = this._rd
    this._tableInstances[tableName] = t
    return t
}

_{{$dao.DBName}}Dao.begin = function() {
    return _make{{$dao.DBName}}Dao(this._conn, this._conn.begin(), this._rd)
}

_{{$dao.DBName}}Dao._daoActions.query = function(sql, ...args) {
    if(this._tx) return this._tx.query(sql, ...args)
    if(this._conn) return this._conn.query(sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.query1 = function(sql, ...args) {
    if(this._tx) return this._tx.query1(sql, ...args)
	let aa = this._conn.query1(sql, ...args)
    if(this._conn) return this._conn.query1(sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.query11 = function(sql, ...args) {
    if(this._tx) return this._tx.query11(sql, ...args)
    if(this._conn) return this._conn.query11(sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.query1a = function(sql, ...args) {
    if(this._tx) return this._tx.query1a(sql, ...args)
    if(this._conn) return this._conn.query1a(sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.exec = function(sql, ...args) {
    if(this._tx) return this._tx.exec(sql, ...args)
    if(this._conn) return this._conn.exec(sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.insertTo = function(table, data) {
    if(this._tx) return this._tx.insert(table, data)
    if(this._conn) return this._conn.insert(table, data)
    return null
}

_{{$dao.DBName}}Dao._daoActions.replaceTo = function(table, data) {
    if(this._tx) return this._tx.replace(table, data)
    if(this._conn) return this._conn.replace(table, data)
    return null
}

_{{$dao.DBName}}Dao._daoActions.updateTo = function(table, data, sql, ...args) {
    if(this._tx) return this._tx.update(table, data, sql, ...args)
    if(this._conn) return this._conn.update(table, data, sql, ...args)
    return null
}

_{{$dao.DBName}}Dao._daoActions.deleteFrom = function(table, where, ...args) {
    if(this._tx) return this._tx.delete(table, where, ...args)
    if(this._conn) return this._conn.delete(table, where, ...args)
    return null
}


{{- range $t := .Tables }}

_{{$dao.DBName}}Dao.{{$t.TableName}} = {}
_{{$dao.DBName}}Dao.{{$t.TableName}}Item = {}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query = {}
_{{$dao.DBName}}Dao.{{$t.TableName}}QueryList = {}

_{{$dao.DBName}}Dao.{{$t.TableName}}.attach = function(item){
    if(!item || typeof item !== 'object') return null
	let o = {}
	for(let k in item) o[k] = item[k]
    let itemSet = _{{$dao.DBName}}Dao.{{$t.TableName}}Item
    for(let k in itemSet) if(typeof itemSet[k]==='function') o[k] = itemSet[k]
    // item._conn = this._conn
    // item._tx = this._tx
    // item._rd = this._rd
    o._table = this
    return o
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.attachList = function(list){
	if(!list || typeof list !== 'object' || !(list instanceof Array)) return []
	let a = []
	for(let i=0; i<list.length; i++) a.push(this.attach(list[i]))
	let queryListSet = _{{$dao.DBName}}Dao.{{$t.TableName}}QueryList
	for(let k in queryListSet) if(typeof queryListSet[k]==='function') a[k] = queryListSet[k]
    return a
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.new = function(data){
    let item = {}
    {{- range $f := .Fields }}
    item.{{$f.Name}} = data && data.{{$f.Name}} !== undefined ? data.{{$f.Name}} : {{$f.Default}}
    {{- end }}
    {{- if .IsAutoId }}
    delete item.{{.AutoIdField}}
    {{- end }}
    {{- if $t.InvalidSet}}
    item.{{$t.ValidField}} = {{$t.ValidFieldConfig.ValidSetValue}}
    {{- end }}
    return this.attach(item)
}

{{range $k := .UniqueKeys -}}
_{{$dao.DBName}}Dao.{{$t.TableName}}.getBy{{$k.Name}} = function({{$k.Args}}) {
    let rr = this.query1("SELECT {{$t.SelectFields}} FROM `{{$t.TableName}}` WHERE {{$k.Where}}{{$t.ValidWhere}}", {{$k.Args}})
    if(this._conn) return this.attach(rr)
    return null
}
{{- end }}

{{ if $t.PrimaryKey -}}
_{{$dao.DBName}}Dao.{{$t.TableName}}.get = function({{$t.PrimaryKey.Args}}) {
    return this.attach( this.query1("SELECT {{$t.SelectFields}} FROM `{{$t.TableName}}` WHERE {{$t.PrimaryKey.Where}}{{$t.ValidWhere}}", {{$t.PrimaryKey.Args}}))
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.getWithFields = function({{$t.PrimaryKey.Args}}, fields) {
    return this.attach(this.query1("SELECT "+fields+" FROM `{{$t.TableName}}` WHERE {{$t.PrimaryKey.Where}}{{$t.ValidWhere}}", {{$t.PrimaryKey.Args}}))
}

{{ if .ValidSet -}}
_{{$dao.DBName}}Dao.{{$t.TableName}}.getWithInvalid = function({{$t.PrimaryKey.Args}}) {
    return this.attach(this.query1("SELECT {{$t.SelectFields}} FROM `{{$t.TableName}}` WHERE {{$t.PrimaryKey.Where}}", {{$t.PrimaryKey.Args}}))
}
{{- end }}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}.insert = function(data) {
{{- range $index, $field := .AutoGenerated }}
    if( data["{{$field}}"] == null ) delete data["{{$field}}"]
{{- end }}
{{- range $index, $field := .AutoGeneratedOnUpdate }}
    delete data["{{$field}}"]
{{- end }}

{{- if $t.InvalidSet}}
    if(data.{{$t.ValidField}}===undefined) data.{{$t.ValidField}} = {{$t.ValidFieldConfig.ValidSetValue}}
{{- end }}

{{- if .HasVersion }}
	let version = this._getVersion()
	data["{{$t.VersionField}}"] = version
{{- end }}
	let r = this.insertTo("{{$t.TableName}}", data)
{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.replace = function(data) {
{{- range $index, $field := .AutoGenerated }}
    if( data["{{$field}}"] == null ) delete data["{{$field}}"]
{{- end }}
{{- range $index, $field := .AutoGeneratedOnUpdate }}
    delete data["{{$field}}"]
{{- end }}

{{- if $t.InvalidSet}}
    if(data.{{$t.ValidField}}===undefined) data.{{$t.ValidField}} = {{$t.ValidFieldConfig.ValidSetValue}}
{{- end }}

{{- if .HasVersion }}
	let version = this._getVersion()
	data["{{$t.VersionField}}"] = version
{{- end }}
	let r = this.replaceTo("{{$t.TableName}}", data)

{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}

{{if .PrimaryKey -}}
_{{$dao.DBName}}Dao.{{$t.TableName}}.update = function(data, {{$t.PrimaryKey.Args}}) {
    {{- range $index, $field := .AutoGenerated }}
    if( data["{{$field}}"] == null ) delete data["{{$field}}"]
    {{- end }}
    {{- range $index, $field := .AutoGeneratedOnUpdate }}
    delete data["{{$field}}"]
    {{- end }}
    {{- if .HasVersion }}
    let version = this._getVersion()
    data["{{$t.VersionField}}"] = version
    {{- end }}
	let r = this.updateTo("{{$t.TableName}}", data, "{{$t.PrimaryKey.Where}}", {{$t.PrimaryKey.Args}})
{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}

{{- if .InvalidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}.enable = function({{$t.PrimaryKey.Args}}) {
{{- if .HasVersion }}
	let version = this._getVersion()
    let r = this.exec("UPDATE `{{$t.TableName}}` set {{$t.ValidSet}}, `{{$t.VersionField}}`=? WHERE {{$t.PrimaryKey.Where}}", version, {{$t.PrimaryKey.Args}})
{{- else }}
    let r = this.exec("UPDATE `{{$t.TableName}}` set {{$t.ValidSet}} WHERE {{$t.PrimaryKey.Where}}", {{$t.PrimaryKey.Args}})
{{- end }}
{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.disable = function({{$t.PrimaryKey.Args}}){
{{- if .HasVersion }}
	let version = this._getVersion()
    let r = this.exec("UPDATE `{{$t.TableName}}` set {{$t.InvalidSet}}, `{{$t.VersionField}}`=? WHERE {{$t.PrimaryKey.Where}}", version, {{$t.PrimaryKey.Args}})
{{- else }}
    let r = this.exec("UPDATE `{{$t.TableName}}` set {{$t.InvalidSet}} WHERE {{$t.PrimaryKey.Where}}", {{$t.PrimaryKey.Args}})
{{- end }}
{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}
{{- else }}

_{{$dao.DBName}}Dao.{{$t.TableName}}.delete = function({{$t.PrimaryKey.Args}}) {
	return this.exec("DELETE FROM `{{$t.TableName}}` WHERE {{$t.PrimaryKey.Where}}", {{$t.PrimaryKey.Args}})
}

_{{$dao.DBName}}Dao.{{$t.TableName}}.deleteBy = function(where, ...args) {
    return this.deleteFrom("{{.TableName}}", where, ...args)
}
{{- end }}

{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}.updateBy = function(data, where, ...args) {
{{- if .HasVersion }}
	let version = this._getVersion()
	data["{{.VersionField}}"] = version
{{- end }}
    let r = this.updateTo("{{.TableName}}", data, where, ...args)
{{- if .HasVersion }}
	this._commitVersion(version)
    r.version = version
{{- end }}
    return r
}

{{ if .HasVersion -}}
_{{$dao.DBName}}Dao.{{$t.TableName}}._getVersion = function() {
	let version = 0
	if(this._rd){
		version = this._rd.incr("_DATA_VERSION_{{.TableName}}")
		if(version > 1){
			this._rd.setEX("_DATA_VERSION_DOING_{{.TableName}}_"+version, 10, true)
			return version
		}

		this._rd.del("_DATA_VERSION_{{.TableName}}")
		version = 0
	} else {
		logger.warn("use version but not configured redis", {db:"{{.DBName}}", table:"{{.TableName}}"})
	}

	let maxVersion = parseInt(this.query11("SELECT MAX(`{{.VersionField}}`) FROM `{{.TableName}}`") || '0')
	version = maxVersion+1
	if(this._rd){
		this._rd.mSet("_DATA_VERSION_{{.TableName}}", version, "_DATA_MAX_VERSION_{{.TableName}}", version)
		this._rd.setEX("_DATA_VERSION_DOING_{{.TableName}}_"+version, 10, true)
	}
	return version
}

_{{$dao.DBName}}Dao.{{$t.TableName}}._commitVersion = function(version) {
    if(this._rd){
		this._rd.del("_DATA_VERSION_DOING_{{.TableName}}_"+version)
        let seqVersion = parseInt(this._rd.get("_DATA_VERSION_{{.TableName}}") || '0')
        let currentMaxVersion = parseInt(this._rd.get("_DATA_MAX_VERSION_{{.TableName}}") || '0')
		for(let i=currentMaxVersion; i<=seqVersion; i++){
			if(this._rd.exists("_DATA_VERSION_DOING_{{.TableName}}_"+i)){
				break
			} else {
				this._rd.set("_DATA_MAX_VERSION_{{.TableName}}", i)
			}
		}
	}
}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}.newQuery = function(){
    let query = {
        _validWhere:     "{{.ValidWhere}}",
        _sql:            "",
        _fields:         "{{.SelectFields}}",
        _where:          "",
        _extraSql:       "",
        _extraArgs:      [],
        _args:           [],
        _leftJoins:      [],
        _leftJoinArgs:   [],
        _result:         null,
		_lastSql:        "",
		_lastSqlArgs:    [],
    }
    let querySet = _{{$dao.DBName}}Dao.{{$t.TableName}}Query
    for(let k in querySet) if(typeof querySet[k]==='function') query[k] = querySet[k]
    query._table = this
    // query._conn = this._conn
    // query._tx = this._tx
    // query._rd = this._rd
    return query
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query._parseFields = function(fields, table) {
    let fieldArr = fields
    if(typeof fields !== 'object' || !(fields instanceof Array)) {
        if(typeof fields !== 'string') fields = fields.toString()
        if (fields==="" || fields.indexOf('(') !== -1 || fields.indexOf('`') !== -1) return fields
        fieldArr = fields.split(",")
    }
	for(let i=0; i<fieldArr.length; i++){
		let field = fieldArr[i]
        if(typeof field !== 'string') field = field.toString()
        field = field.trim()
		let as = ""
		if(field.indexOf(' ')!==-1){
			let a = field.split(" ")
			field = a[0]
			if(a[a.length-2].toLowerCase()==="as" && !a[a.length-1].startsWith("`")){
				a[a.length-1] = "`" + a[a.length-1] + "`"
			}
			as = " " + a.slice(1),join(" ")
		}
		if(table){
			fieldArr[i] = "`"+table+"`.`"+field+"`"+as
		} else {
			fieldArr[i] = "`"+field+"`"+as
		}
	}
	return fieldArr.join(",")
}


_{{$dao.DBName}}Dao.{{$t.TableName}}Query._parse = function(tag){
	if(this._sql !== ""){
		return this._sql, this._args
	}

	let fields = this._fields
	let validWhere = this._validWhere
	if(tag==="COUNT"){
		fields = "COUNT(*)"
	}else if(tag==="COUNT_ALL"){
		fields = "COUNT(*)"
		validWhere = ""
	}else if(tag==="ALL"){
		validWhere = ""
	}else if(tag==="ALL_VERSION"){
		validWhere = ""
	//}else if(tag==="VERSION"){
	}

	let leftJoinsStr = ""
	if(this._leftJoins.length > 0){
		leftJoinsStr = " " + this._leftJoins.join(" ")
		this._args.unshift(...this._leftJoinArgs)
		validWhere = validWhere.replace(/ AND /g, " AND `{{.TableName}}`.")
	}

	if(this._where==="" && validWhere.startsWith(" AND ")) validWhere = validWhere.substring(5)
    if(this._extraArgs) this._args.push(...this._extraArgs)
	return {sql:"SELECT " + fields + " FROM `{{.TableName}}`" + leftJoinsStr + " WHERE " + this._where + validWhere + this._extraSql, args:this._args}
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.sql = function(sql, ...args){
	this._sql = sql
	this._args = args
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.fields = function(fields){
	this._fields = this._parseFields(fields, "")
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.appendFields = function(fields){
	if(this._fields) this._fields += ", "
	this._fields += this._parseFields(fields, "")
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.where = function(where, ...args){
	this._where = where
	this._args = args
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.in = function(field, ...values){
	if(field.indexOf("`")===-1) field = "`"+field+"`"
	this._where = field+" IN "+this._conn.inKeys(values.length)
	this._args = values
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.and = function(where, ...args){
	if(this._where) this._where += " AND "
	this._where += where
	this._args = this._args.push(...args)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.or = function(where, ...args){
	if(this._where) this._where += " OR "
	this._where += where
	this._args = this._args.push(...args)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.andIn = function(field, ...values){
	if(field.indexOf("`")===-1) field = "`"+field+"`"
	if(this._where) this._where += " AND "
	this._where += field + " IN "+this._conn.inKeys(values.length)
	this._args = this._args.push(...values)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.orIn = function(field, ...values){
	if(field.indexOf("`")===-1) field = "`"+field+"`"
	if(this._where) this._where += " OR "
	this._where += field + " IN "+this._conn.inKeys(values.length)
	this._args = this._args.push(...values)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.orderBy = function(orderBy){
	this._extraSql += " ORDER BY " + orderBy
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.groupBy = function(groupBy){
	this._extraSql += " GROUP BY " + groupBy
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.limit = function(start, num){
	if(num===undefined){
		num = start
		start = 0
	}
	this._extraSql += " LIMIT ?,?"
	this._extraArgs.push(start, num)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.having = function(where, ...args){
	this._extraSql += " HAVING "+where
	this._extraArgs = this._extraArgs.push(...args)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.extra = function(sql, ...args){
	this._extraSql += sql
	this._extraArgs = this._extraArgs.push(...args)
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.leftJoin = function(joinTable, fields, on, ...args){
	if(this._fields.indexOf("`{{.TableName}}`.")===-1){
		this._fields = "`{{.TableName}}`."+this._fields.replace(/`, `/g, "`, `{{.TableName}}`.`")
	}
	if(fields) this._fields += ", "+this._parseFields(fields, joinTable)
	this._leftJoins = this._leftJoins.push("LEFT JOIN `" + joinTable + "` ON " + on)
	this._leftJoinArgs = this._leftJoinArgs.push(...args)
	return this
}

{{range $idx := .IndexKeys}}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.by{{$idx.Name}} = function({{$idx.Args}}){
	return this.where("{{$idx.Where}}", {{$idx.Args}})
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.and{{$idx.Name}} = function({{$idx.Args}}){
	if(this._where) this._where += " AND "
	this._where += "{{$idx.Where}}"
	this._args = this._args.push({{$idx.Args}})
	return this
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.or{{$idx.Name}} = function({{$idx.Args}}){
	if(this._where){
		this._where += " OR "
	}
	this._where += "{{$idx.Where}}"
	this._args = this._args.push({{$idx.Args}})
	return this
}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.query = function(){
	let {sql,args} = this._parse("")
	this._lastSql = sql
	this._lastSqlArgs = args
    this._result = this._table.query(sql, ...args).result
	return this
}

{{- if .ValidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.queryWithValid = function(){
	let {sql,args} = this._parse("ALL")
	this._lastSql = sql
	this._lastSqlArgs = args
    this._result = this._table.query(sql, ...args).result
	return this
}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.count = function(){
	let {sql,args} = this._parse("COUNT")
	this._lastSql = sql
	this._lastSqlArgs = args
	return parseInt(this._table.query11(sql, ...args) || '0')
}

{{- if .ValidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.countAll = function(){
	let {sql,args} = this._parse("COUNT_ALL")
	this._lastSql = sql
	this._lastSqlArgs = args
	return parseInt(this._table.query11(sql, ...args) || '0')
}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.queryByPage = function(start, num){
    this.limit(start, num)
	return this.query()
}

{{- if .ValidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.queryWithValidByPage = function(start, num){
    this.limit(start, num)
	return this.queryWithValid()
}
{{- end }}

{{- if .HasVersion }}

{{- if .ValidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.queryByVersion = function(minVersion, maxVersion, limit, withInvalid){
	if(minVersion > 0) withInvalid = true
	let parseTag = u.StringIf(withInvalid, "ALL_VERSION", "VERSION")

{{- else }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Query.queryByVersion = function(minVersion, maxVersion, limit){
    let parseTag = "VERSION"
{{- end }}

	if(maxVersion===0){
		if(this._rd){
			maxVersion = parseInt(this._rd.GET("_DATA_MAX_VERSION_{{.TableName}}") || '0')
		} else {
            logger.warn("use version but not configured redis", {db:"{{.DBName}}", table:"{{.TableName}}"})
		}
		if(maxVersion===0){
			maxVersion = parseInt(this._table.query11("SELECT MAX(`{{.VersionField}}`) FROM `{{.TableName}}`") || '0')
			this._lastSql = "SELECT MAX(`{{.VersionField}}`) FROM `{{.TableName}}`"
			this._lastSqlArgs = []
		}
	}

	this.and("`version` BETWEEN ? AND ?", minVersion+1, maxVersion )
	if(limit > 0){
    	this.orderBy("`{{.VersionField}}`")
    	this.limit(0, limit)
	}

	let {sql,args} = this._parse(parseTag)
	this._lastSql = sql
	this._lastSqlArgs = args
	this._result = this._table.query(sql, ...args).result
    this.maxVersion = maxVersion
	return this
}
{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.first = function(){
	let list = this.list()
	if(list.length > 0) return this._table.attach(list[0])
	return null
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.list = function(){
	if(this._result===null) this.query()
	return this._table.attachList(this._result)
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.listBy = function(...fields){
    if(this._result===null) this.query()
    let list = []
    for(let item of this._result){
        let o = {}
        for(let k in item) if(fields.indexOf(k)!==-1) o[k] = item[k]
        list.push(o)
    }
    return list
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.getSql = function(){
	return this._lastSql
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Query.getSqlArgs = function(){
	return this._lastSqlArgs
}

_{{$dao.DBName}}Dao.{{$t.TableName}}QueryList.getData = function(){
	let list = []
	for(let i=0; i<this.length; i++) list.push(list[i].getData())
	return list
}

_{{$dao.DBName}}Dao.{{$t.TableName}}QueryList.getJson = function(){
	return JSON.stringify(this.getData())
}





{{- if .PrimaryKey }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Item.save = function(){
	return this._table.replace(this.getData())
}

{{- if .InvalidSet }}
_{{$dao.DBName}}Dao.{{$t.TableName}}Item.enable = function(){
	return this._table.enable({{.PrimaryKey.ItemArgs}})
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Item.disable = function(){
	return this._table.disable({{.PrimaryKey.ItemArgs}})
}

{{- else }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Item.delete = function(){
	return this._table.delete({{.PrimaryKey.ItemArgs}})
}
{{- end }}

{{- end }}

_{{$dao.DBName}}Dao.{{$t.TableName}}Item.getData = function(){
    let data = {}
    {{- range $f := .Fields }}
    if(this.{{$f.Name}} !== undefined) data.{{$f.Name}} = this.{{$f.Name}}
    {{- end }}
    return data
}

_{{$dao.DBName}}Dao.{{$t.TableName}}Item.getJson = function(){
    return JSON.stringify(this.getData())
}



{{- end }}