golang代码创建mysql表

基于go，go template的数据层代码生成器，支持生成基于xorm go，spring jpa的数据层代码生成

main.go

package main

import (

"fmt"

"io/ioutil"

"os"

"strings"

"text/template"

"unsafe"

_ "github.com/go-sql-driver/mysql"

"gopkg.in/yaml.v2"

"xorm.io/xorm"

)

const (

selectCurrentDbSql = "SELECT DATABASE()"

allColumnInfoSql = "SELECT * FROM information_schema.columns WHERE table_schema =? ORDER BY table_schema ASC,table_name ASC,ordinal_position ASC"

)

func main() {

config, err := NewConfiguration()

if err != nil {

fmt.Println("can not read configuration file,err:", err)

return

}

engine, err := xorm.NewEngine("mysql", config.Datasource)

if err != nil {

fmt.Println("can not create database engine,err:", err)

return

}

currentDb := ""

if _, err := engine.SQL(selectCurrentDbSql).Get(&currentDb); err != nil {

fmt.Println("can not get current database,err:", err)

return

}

columns := make([]DataColumn, 0)

if err := engine.SQL(allColumnInfoSql, currentDb).Find(&columns); err != nil {

fmt.Println("can not get column information,err:", err)

return

}

tableMap := make(map[string][]DataColumn)

for _, column := range columns {

tableName := column.TableName

if _, ok := tableMap[tableName]; !ok {

tableMap[tableName] = make([]DataColumn, 0)

}

tableMap[tableName] = append(tableMap[tableName], column)

}

funcMap := template.FuncMap{"upperCamelCase": UpperCamelCase, "lowerCamelCase": LowerCamelCase}

t, err := template.New(config.TplName).Funcs(funcMap).ParseFiles(config.TplFile)

if err != nil {

fmt.Println("parse file err:", err)

return

}

os.RemoveAll(config.Output)

for table, columns := range tableMap {

if _, err := os.Stat(config.Output); os.IsNotExist(err) {

os.Mkdir(config.Output, 0777)

os.Chmod(config.Output, 0777)

}

fileSb := new(strings.Builder)

fileSb.WriteString(config.Output)

fileSb.WriteString("/")

if config.Lang == "go" {

fileSb.WriteString(table)

if config.TargetType == "repository" {

fileSb.WriteString("_repository")

}

} else if config.Lang == "java" {

if config.TargetType == "entity" {

fileSb.WriteString(UpperCamelCase(table))

fileSb.WriteString("Entity")

} else if config.TargetType == "model" {

fileSb.WriteString(UpperCamelCase(table))

} else if config.TargetType == "repository" {

fileSb.WriteString(UpperCamelCase(table))

fileSb.WriteString("EntityRepository")

}

}

fileSb.WriteString(".")

fileSb.WriteString(config.Lang)

f, err := os.OpenFile(fileSb.String(), os.O_CREATE|os.O_WRONLY, 0666)

defer f.Close()

if err != nil {

fmt.Println("can not create output file,err:", err)

return

}

if err := t.Execute(f, &Config{TableName: table, Readonly: config.Readonly, PackageName: config.PackageName, Columns: columns}); err != nil {

fmt.Println("There was an error:", err.Error())

}

}

}

type Configuration struct {

Datasource string `yaml:"datasource"`

Lang string `yaml:"lang"`

TargetType string `yaml:"target-type"`

TplName string `yaml:"tpl-name"`

TplFile string `yaml:"tpl-file"`

Readonly bool `yaml:"readonly"`

Output string `yaml:"output"`

SkipTables []string `yaml:"skip-tables"`

SkipColumns []SkipColumn `yaml:"skip-columns"`

TypeMap map[string]string `yaml:"type-map"`

PackageName string `yaml:"package-name"`

}

type SkipColumn struct {

Table string `yaml:"table"`

Column string `yaml:"column"`

}

func NewConfiguration() (*Configuration, error) {

conf := new(Configuration)

data, err := ioutil.ReadFile("config.yml")

if err != nil {

return conf, err

}

err = yaml.Unmarshal(data, &conf)

return conf, err

}

type Config struct {

TableName string

Readonly bool

PackageName string

Columns []DataColumn

}

func (c *Config) PrimaryColumnDataType() string {

for _, column := range c.Columns {

if column.IsPrimary() {

return column.JavaType()

}

}

return ""

}

func (c *Config) HasDelStatus() bool {

for _, column := range c.Columns {

if column.IsDelStatus() {

return true

}

}

return false

}

func (c *Config) HasDecimalType() bool {

for _, column := range c.Columns {

if column.IsDecimalType() {

return true

}

}

return false

}

func (c *Config) HasDateType() bool {

for _, column := range c.Columns {

if column.IsDateType() {

return true

}

}

return false

}

func (c *Config) HasEnterpriseId() bool {

return c.HasColumn("enterprise_id")

}

func (c *Config) HasCode() bool {

return c.HasColumn("code")

}

func (c *Config) HasStatus() bool {

return c.HasColumn("status")

}

func (c *Config) HasColumn(name string) bool {

for _, column := range c.Columns {

if column.ColumnName == name {

return true

}

}

return false

}

type DataColumn struct {

TableSchema string

TableName string

ColumnName string

OrdinalPosition int

ColumnDefault string

IsNullable string

DataType string

CharacterMaximumLength string

CharacterOctetLength string

NumericPrecision string

NumbericScale string

DatetimePrecision string

ColumnType string

ColumnKey string

Extra string

ColumnComment string

}

func (c *DataColumn) IsIdentity() bool {

return strings.ToLower(c.Extra) == "auto_increment"

}

func (c *DataColumn) IsPrimary() bool {

return strings.ToLower(c.ColumnKey) == "pri"

}

func (c *DataColumn) GoLangType() string {

dataType := strings.ToLower(c.DataType)

nullable := strings.ToLower(c.IsNullable) == "yes"

if dataType == "int" {

if nullable {

return "*int"

}

return "int"

}

if dataType == "varchar" || dataType == "text" || dataType == "longtext" {

if nullable {

return "*string"

}

return "string"

}

if dataType == "long" || dataType == "bigint" {

if nullable {

return "*int64"

}

return "int64"

}

if dataType == "decimal" {

if nullable {

return "*float64"

}

return "ifloat64"

}

if dataType == "datetime" {

if nullable {

return "*core.LocalDateTime"

}

return "core.LocalDateTime"

}

return dataType

}

func (c *DataColumn) JavaType() string {

dataType := strings.ToLower(c.DataType)

if dataType == "int" {

return "Integer"

} else if dataType == "varchar" || dataType == "text" || dataType == "longtext" {

return "String"

} else if dataType == "long" || dataType == "bigint" {

return "Long"

} else if dataType == "decimal" {

return "BigDecimal"

} else if dataType == "datetime" {

return "LocalDateTime"

} else {

return c.DataType

}

}

func (c *DataColumn) IsDateType() bool {

return strings.ToLower(c.DataType) == "datetime"

}

func (c *DataColumn) IsDecimalType() bool {

return strings.ToLower(c.DataType) == "decimal"

}

func (c *DataColumn) IsDelStatus() bool {

return c.ColumnName == "del_status"

}

func (c *DataColumn) Tag() string {

name := strings.ToLower(c.ColumnName)

dataType := strings.ToLower(c.DataType)

identity := strings.ToLower(c.Extra) == "auto_increment"

primary := strings.ToLower(c.ColumnKey) == "pri"

nullable := strings.ToLower(c.IsNullable) == "yes"

sb := new(strings.Builder)

sb.WriteString("`xorm:\"")

sb.WriteString(dataType)

sb.WriteString(" '")

sb.WriteString(name)

sb.WriteString("'")

if identity {

sb.WriteString(" autoincr")

}

if primary {

sb.WriteString(" pk")

}

if nullable {

sb.WriteString(" null")

} else {

sb.WriteString(" notnull")

}

sb.WriteString(" default(")

if dataType == "varchar" || dataType == "text" || dataType == "longtext" {

sb.WriteString("'")

}

sb.WriteString(c.ColumnDefault)

if dataType == "varchar" || dataType == "text" || dataType == "longtext" {

sb.WriteString("'")

}

sb.WriteString(")")

sb.WriteString(" comment('")

sb.WriteString(c.ColumnComment)

sb.WriteString("')")

sb.WriteString("\" json:\"")

if name == "del_status" {

sb.WriteString("-")

} else {

sb.WriteString(LowerCamelCase(c.ColumnName))

}

sb.WriteString("\"`")

return sb.String()

}

func UpperCamelCase(txt string) string {

sb := new(strings.Builder)

strs := strings.Split(txt, "_")

for _, str := range strs {

sb.WriteString(strings.ToUpper(string(str[0])))

sb.WriteString(str[1:])

}

return sb.String()

}

func LowerCamelCase(txt string) string {

sb := new(strings.Builder)

strs := strings.Split(txt, "_")

for i, str := range strs {

if i == 0 {

sb.WriteString(strings.ToLower(string(str[0])))

} else {

sb.WriteString(strings.ToUpper(string(str[0])))

}

sb.WriteString(str[1:])

}

return sb.String()

}

func BytesToString(b []byte) string {

return *(*string)(unsafe.Pointer(&b))

}

config.yml

datasource: ""

lang: java

target-type: repository

tpl-name: repository.tpl

tpl-file: tpl/java/repository.tpl

readonly: false

output: ""

skip-tables:

skip-columns:

type-map:

package-name:

go/model.tpl

package model

type {{upperCamelCase .TableName}} struct{

{{- range $column := .Columns}}

{{- if not .IsDelStatus}}

// {{.ColumnComment}}

{{upperCamelCase .ColumnName}} {{.GoLangType}}

{{- end -}}

{{end}}

}

go/repository.tpl

package repository

type {{upperCamelCase .TableName}} struct{

{{range $column := .Columns -}}

{{upperCamelCase .ColumnName }} {{.GoLangType}} {{.Tag}}

{{end -}}

}

func (entity *{{upperCamelCase .TableName}}) Copy(target *{{upperCamelCase .TableName}},columns []string) ([]string,[]utility.BeanUpdateLogItem){

updateColumns:=make([]string,0,len({{lowerCamelCase .TableName}}Columns))

updateLogItems:=make([]utility.BeanUpdateLogItem,0,len({{lowerCamelCase .TableName}}Columns))

columnMap := make(map[string]string)

for _,column := range columns {

columnMap[column]=column

}

{{range $column := .Columns -}}

if _,ok:=columnMap["{{upperCamelCase .ColumnName}}"];!ok && entity.{{upperCamelCase .ColumnName}} != target.{{upperCamelCase .ColumnName}}{

updateColumns = append(updateColumns,"{{.ColumnName}}")

updateLogItems = append(updateLogItems,utility.BeanUpdateLogItem{PropertyName:"{{upperCamelCase .ColumnName}}",OldProperyValue:entity.{{upperCamelCase .ColumnName}},NewPropertyValue:target.{{upperCamelCase .ColumnName}}})

target.{{upperCamelCase .ColumnName}} = entity.{{upperCamelCase .ColumnName}}

}

{{end -}}

}

{{if not .Readonly}}

var(

{{lowerCamelCase .TableName}}Columns=[]string{

{{range $column := .Columns -}}

"{{.ColumnName}}",

{{end -}}

}

{{lowerCamelCase .TableName}}ColumnMap=map[string]string{

{{range $column := .Columns -}}

"{{.ColumnName }}":"{{.ColumnName}}",

{{end -}}

}

)

{{end}}

type {{upperCamelCase .TableName}}Repository interface {

{{- if not .Readonly}}

Create(entity {{upperCamelCase .TableName}}) ({{upperCamelCase .TableName}}, error)

{{- end -}}

{{- if not .Readonly}}

CreateBySession(session *xorm.Session, entity {{upperCamelCase .TableName}}) ({{upperCamelCase .TableName}}, error)

{{- end -}}

{{- if not .Readonly}}

DeleteById(id int64) (int64, error)

{{- end -}}

{{- if not .Readonly}}

DeleteBySessionAndId(session *xorm.Session, id int64) (int64, error)

{{- end -}}

{{- if not .Readonly}}

Update(entity {{upperCamelCase .TableName}}, columns []string) ({{upperCamelCase .TableName}}, error)

{{- end -}}

{{- if not .Readonly}}

UpdateBySession(session *xorm.Session, entity {{upperCamelCase .TableName}}, columns []string) ({{upperCamelCase .TableName}}, error)

{{- end}}

FindById(id int64) ({{upperCamelCase .TableName}}, error)

FindBySessionAndId(session *xorm.Session, id int64) ({{upperCamelCase .TableName}}, error)

}

type {{lowerCamelCase .TableName}}Repository struct {

engine *xorm.Engine

}

func New{{upperCamelCase .TableName}}Repository(engine *xorm.Engine) {{upperCamelCase .TableName}}Repository {

return &{{lowerCamelCase .TableName}}Repository{

engine: engine,

}

}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) Create(entity {{upperCamelCase .TableName}}) ({{upperCamelCase .TableName}}, error) {

_, err := r.engine.Insert(&entity)

return entity, err

}

{{end -}}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) CreateBySession(session *xorm.Session, entity {{upperCamelCase .TableName}}) ({{upperCamelCase .TableName}}, error) {

_, err := session.Insert(&entity)

return entity, err

}

{{end -}}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) DeleteById(id int64) (int64, error) {

{{- if .HasDelStatus}}

return r.engine.ID(id).Cols("del_status", "update_time").Update(&{{upperCamelCase .TableName}}{DelStatus: 1, UpdateTime: core.LocalDateTime(time.Now())})

{{- else}}

return r.engine.ID(id).Delete(&{{upperCamelCase .TableName}}{})

{{- end}}

}

{{end -}}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) DeleteBySessionAndId(session *xorm.Session, id int64) (int64, error) {

{{- if .HasDelStatus}}

return session.ID(id).Cols("del_status", "update_time").Update(&{{upperCamelCase .TableName}}{DelStatus: 1, UpdateTime: core.LocalDateTime(time.Now())})

{{- else}}

return session.ID(id).Delete(&{{upperCamelCase .TableName}}{})

{{- end}}

}

{{end -}}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) Update(entity {{upperCamelCase .TableName}},columns []string) ({{upperCamelCase .TableName}}, error) {

_, err := r.engine.ID(entity.Id).Cols(columns...).Update(&entity)

return entity, err

}

{{end -}}

{{if not .Readonly}}

func (r *{{lowerCamelCase .TableName}}Repository) UpdateBySession(session *xorm.Session, entity {{upperCamelCase .TableName}},columns []string) ({{upperCamelCase .TableName}}, error) {

_, err := session.ID(entity.Id).Cols(columns...).Update(&entity)

return entity, err

}

{{end}}

func (r *{{lowerCamelCase .TableName}}Repository) FindById(id int64) ({{upperCamelCase .TableName}}, error) {

entity := new({{upperCamelCase .TableName}})

_, err := r.engine.ID(id){{if .HasDelStatus}}.Where("del_status=0"){{end}}.Get(entity)

return *entity, err

}

func (r *{{lowerCamelCase .TableName}}Repository) FindBySessionAndId(session *xorm.Session, id int64) ({{upperCamelCase .TableName}}, error) {

entity := new({{upperCamelCase .TableName}})

_, err := session.ID(id){{if .HasDelStatus}}.Where("del_status=0"){{end}}.Get(entity)

return *entity, err

}

java/entity.tpl

package {{.PackageName}}.data.entity;

import java.io.Serializable;

{{- if .HasDecimalType}}

import java.math.BigDecimal;

{{- end -}}

{{if .HasDateType}}

import java.time.LocalDateTime;

{{- end}}

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name = "{{.TableName}}")

public class {{upperCamelCase .TableName}}Entity implements Serializable {

private static final long serialVersionUID = 1L;

{{- range $column := .Columns}}

/*

* {{.ColumnComment}}

*/

{{if .IsPrimary -}}

@Id

{{- end -}}

{{if .IsIdentity}}

@GeneratedValue(strategy = GenerationType.IDENTITY)

{{- end -}}

@Column(name = "{{.ColumnName}}")

private {{.JavaType}} {{lowerCamelCase .ColumnName}};

{{end}}

{{- range $column := .Columns}}

public {{.JavaType}} get{{upperCamelCase .ColumnName}}() {

return {{lowerCamelCase .ColumnName}};

}

public void set{{upperCamelCase .ColumnName}}({{.JavaType}} {{lowerCamelCase .ColumnName}}) {

this.{{lowerCamelCase .ColumnName}} = {{lowerCamelCase .ColumnName}};

}

{{end}}

}

java/model.tpl

package {{.PackageName}}.model;

{{if .HasDecimalType}}

import java.math.BigDecimal;

{{- end -}}

{{if .HasDateType}}

import java.time.LocalDateTime;

{{- end}}

@Entity

@Table(name = "{{.TableName}}")

public class {{upperCamelCase .TableName}} {

{{- range $column := .Columns}}

/*

* {{.ColumnComment}}

*/

private {{.JavaType}} {{lowerCamelCase .ColumnName}};

{{- end}}

{{range $column := .Columns}}

public {{.JavaType}} get{{upperCamelCase .ColumnName}}() {

return {{lowerCamelCase .ColumnName}};

}

public void set{{upperCamelCase .ColumnName}}({{.JavaType}} {{lowerCamelCase .ColumnName}}) {

this.{{lowerCamelCase .ColumnName}} = {{lowerCamelCase .ColumnName}};

}

{{end}}

}

java/repository.tpl

package {{.PackageName}}.data.repository;

import java.time.LocalDateTime;

import java.util.Collection;

import java.util.List;

import java.util.Optional;

import org.springframework.data.domain.Pageable;

import org.springframework.data.domain.Slice;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import org.springframework.data.jpa.repository.Modifying;

import org.springframework.data.jpa.repository.Query;

import org.springframework.data.repository.query.Param;

import {{.PackageName}}.entity.{{upperCamelCase .TableName}}Entity;

public interface {{upperCamelCase .TableName}}EntityRepository

extends JpaRepository, JpaSpecificationExecutor {

{{if .HasEnterpriseId}}

@Query("select count(e.id) from #{#entityName} e where e.enterpriseId=0 or e.enterpriseId=:enterpriseId")

long countByEnterpriseId(@Param("enterpriseId")Long enterpriseId);

@Query("select count(e.id) from #{#entityName} e where (e.enterpriseId=0 or e.enterpriseId=:enterpriseId) and e.updateTime>:updateTime")

long countByEnterpriseIdAndUpdateTimeGreaterThan(@Param("enterpriseId")Long enterpriseId, @Param("updateTime")LocalDateTime updateTime);

@Query("select e from #{#entityName} e where e.enterpriseId=0 or e.enterpriseId=:enterpriseId")

List findByEnterpriseId(@Param("enterpriseId")Long enterpriseId);

@Query("select e from #{#entityName} e where (e.enterpriseId=0 or e.enterpriseId=:enterpriseId) and e.id>:id")

Slice findByEnterpriseIdAndIdGreaterThanOrderByIdAsc(@Param("enterpriseId")Long enterpriseId, @Param("id")Long id, Pageable pageable);

@Query("select e from #{#entityName} e where (e.enterpriseId=0 or e.enterpriseId=:enterpriseId) and e.id>:id and e.updateTime>:updateTime")

Slice findByEnterpriseIdAndIdGreaterThanAndUpdateTimeGreaterThanOrderByIdAsc(@Param("enterpriseId")Long enterpriseId,

@Param("id")Long id, @Param("updateTime")LocalDateTime updateTime, Pageable pageable);

long countByEnterpriseIdIn(Collection enterpriseIds);

long countByEnterpriseIdInAndUpdateTimeGreaterThan(Collection enterpriseIds, LocalDateTime updateTime);

List findByEnterpriseIdIn(Collection enterpriseIds);

Slice findByEnterpriseIdInAndIdGreaterThanOrderByIdAsc(Collection enterpriseIds, Long id,

Pageable pageable);

Slice findByEnterpriseIdInAndIdGreaterThanAndUpdateTimeGreaterThanOrderByIdAsc(

Collection enterpriseIds, Long id, LocalDateTime updateTime, Pageable pageable);

{{if .HasCode}}

boolean existsByEnterpriseIdAndCode(Long enterpriseId, String code);

Optional findByEnterpriseIdAndCode(Long enterpriseId, String code);

List findByEnterpriseIdAndCodeIn(Long enterpriseId, Collection codes);

List findByEnterpriseIdInAndCodeIn(Collection enterpriseIds, Collection codes);

{{if .HasDelStatus}}

boolean existsByEnterpriseIdAndCodeAndDelStatus(Long enterpriseId, String code, Integer delStatus);

Optional findByEnterpriseIdAndCodeAndDelStatus(Long enterpriseId, String code, Integer delStatus);

List findByEnterpriseIdAndCodeInAndDelStatus(Long enterpriseId, Collection codes, Integer delStatus);

List findByEnterpriseIdInAndCodeInAndDelStatus(Collection enterpriseIds, Collection codes, Integer delStatus);

{{end}}

{{- end -}}

{{if .HasDelStatus}}

@Query("select e from #{#entityName} e where e.delStatus=0")

List findAvailable();

@Query("select e from #{#entityName} e where e.id=:id and e.delStatus=0")

Optional findAvailableById(@Param("id") Long id);

@Query("select e from #{#entityName} e where e.id in (:ids) and e.delStatus=0")

List findAvailableByIdIn(@Param("ids") Collection ids);

@Query("select e from #{#entityName} e where (e.enterpriseId=0 or e.enterpriseId=:enterpriseId) and e.delStatus=0")

List findAvailableByEnterpriseId(@Param("enterpriseId") Long enterpriseId);

@Query("select e from #{#entityName} e where e.enterpriseId in (:enterpriseIds) and e.delStatus=0")

List findAvailableByEnterpriseIdIn(@Param("enterpriseIds") Collection enterpriseIds);

{{end -}}

{{if .HasStatus}}

@Modifying

{{- if .HasDelStatus}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId and e.delStatus=0")

{{else -}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId")

{{- end -}}

int updateStatusByEnterpriseId(@Param("enterpriseId") Long enterpriseId, @Param("status") Integer status,

@Param("updateTime") LocalDateTime updateTime);

@Modifying

{{- if .HasDelStatus}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId in (:enterpriseIds) and e.delStatus=0")

{{else -}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId in (:enterpriseIds)")

{{- end -}}

int updateStatusByEnterpriseIdIn(@Param("enterpriseIds") Collection enterpriseIds,

@Param("status") Integer status, @Param("updateTime") LocalDateTime updateTime);

@Modifying

{{- if .HasDelStatus}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId and e.id in (:ids) and e.delStatus=0")

{{else -}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId and e.id in (:ids)")

{{- end -}}

int updateStatusByEnterpriseIdAndIdIn(@Param("enterpriseId") Long enterpriseId, @Param("ids") Collection ids,

@Param("status") Integer status, @Param("updateTime") LocalDateTime updateTime);

@Modifying

{{- if .HasDelStatus}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.id in (:ids) and e.delStatus=0")

{{else -}}

@Query("update #{#entityName} e set e.status=:status,e.updateTime=:updateTime where e.id in (:ids)")

{{- end -}}

int updateStatusByIdIn(@Param("ids") Collection ids, @Param("status") Integer status,

@Param("updateTime") LocalDateTime updateTime);

{{end}}

{{- if .HasDelStatus}}

@Modifying

@Query("update #{#entityName} e set e.delStatus=:delStatus,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId and e.id=:id")

int updateDelStatusByEnterpriseIdAndId(@Param("enterpriseId") Long enterpriseId,

@Param("id") Long id, @Param("delStatus") Integer delStatus,

@Param("updateTime") LocalDateTime updateTime);

@Modifying

@Query("update #{#entityName} e set e.delStatus=:delStatus,e.updateTime=:updateTime where e.enterpriseId=:enterpriseId and e.id in (:ids)")

int updateDelStatusByEnterpriseIdAndIdIn(@Param("enterpriseId") Long enterpriseId,

@Param("ids") Collection ids, @Param("delStatus") Integer delStatus,

@Param("updateTime") LocalDateTime updateTime);

@Modifying

@Query("update #{#entityName} e set e.delStatus=:delStatus,e.updateTime=:updateTime where e.id=:id")

int updateDelStatusById(@Param("id") Long id, @Param("delStatus") Integer delStatus,

@Param("updateTime") LocalDateTime updateTime);

@Modifying

@Query("update #{#entityName} e set e.delStatus=:delStatus,e.updateTime=:updateTime where e.id in (:ids)")

int updateDelStatusByIdIn(@Param("ids") Collection ids, @Param("delStatus") Integer delStatus,

@Param("updateTime") LocalDateTime updateTime);

{{end}}

{{- end}}

}