func (m *default{{.upperStartCamelObject}}Model) Update(ctx context.Context, {{if .containsIndexCache}}newData{{else}}data{{end}} *{{.upperStartCamelObject}}) error {
	{{if .withCache}}{{if .containsIndexCache}}data, err:=m.FindOne(ctx, newData.{{.upperStartCamelPrimaryKey}})
	if err!=nil{
		return err
	}

{{end}}	{{.keys}}
    _, {{if .containsIndexCache}}err{{else}}err:{{end}}= m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("UPDATE %s SET %s WHERE {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
		return conn.ExecCtx(ctx, query, {{.expressionValues}})
	}, {{.keyValues}}){{else}}query := fmt.Sprintf("UPDATE %s SET %s WHERE {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
    _,err:=m.conn.ExecCtx(ctx, query, {{.expressionValues}}){{end}}
	return err
}

func (m *default{{.upperStartCamelObject}}Model) UpdateWithTx(ctx context.Context, session sqlx.Session, {{if .containsIndexCache}}newData{{else}}data{{end}} *{{.upperStartCamelObject}}) error {
	{{if .withCache}}{{if .containsIndexCache}}data, err:=m.FindOne(ctx, newData.{{.upperStartCamelPrimaryKey}})
	if err!=nil{
		return err
	}

{{end}}	{{.keys}}
    _, {{if .containsIndexCache}}err{{else}}err:{{end}}= m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		query := fmt.Sprintf("UPDATE %s SET %s WHERE {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
		return session.ExecCtx(ctx, query, {{.expressionValues}})
	}, {{.keyValues}}){{else}}query := fmt.Sprintf("UPDATE %s SET %s WHERE {{.originalPrimaryKey}} = {{if .postgreSql}}$1{{else}}?{{end}}", m.table, {{.lowerStartCamelObject}}RowsWithPlaceHolder)
    _,err:=session.ExecCtx(ctx, query, {{.expressionValues}}){{end}}
	return err
}

func (m *default{{.upperStartCamelObject}}Model) BatchUpdate(ctx context.Context, dataList []*{{.upperStartCamelObject}}) error {
	if len(dataList) == 0 {
		return nil
	}

	{{if .withCache}}keys := make([]string, 0)
	{{if .containsIndexCache}}primaryKeys := make([]interface{}, 0, len(dataList))
	for _, item := range dataList {
		primaryKeys = append(primaryKeys, item.{{.upperStartCamelPrimaryKey}})
	}
	oldList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}{{end}}

	for _, data := range {{if .containsIndexCache}}oldList{{else}}dataList{{end}} {
		{{.keys}}
		keys = append(keys, {{.keyValues}})
	}

	query, vals := m.buildBatchUpdateQuery(dataList)
	_, err {{if .containsIndexCache}}={{else}}:={{end}} m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return conn.ExecCtx(ctx, query, vals...)
	}, keys...)
	{{else}}query, vals := m.buildBatchUpdateQuery(dataList)
	_, err := m.conn.ExecCtx(ctx, query, vals...)
	{{end}}
	return err
}

func (m *default{{.upperStartCamelObject}}Model) BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*{{.upperStartCamelObject}}) error {
	if len(dataList) == 0 {
		return nil
	}

	{{if .withCache}}keys := make([]string, 0)
	{{if .containsIndexCache}}primaryKeys := make([]interface{}, 0, len(dataList))
	for _, item := range dataList {
		primaryKeys = append(primaryKeys, item.{{.upperStartCamelPrimaryKey}})
	}
	oldList, err := m.findListByPrimaryKeys(ctx, primaryKeys)
	if err != nil {
		return err
	}{{end}}

	for _, data := range {{if .containsIndexCache}}oldList{{else}}dataList{{end}} {
		{{.keys}}
		keys = append(keys, {{.keyValues}})
	}

	query, vals := m.buildBatchUpdateQuery(dataList)
	_, err {{if .containsIndexCache}}={{else}}:={{end}} m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
		return session.ExecCtx(ctx, query, vals...)
	}, keys...)
	{{else}}query, vals := m.buildBatchUpdateQuery(dataList)
	_, err := session.ExecCtx(ctx, query, vals...)
	{{end}}
	return err
}

func (m *default{{.upperStartCamelObject}}Model) buildBatchUpdateQuery(dataList []*{{.upperStartCamelObject}}) (string, []interface{}) {
	{{if .postgreSql}}rawParts := strings.Split({{.lowerStartCamelObject}}RowsWithPlaceHolder, ", ")
	fields := make([]string, len(rawParts))
	for i, part := range rawParts {
		fields[i] = part[:strings.Index(part, " =")]
	}{{else}}fields := strings.Split(strings.ReplaceAll({{.lowerStartCamelObject}}RowsWithPlaceHolder, "=?", ""), ","){{end}}

	listValues := make([][]interface{}, 0, len(dataList))
	for _, {{if .containsIndexCache}}newData{{else}}data{{end}} := range dataList {
		values := make([]interface{}, 0, len(fields)+1)
		values = append(values, {{.expressionValues}})
		listValues = append(listValues, values)
	}

	vals := make([]interface{}, 0, len(dataList)*(len(fields)*2+1))
	setClauses := make([]string, len(fields))
	{{if .postgreSql}}placeholderIdx := 1{{end}}
	for i, field := range fields {
		caseClauses := make([]string, len(dataList))
		for j, item := range dataList {
			{{if .postgreSql}}caseClauses[j] = fmt.Sprintf("WHEN {{.originalPrimaryKey}} = $%d THEN $%d", placeholderIdx, placeholderIdx+1)
			placeholderIdx += 2{{else}}caseClauses[j] = "WHEN {{.originalPrimaryKey}} = ? THEN ?"{{end}}
			vals = append(vals, item.{{.upperStartCamelPrimaryKey}}, listValues[j][i])
		}
		setClauses[i] = fmt.Sprintf("%s = CASE %s ELSE %s END", field, strings.Join(caseClauses, " "), field)
	}

	wherePlaceholders := make([]string, len(dataList))
	for i, item := range dataList {
		{{if .postgreSql}}wherePlaceholders[i] = fmt.Sprintf("$%d", placeholderIdx)
		placeholderIdx++{{else}}wherePlaceholders[i] = "?"{{end}}
		vals = append(vals, item.{{.upperStartCamelPrimaryKey}})
	}

	query := fmt.Sprintf("UPDATE %s SET %s WHERE {{.originalPrimaryKey}} IN (%s)", m.table, strings.Join(setClauses, ", "), strings.Join(wherePlaceholders, ","))
	return query, vals
}