pkg

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 15, 2026 License: MIT Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var OutputTemplate_ch = parseTemplateOrPanic("output_template_ch", `
///////////////////////////////////////////////////////////
// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
//        ANY CHANGES DONE HERE WILL BE LOST             //
///////////////////////////////////////////////////////////

package {{.PkgName}}

import (
	"time"

	"gitee.com/carlmax_my/go-clickhouse"
	{{.RefStructPkgPath}}

	"github.com/pkg/errors"
)

var CollName = "{{.PkgName}}"
var Columns = []string{
{{range .OptionFields}}"{{.ColumnName}}",
{{end}}
}

func NewModel() *{{.RefStructName}} {
	return new({{.RefStructName}})
}

func NewQueryBuilder() *{{.QueryBuilderName}} {
	return new({{.QueryBuilderName}})
}

func Create(col *Coll, t *{{.RefStructName}}) (id {{.PrimaryKeyType}}, err error) {
	if err = col.InsertOne(t); err != nil {
		return {{.PrimaryKeyDef}}, errors.Wrap(err, "create err")
	}
	return t.Id, nil
}

// region query builder
type {{.QueryBuilderName}} struct {
	clickhouse.ModelQueryBuilder[{{.RefStructName}}]
}

{{$queryBuilderName := .QueryBuilderName}}
{{range .OptionFields}}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}(p clickhouse.Predicate, value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, p)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}Eq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.EqualPredicate)
	return qb
}

{{if eq .FieldType "time.Time"}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.SmallerThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.SmallerThanOrEqualPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.GreaterThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.GreaterThanOrEqualPredicate)
	return qb
}

{{else}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NEq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.NotEqualPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}In(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.InPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NotIn(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, clickhouse.NotInPredicate)
	return qb
}

{{end}}

func (qb *{{$queryBuilderName}}) OrderBy{{call $.Helpers.Titlize .FieldName}}(asc bool) *{{$queryBuilderName}} {
	qb.AddOrder("{{.ColumnName}}", asc)
	return qb
}

{{end}}

// endregion query builder

// region coll
type Coll struct {
	clickhouse.Collection[{{.RefStructName}}]
}

func NewColl(db clickhouse.ClickhouseDB) *Coll {
	c := &Coll{}
	c.Collection = *clickhouse.NewTable[{{.RefStructName}}](db, clickhouse.SetTableName(CollName), clickhouse.SetTableColumns(Columns))
	return c
}

{{$RefStructName := .RefStructName}}
{{range .OptionFields}}

{{if not .NoQuery}}
func (c *Coll) FindBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}) (*{{$RefStructName}}, error) {
	return c.ByAttr("{{.ColumnName}}", value)
}

func (c *Coll) FindAllBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}) ([]{{$RefStructName}}, error) {
	return c.AllByAttr("{{.ColumnName}}", value)
}

func (c *Coll) FindAllPagedBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}, page int64, pageSize int64) ([]{{$RefStructName}}, error) {
	return c.FindAllPagedByAttr("{{.ColumnName}}", value, page, pageSize)
}
{{end}}
{{end}}
// endregion coll
`)
View Source 
var OutputTemplate_mongo = parseTemplateOrPanic("output_template_mongo", `
///////////////////////////////////////////////////////////
// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
//        ANY CHANGES DONE HERE WILL BE LOST             //
///////////////////////////////////////////////////////////

package {{.PkgName}}

import (
	"time"

	"gitee.com/carlmax_my/go-mongo"
	{{.RefStructPkgPath}}

	"github.com/pkg/errors"
	"go.mongodb.org/mongo-driver/bson"
)

var CollName = "{{.PkgName}}"

func NewModel() *{{.RefStructName}} {
	return new({{.RefStructName}})
}

func NewQueryBuilder() *{{.QueryBuilderName}} {
	return new({{.QueryBuilderName}})
}

func Create(col *Coll, t *{{.RefStructName}}) (id {{.PrimaryKeyType}}, err error) {
	if err = col.InsertOne(t); err != nil {
		return {{.PrimaryKeyDef}}, errors.Wrap(err, "create err")
	}
	return t.Id, nil
}

// region query builder
type {{.QueryBuilderName}} struct {
	mongo.ModelQueryBuilder[{{.RefStructName}}]
}

{{$queryBuilderName := .QueryBuilderName}}
{{range .OptionFields}}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}(p mongo.Predicate, value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, p)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}Eq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.EqualPredicate)
	return qb
}

{{if eq .FieldType "time.Time"}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.SmallerThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.SmallerThanOrEqualPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.GreaterThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.GreaterThanOrEqualPredicate)
	return qb
}
{{else}}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NEq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.NotEqualPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}In(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.InPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NotIn(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mongo.NotInPredicate)
	return qb
}
{{end}}

func (qb *{{$queryBuilderName}}) OrderBy{{call $.Helpers.Titlize .FieldName}}(asc bool) *{{$queryBuilderName}} {
	qb.AddOrder("{{.ColumnName}}", asc)
	return qb
}

{{end}}
// endregion query builder

// region coll
type Coll struct {
	mongo.Collection[{{.RefStructName}}]
}

func NewColl(db mongo.MongoDB) *Coll {
	c := &Coll{}
	c.Collection = *mongo.NewColl[{{.RefStructName}}](db, mongo.SetColl(CollName))
	return c
}

func (c *Coll) PatchById(id string, doc *{{.RefStructName}}Patch) error {
	return c.UpdateOneByIdStr(&id, doc)
}

func (c *Coll) Patch(filter *bson.M, doc *{{.RefStructName}}Patch) error {
	return c.UpdateOneByFilter(filter, doc)
}

{{$RefStructName := .RefStructName}}
{{range .OptionFields}}

{{if not .NoQuery}}
func (c *Coll) FindBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}) (*{{$RefStructName}}, error) {
	filter := &bson.M{"{{.ColumnName}}": value}
	return c.FindOneByFilter(filter)
}

func (c *Coll) FindAllBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}) ([]{{$RefStructName}}, error) {
	filter := &bson.M{"{{.ColumnName}}": value}
	return c.FindAllByFilter(filter)
}

func (c *Coll) FindAllPagedBy{{call $.Helpers.Titlize .FieldName}}(value {{.FieldType}}, page int64, pageSize int64) ([]{{$RefStructName}}, error) {
	filter := &bson.M{"{{.ColumnName}}": value}
	return c.FindAllPagedByFilter(filter, page, pageSize)
}
{{end}}

{{if .CanPatch}}
{{if .IsAny}}
func (c *Coll) Patch{{call $.Helpers.Titlize .FieldName}}ById(id string, value {{.FieldType}}) error {
	doc := new({{$RefStructName}}Patch)
	doc.{{call $.Helpers.Titlize .FieldName}} = value
	return c.UpdateOneByIdStr(&id, doc)
}

func (c *Coll) Patch{{call $.Helpers.Titlize .FieldName}}(filter *bson.M, value {{.FieldType}}) error {
	doc := new({{$RefStructName}}Patch)
	doc.{{call $.Helpers.Titlize .FieldName}} = value
	return c.UpdateOneByFilter(filter, doc)
}
{{else}}
func (c *Coll) Patch{{call $.Helpers.Titlize .FieldName}}ById(id string, value *{{.FieldType}}) error {
	doc := new({{$RefStructName}}Patch)
	doc.{{call $.Helpers.Titlize .FieldName}} = value
	return c.UpdateOneByIdStr(&id, doc)
}

func (c *Coll) Patch{{call $.Helpers.Titlize .FieldName}}(filter *bson.M, value *{{.FieldType}}) error {
	doc := new({{$RefStructName}}Patch)
	doc.{{call $.Helpers.Titlize .FieldName}} = value
	return c.UpdateOneByFilter(filter, doc)
}
{{end}}
{{end}}

{{end}}
// endregion coll
`)
View Source 
var OutputTemplate_mysql = parseTemplateOrPanic("output_template_mysql", `
///////////////////////////////////////////////////////////
// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
//        ANY CHANGES DONE HERE WILL BE LOST             //
///////////////////////////////////////////////////////////

package {{.PkgName}}

import (
	"time"

	{{.RefStructPkgPath}}

	"gitee.com/carlmax_my/go-mysql"
	"github.com/pkg/errors"
	"gorm.io/gorm"
)

func NewModel() *{{.RefStructName}} {
	return new({{.RefStructName}})
}

func NewQueryBuilder() *{{.QueryBuilderName}} {
	return new({{.QueryBuilderName}})
}

func Create(db *gorm.DB, t *{{.RefStructName}}) (id {{.PrimaryKeyType}}, err error) {
	if err = db.Create(t).Error; err != nil {
		return {{.PrimaryKeyDef}}, errors.Wrap(err, "create err")
	}
	return t.Id, nil
}

type {{.QueryBuilderName}} struct {
	mysql.ModelQueryBuilder[{{.RefStructName}}]
}

{{$queryBuilderName := .QueryBuilderName}}
{{range .OptionFields}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}(p mysql.Predicate, value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, p)
	return qb
}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}Eq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.EqualPredicate)
	return qb
}

{{if eq .FieldType "time.Time"}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.SmallerThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}LTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.SmallerThanOrEqualPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GT(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.GreaterThanPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}GTE(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.GreaterThanOrEqualPredicate)
	return qb
}
{{else}}
func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}In(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.InPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NotIn(value []{{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.NotInPredicate)
	return qb
}

func (qb *{{$queryBuilderName}}) Where{{call $.Helpers.Titlize .FieldName}}NEq(value {{.FieldType}}) *{{$queryBuilderName}} {
	qb.AddWhere("{{.ColumnName}}", value, mysql.NotEqualPredicate)
	return qb
}
{{end}}

func (qb *{{$queryBuilderName}}) OrderBy{{call $.Helpers.Titlize .FieldName}}(asc bool) *{{$queryBuilderName}} {
	qb.AddOrder("{{.ColumnName}}", asc)
	return qb
}
{{end}}
`)

Functions

func IsExists 

func IsExists(path string) (os.FileInfo, bool)

IsExists whether file exist

func LoadEnv 

func LoadEnv()

func Run 

func Run(db string, modelFileFolder string, modelPkgName string)

db = 1, only mongo(所有表格) db = 2, only ch(带标记的表格) db = ..., mysql(所有表格)

没有clickhouse标记的表格，db=2, return, db不是2,正常继续执行 有clickhouse标记的表格，db=2, 正常继续执行, db不是2,也正常继续执行

func RunByArgs 

func RunByArgs(cmd string, modelFileFolder string, modelPkgName string)

func SQLColumnToCapitalizeStyle 

func SQLColumnToCapitalizeStyle(in string) (ret string)

func SQLColumnToHumpStyle 

func SQLColumnToHumpStyle(in string) (ret string)

SQLColumnToHumpStyle sql转换成驼峰模式

Types

type Generator 

type Generator struct {
	// contains filtered or unexported fields
}

The Generator is the one responsible for generating the code, adding the imports, formatting, and writing it to the file.

func NewGenerator 

func NewGenerator(inputFolder, outputFolder, pkgName string, template *template.Template, modelFileFolder string, modelPkgName string) *Generator

NewGenerator function creates an instance of the generator given the name of the output file as an argument.

func (*Generator) Flush 

func (g *Generator) Flush() error

Flush function writes the output to the output file.

func (*Generator) Format 

func (g *Generator) Format() *Generator

Format function formats the output of the generation.

func (*Generator) Generate 

func (g *Generator) Generate() *Generator

Generate executes the template and store it in an internal buffer.

func (*Generator) ParserAST 

func (g *Generator) ParserAST(p *Parser, structs []string) (ret *Generator)

ParserAST parse by go file

type ImportPkg 

type ImportPkg struct {
	Pkg string
}

type Parser 

type Parser struct {
	// contains filtered or unexported fields
}

The Parser is used to parse a directory and expose information about the structs defined in the files of this directory.

func NewParser 

func NewParser(dir string) *Parser

NewParser create a new parser instance.

func (*Parser) Parse 

func (p *Parser) Parse() (ret []structConfig)

Parse should be called before any type querying for the parser. It takes the directory to be parsed and extracts all the structs defined in this directory.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.