SCHISANDRA/schisandra-album-cloud-microservices
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

✨ add face recognition

Browse Source
This commit is contained in:
landaiqing
2025-01-22 10:36:28 +08:00
parent eab806fb9b
commit c6af9a0461
47 changed files with 3621 additions and 454 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
app/aisvc/model/mysql/generate/generate.go Normal file
View File

@@ -0,0 +1,107 @@
package main
import (
"os"
"path/filepath"
"strings"
"gorm.io/driver/mysql"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/gorm"
)
const MySQLDSN = "root:LDQ20020618xxx@tcp(1.95.0.111:3306)/schisandra-cloud-album?charset=utf8mb4&parseTime=True&loc=Local"
func main() {
// 连接数据库
db, err := gorm.Open(mysql.Open(MySQLDSN))
if err != nil {
panic(err)
}
dir, err := os.Getwd()
if err != nil {
panic(err)
}
path := filepath.Join(dir, "app/aisvc/model/mysql/", "query")
// 生成实例
g := gen.NewGenerator(gen.Config{
// 相对执行`go run`时的路径, 会自动创建目录
OutPath: path,
// 生成的文件名，默认gen.go
OutFile: "gen.go",
// 生成DAO代码的包名，默认是：model
ModelPkgPath: "model",
// 是否为DAO包生成单元测试代码，默认：false
WithUnitTest: false,
// WithDefaultQuery 生成默认查询结构体(作为全局变量使用), 即`Q`结构体和其字段(各表模型)
// WithoutContext 生成没有context调用限制的代码供查询
// WithQueryInterface 生成interface形式的查询代码(可导出), 如`Where()`方法返回的就是一个可导出的接口类型
Mode: gen.WithDefaultQuery | gen.WithQueryInterface | gen.WithoutContext,
// 表字段可为 null 值时, 对应结体字段使用指针类型
FieldNullable: false, // generate pointer when field is nullable
// 表字段默认值与模型结构体字段零值不一致的字段, 在插入数据时需要赋值该字段值为零值的, 结构体字段须是指针类型才能成功, 即`FieldCoverable:true`配置下生成的结构体字段.
// 因为在插入时遇到字段为零值的会被GORM赋予默认值. 如字段`age`表默认值为10, 即使你显式设置为0最后也会被GORM设为10提交.
// 如果该字段没有上面提到的插入时赋零值的特殊需要, 则字段为非指针类型使用起来会比较方便.
FieldCoverable: true,
// 模型结构体字段的数字类型的符号表示是否与表字段的一致, `false`指示都用有符号类型
FieldSignable: false,
// 生成 gorm 标签的字段索引属性
FieldWithIndexTag: true,
// 生成 gorm 标签的字段类型属性
FieldWithTypeTag: true,
})
// 设置目标 db
g.UseDB(db)
// 自定义字段的数据类型
// 统一数字类型为int64,兼容protobuf
dataMap := map[string]func(columnType gorm.ColumnType) (dataType string){
"tinyint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"smallint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"mediumint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"bigint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
"int": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
}
// 要先于`ApplyBasic`执行
g.WithDataTypeMap(dataMap)
// 自定义模型结体字段的标签
// 将特定字段名的 json 标签加上`string`属性,即 MarshalJSON 时该字段由数字类型转成字符串类型
jsonField := gen.FieldJSONTagWithNS(func(columnName string) (tagContent string) {
toStringField := `id, `
if strings.Contains(toStringField, columnName) {
return columnName + ",string"
}
return columnName
})
// 将非默认字段名的字段定义为自动时间戳和软删除字段;
// 自动时间戳默认字段名为:`updated_at`、`created_at, 表字段数据类型为: INT 或 DATETIME
// 软删除默认字段名为:`deleted_at`, 表字段数据类型为: DATETIME
idField := gen.FieldGORMTag("id", func(tag field.GormTag) field.GormTag {
return tag.Append("primary_key")
})
autoUpdateTimeField := gen.FieldGORMTag("updated_at", func(tag field.GormTag) field.GormTag {
return tag.Append("autoUpdateTime")
})
autoCreateTimeField := gen.FieldGORMTag("created_at", func(tag field.GormTag) field.GormTag {
return tag.Append("autoCreateTime")
})
softDeleteField := gen.FieldType("delete_at", "gorm.DeletedAt")
versionField := gen.FieldType("version", "optimisticlock.Version")
// 模型自定义选项组
fieldOpts := []gen.ModelOpt{jsonField, idField, autoUpdateTimeField, autoCreateTimeField, softDeleteField, versionField}
// 创建全部模型文件, 并覆盖前面创建的同名模型
model := g.GenerateModel("sca_storage_face", fieldOpts...)
g.ApplyBasic(model)
g.Execute()
}

31
app/aisvc/model/mysql/model/sca_storage_face.gen.go Normal file
View File

@@ -0,0 +1,31 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package model
import (
"time"
"gorm.io/gorm"
)
const TableNameScaStorageFace = "sca_storage_face"
// ScaStorageFace 人脸特征向量表
type ScaStorageFace struct {
ID int64 `gorm:"column:id;type:bigint(20);primaryKey;autoIncrement:true;comment:主键;primary_key" json:"id,string"` // 主键
UserID string `gorm:"column:user_id;type:varchar(50);comment:用户ID" json:"user_id"` // 用户ID
FaceName string `gorm:"column:face_name;type:varchar(255);comment:人脸名称" json:"face_name"` // 人脸名称
FaceVector string `gorm:"column:face_vector;type:json;comment:人脸特征向量" json:"face_vector"` // 人脸特征向量
FaceImagePath string `gorm:"column:face_image_path;type:varchar(255);comment:人脸图像路径" json:"face_image_path"` // 人脸图像路径
FaceType string `gorm:"column:face_type;type:varchar(50);comment:人脸类型标识" json:"face_type"` // 人脸类型标识
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"` // 删除时间
}
// TableName ScaStorageFace's table name
func (*ScaStorageFace) TableName() string {
return TableNameScaStorageFace
}

76
app/aisvc/model/mysql/mysql.go Normal file
View File

@@ -0,0 +1,76 @@
package mysql
import (
"log"
"os"
"schisandra-album-cloud-microservices/app/aisvc/model/mysql/model"
"schisandra-album-cloud-microservices/app/aisvc/model/mysql/query"
"time"
"github.com/asjdf/gorm-cache/cache"
"github.com/asjdf/gorm-cache/config"
"github.com/asjdf/gorm-cache/storage"
"github.com/redis/go-redis/v9"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
func NewMySQL(url string, maxOpenConn int, maxIdleConn int, client *redis.Client) (*gorm.DB, *query.Query) {
db, err := gorm.Open(mysql.Open(url), &gorm.Config{
SkipDefaultTransaction: true,
PrepareStmt: true,
Logger: logger.New(
log.New(os.Stdout, "\r\n", log.LstdFlags),
logger.Config{
SlowThreshold: time.Second, // 慢sql日志
LogLevel: logger.Error, // 级别
Colorful: true, // 颜色
IgnoreRecordNotFoundError: true, // 忽略RecordNotFoundError
ParameterizedQueries: true, // 格式化SQL语句
}),
})
if err != nil {
panic(err)
}
sqlDB, err := db.DB()
if err != nil {
panic(err)
}
sqlDB.SetMaxOpenConns(maxOpenConn)
sqlDB.SetMaxIdleConns(maxIdleConn)
useDB := query.Use(db)
// migrate
Migrate(db)
// cache
gormCache, err := cache.NewGorm2Cache(&config.CacheConfig{
CacheLevel: config.CacheLevelAll,
CacheStorage: storage.NewRedis(&storage.RedisStoreConfig{
KeyPrefix: "cache",
Client: client,
}),
InvalidateWhenUpdate: true, // when you create/update/delete objects, invalidate cache
CacheTTL: 10000, // 5000 ms
CacheMaxItemCnt: 0, // if length of objects retrieved one single time
AsyncWrite: true, // async write to cache
DebugMode: false,
DisableCachePenetrationProtect: true, // disable cache penetration protect
})
if err != nil {
panic(err)
}
err = db.Use(gormCache)
if err != nil {
panic(err)
}
return db, useDB
}
func Migrate(db *gorm.DB) {
err := db.AutoMigrate(
&model.ScaStorageFace{})
if err != nil {
panic(err)
}
}

103
app/aisvc/model/mysql/query/gen.go Normal file
View File

@@ -0,0 +1,103 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"database/sql"
"gorm.io/gorm"
"gorm.io/gen"
"gorm.io/plugin/dbresolver"
)
var (
Q = new(Query)
ScaStorageFace *scaStorageFace
)
func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
ScaStorageFace = &Q.ScaStorageFace
}
func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
return &Query{
db: db,
ScaStorageFace: newScaStorageFace(db, opts...),
}
}
type Query struct {
db *gorm.DB
ScaStorageFace scaStorageFace
}
func (q *Query) Available() bool { return q.db != nil }
func (q *Query) clone(db *gorm.DB) *Query {
return &Query{
db: db,
ScaStorageFace: q.ScaStorageFace.clone(db),
}
}
func (q *Query) ReadDB() *Query {
return q.ReplaceDB(q.db.Clauses(dbresolver.Read))
}
func (q *Query) WriteDB() *Query {
return q.ReplaceDB(q.db.Clauses(dbresolver.Write))
}
func (q *Query) ReplaceDB(db *gorm.DB) *Query {
return &Query{
db: db,
ScaStorageFace: q.ScaStorageFace.replaceDB(db),
}
}
type queryCtx struct {
ScaStorageFace IScaStorageFaceDo
}
func (q *Query) WithContext(ctx context.Context) *queryCtx {
return &queryCtx{
ScaStorageFace: q.ScaStorageFace.WithContext(ctx),
}
}
func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error {
return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)
}
func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx {
tx := q.db.Begin(opts...)
return &QueryTx{Query: q.clone(tx), Error: tx.Error}
}
type QueryTx struct {
*Query
Error error
}
func (q *QueryTx) Commit() error {
return q.db.Commit().Error
}
func (q *QueryTx) Rollback() error {
return q.db.Rollback().Error
}
func (q *QueryTx) SavePoint(name string) error {
return q.db.SavePoint(name).Error
}
func (q *QueryTx) RollbackTo(name string) error {
return q.db.RollbackTo(name).Error
}

413
app/aisvc/model/mysql/query/sca_storage_face.gen.go Normal file
View File

@@ -0,0 +1,413 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"schisandra-album-cloud-microservices/app/aisvc/model/mysql/model"
)
func newScaStorageFace(db *gorm.DB, opts ...gen.DOOption) scaStorageFace {
_scaStorageFace := scaStorageFace{}
_scaStorageFace.scaStorageFaceDo.UseDB(db, opts...)
_scaStorageFace.scaStorageFaceDo.UseModel(&model.ScaStorageFace{})
tableName := _scaStorageFace.scaStorageFaceDo.TableName()
_scaStorageFace.ALL = field.NewAsterisk(tableName)
_scaStorageFace.ID = field.NewInt64(tableName, "id")
_scaStorageFace.UserID = field.NewString(tableName, "user_id")
_scaStorageFace.FaceName = field.NewString(tableName, "face_name")
_scaStorageFace.FaceVector = field.NewString(tableName, "face_vector")
_scaStorageFace.FaceImagePath = field.NewString(tableName, "face_image_path")
_scaStorageFace.FaceType = field.NewString(tableName, "face_type")
_scaStorageFace.CreatedAt = field.NewTime(tableName, "created_at")
_scaStorageFace.UpdatedAt = field.NewTime(tableName, "updated_at")
_scaStorageFace.DeletedAt = field.NewField(tableName, "deleted_at")
_scaStorageFace.fillFieldMap()
return _scaStorageFace
}
// scaStorageFace 人脸特征向量表
type scaStorageFace struct {
scaStorageFaceDo
ALL field.Asterisk
ID field.Int64 // 主键
UserID field.String // 用户ID
FaceName field.String // 人脸名称
FaceVector field.String // 人脸特征向量
FaceImagePath field.String // 人脸图像路径
FaceType field.String // 人脸类型标识
CreatedAt field.Time // 创建时间
UpdatedAt field.Time // 更新时间
DeletedAt field.Field // 删除时间
fieldMap map[string]field.Expr
}
func (s scaStorageFace) Table(newTableName string) *scaStorageFace {
s.scaStorageFaceDo.UseTable(newTableName)
return s.updateTableName(newTableName)
}
func (s scaStorageFace) As(alias string) *scaStorageFace {
s.scaStorageFaceDo.DO = *(s.scaStorageFaceDo.As(alias).(*gen.DO))
return s.updateTableName(alias)
}
func (s *scaStorageFace) updateTableName(table string) *scaStorageFace {
s.ALL = field.NewAsterisk(table)
s.ID = field.NewInt64(table, "id")
s.UserID = field.NewString(table, "user_id")
s.FaceName = field.NewString(table, "face_name")
s.FaceVector = field.NewString(table, "face_vector")
s.FaceImagePath = field.NewString(table, "face_image_path")
s.FaceType = field.NewString(table, "face_type")
s.CreatedAt = field.NewTime(table, "created_at")
s.UpdatedAt = field.NewTime(table, "updated_at")
s.DeletedAt = field.NewField(table, "deleted_at")
s.fillFieldMap()
return s
}
func (s *scaStorageFace) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := s.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (s *scaStorageFace) fillFieldMap() {
s.fieldMap = make(map[string]field.Expr, 9)
s.fieldMap["id"] = s.ID
s.fieldMap["user_id"] = s.UserID
s.fieldMap["face_name"] = s.FaceName
s.fieldMap["face_vector"] = s.FaceVector
s.fieldMap["face_image_path"] = s.FaceImagePath
s.fieldMap["face_type"] = s.FaceType
s.fieldMap["created_at"] = s.CreatedAt
s.fieldMap["updated_at"] = s.UpdatedAt
s.fieldMap["deleted_at"] = s.DeletedAt
}
func (s scaStorageFace) clone(db *gorm.DB) scaStorageFace {
s.scaStorageFaceDo.ReplaceConnPool(db.Statement.ConnPool)
return s
}
func (s scaStorageFace) replaceDB(db *gorm.DB) scaStorageFace {
s.scaStorageFaceDo.ReplaceDB(db)
return s
}
type scaStorageFaceDo struct{ gen.DO }
type IScaStorageFaceDo interface {
gen.SubQuery
Debug() IScaStorageFaceDo
WithContext(ctx context.Context) IScaStorageFaceDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IScaStorageFaceDo
WriteDB() IScaStorageFaceDo
As(alias string) gen.Dao
Session(config *gorm.Session) IScaStorageFaceDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IScaStorageFaceDo
Not(conds ...gen.Condition) IScaStorageFaceDo
Or(conds ...gen.Condition) IScaStorageFaceDo
Select(conds ...field.Expr) IScaStorageFaceDo
Where(conds ...gen.Condition) IScaStorageFaceDo
Order(conds ...field.Expr) IScaStorageFaceDo
Distinct(cols ...field.Expr) IScaStorageFaceDo
Omit(cols ...field.Expr) IScaStorageFaceDo
Join(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo
LeftJoin(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo
RightJoin(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo
Group(cols ...field.Expr) IScaStorageFaceDo
Having(conds ...gen.Condition) IScaStorageFaceDo
Limit(limit int) IScaStorageFaceDo
Offset(offset int) IScaStorageFaceDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IScaStorageFaceDo
Unscoped() IScaStorageFaceDo
Create(values ...*model.ScaStorageFace) error
CreateInBatches(values []*model.ScaStorageFace, batchSize int) error
Save(values ...*model.ScaStorageFace) error
First() (*model.ScaStorageFace, error)
Take() (*model.ScaStorageFace, error)
Last() (*model.ScaStorageFace, error)
Find() ([]*model.ScaStorageFace, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaStorageFace, err error)
FindInBatches(result *[]*model.ScaStorageFace, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.ScaStorageFace) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IScaStorageFaceDo
Assign(attrs ...field.AssignExpr) IScaStorageFaceDo
Joins(fields ...field.RelationField) IScaStorageFaceDo
Preload(fields ...field.RelationField) IScaStorageFaceDo
FirstOrInit() (*model.ScaStorageFace, error)
FirstOrCreate() (*model.ScaStorageFace, error)
FindByPage(offset int, limit int) (result []*model.ScaStorageFace, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IScaStorageFaceDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (s scaStorageFaceDo) Debug() IScaStorageFaceDo {
return s.withDO(s.DO.Debug())
}
func (s scaStorageFaceDo) WithContext(ctx context.Context) IScaStorageFaceDo {
return s.withDO(s.DO.WithContext(ctx))
}
func (s scaStorageFaceDo) ReadDB() IScaStorageFaceDo {
return s.Clauses(dbresolver.Read)
}
func (s scaStorageFaceDo) WriteDB() IScaStorageFaceDo {
return s.Clauses(dbresolver.Write)
}
func (s scaStorageFaceDo) Session(config *gorm.Session) IScaStorageFaceDo {
return s.withDO(s.DO.Session(config))
}
func (s scaStorageFaceDo) Clauses(conds ...clause.Expression) IScaStorageFaceDo {
return s.withDO(s.DO.Clauses(conds...))
}
func (s scaStorageFaceDo) Returning(value interface{}, columns ...string) IScaStorageFaceDo {
return s.withDO(s.DO.Returning(value, columns...))
}
func (s scaStorageFaceDo) Not(conds ...gen.Condition) IScaStorageFaceDo {
return s.withDO(s.DO.Not(conds...))
}
func (s scaStorageFaceDo) Or(conds ...gen.Condition) IScaStorageFaceDo {
return s.withDO(s.DO.Or(conds...))
}
func (s scaStorageFaceDo) Select(conds ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Select(conds...))
}
func (s scaStorageFaceDo) Where(conds ...gen.Condition) IScaStorageFaceDo {
return s.withDO(s.DO.Where(conds...))
}
func (s scaStorageFaceDo) Order(conds ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Order(conds...))
}
func (s scaStorageFaceDo) Distinct(cols ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Distinct(cols...))
}
func (s scaStorageFaceDo) Omit(cols ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Omit(cols...))
}
func (s scaStorageFaceDo) Join(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Join(table, on...))
}
func (s scaStorageFaceDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.LeftJoin(table, on...))
}
func (s scaStorageFaceDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.RightJoin(table, on...))
}
func (s scaStorageFaceDo) Group(cols ...field.Expr) IScaStorageFaceDo {
return s.withDO(s.DO.Group(cols...))
}
func (s scaStorageFaceDo) Having(conds ...gen.Condition) IScaStorageFaceDo {
return s.withDO(s.DO.Having(conds...))
}
func (s scaStorageFaceDo) Limit(limit int) IScaStorageFaceDo {
return s.withDO(s.DO.Limit(limit))
}
func (s scaStorageFaceDo) Offset(offset int) IScaStorageFaceDo {
return s.withDO(s.DO.Offset(offset))
}
func (s scaStorageFaceDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaStorageFaceDo {
return s.withDO(s.DO.Scopes(funcs...))
}
func (s scaStorageFaceDo) Unscoped() IScaStorageFaceDo {
return s.withDO(s.DO.Unscoped())
}
func (s scaStorageFaceDo) Create(values ...*model.ScaStorageFace) error {
if len(values) == 0 {
return nil
}
return s.DO.Create(values)
}
func (s scaStorageFaceDo) CreateInBatches(values []*model.ScaStorageFace, batchSize int) error {
return s.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (s scaStorageFaceDo) Save(values ...*model.ScaStorageFace) error {
if len(values) == 0 {
return nil
}
return s.DO.Save(values)
}
func (s scaStorageFaceDo) First() (*model.ScaStorageFace, error) {
if result, err := s.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.ScaStorageFace), nil
}
}
func (s scaStorageFaceDo) Take() (*model.ScaStorageFace, error) {
if result, err := s.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.ScaStorageFace), nil
}
}
func (s scaStorageFaceDo) Last() (*model.ScaStorageFace, error) {
if result, err := s.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.ScaStorageFace), nil
}
}
func (s scaStorageFaceDo) Find() ([]*model.ScaStorageFace, error) {
result, err := s.DO.Find()
return result.([]*model.ScaStorageFace), err
}
func (s scaStorageFaceDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaStorageFace, err error) {
buf := make([]*model.ScaStorageFace, 0, batchSize)
err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (s scaStorageFaceDo) FindInBatches(result *[]*model.ScaStorageFace, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return s.DO.FindInBatches(result, batchSize, fc)
}
func (s scaStorageFaceDo) Attrs(attrs ...field.AssignExpr) IScaStorageFaceDo {
return s.withDO(s.DO.Attrs(attrs...))
}
func (s scaStorageFaceDo) Assign(attrs ...field.AssignExpr) IScaStorageFaceDo {
return s.withDO(s.DO.Assign(attrs...))
}
func (s scaStorageFaceDo) Joins(fields ...field.RelationField) IScaStorageFaceDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Joins(_f))
}
return &s
}
func (s scaStorageFaceDo) Preload(fields ...field.RelationField) IScaStorageFaceDo {
for _, _f := range fields {
s = *s.withDO(s.DO.Preload(_f))
}
return &s
}
func (s scaStorageFaceDo) FirstOrInit() (*model.ScaStorageFace, error) {
if result, err := s.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.ScaStorageFace), nil
}
}
func (s scaStorageFaceDo) FirstOrCreate() (*model.ScaStorageFace, error) {
if result, err := s.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.ScaStorageFace), nil
}
}
func (s scaStorageFaceDo) FindByPage(offset int, limit int) (result []*model.ScaStorageFace, count int64, err error) {
result, err = s.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = s.Offset(-1).Limit(-1).Count()
return
}
func (s scaStorageFaceDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = s.Count()
if err != nil {
return
}
err = s.Offset(offset).Limit(limit).Scan(result)
return
}
func (s scaStorageFaceDo) Scan(result interface{}) (err error) {
return s.DO.Scan(result)
}
func (s scaStorageFaceDo) Delete(models ...*model.ScaStorageFace) (result gen.ResultInfo, err error) {
return s.DO.Delete(models)
}
func (s *scaStorageFaceDo) withDO(do gen.Dao) *scaStorageFaceDo {
s.DO = *do.(*gen.DO)
return s
}