693 lines
22 KiB
Go
693 lines
22 KiB
Go
// Code generated by ent, DO NOT EDIT.
|
|
|
|
package ent
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"reflect"
|
|
|
|
"code.icod.de/dalu/ka/ent/migrate"
|
|
"github.com/google/uuid"
|
|
|
|
"code.icod.de/dalu/ka/ent/category"
|
|
"code.icod.de/dalu/ka/ent/post"
|
|
"code.icod.de/dalu/ka/ent/profile"
|
|
"entgo.io/ent"
|
|
"entgo.io/ent/dialect"
|
|
"entgo.io/ent/dialect/sql"
|
|
"entgo.io/ent/dialect/sql/sqlgraph"
|
|
)
|
|
|
|
// Client is the client that holds all ent builders.
|
|
type Client struct {
|
|
config
|
|
// Schema is the client for creating, migrating and dropping schema.
|
|
Schema *migrate.Schema
|
|
// Category is the client for interacting with the Category builders.
|
|
Category *CategoryClient
|
|
// Post is the client for interacting with the Post builders.
|
|
Post *PostClient
|
|
// Profile is the client for interacting with the Profile builders.
|
|
Profile *ProfileClient
|
|
}
|
|
|
|
// NewClient creates a new client configured with the given options.
|
|
func NewClient(opts ...Option) *Client {
|
|
client := &Client{config: newConfig(opts...)}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
func (c *Client) init() {
|
|
c.Schema = migrate.NewSchema(c.driver)
|
|
c.Category = NewCategoryClient(c.config)
|
|
c.Post = NewPostClient(c.config)
|
|
c.Profile = NewProfileClient(c.config)
|
|
}
|
|
|
|
type (
|
|
// config is the configuration for the client and its builder.
|
|
config struct {
|
|
// driver used for executing database requests.
|
|
driver dialect.Driver
|
|
// debug enable a debug logging.
|
|
debug bool
|
|
// log used for logging on debug mode.
|
|
log func(...any)
|
|
// hooks to execute on mutations.
|
|
hooks *hooks
|
|
// interceptors to execute on queries.
|
|
inters *inters
|
|
}
|
|
// Option function to configure the client.
|
|
Option func(*config)
|
|
)
|
|
|
|
// newConfig creates a new config for the client.
|
|
func newConfig(opts ...Option) config {
|
|
cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
|
|
cfg.options(opts...)
|
|
return cfg
|
|
}
|
|
|
|
// options applies the options on the config object.
|
|
func (c *config) options(opts ...Option) {
|
|
for _, opt := range opts {
|
|
opt(c)
|
|
}
|
|
if c.debug {
|
|
c.driver = dialect.Debug(c.driver, c.log)
|
|
}
|
|
}
|
|
|
|
// Debug enables debug logging on the ent.Driver.
|
|
func Debug() Option {
|
|
return func(c *config) {
|
|
c.debug = true
|
|
}
|
|
}
|
|
|
|
// Log sets the logging function for debug mode.
|
|
func Log(fn func(...any)) Option {
|
|
return func(c *config) {
|
|
c.log = fn
|
|
}
|
|
}
|
|
|
|
// Driver configures the client driver.
|
|
func Driver(driver dialect.Driver) Option {
|
|
return func(c *config) {
|
|
c.driver = driver
|
|
}
|
|
}
|
|
|
|
// Open opens a database/sql.DB specified by the driver name and
|
|
// the data source name, and returns a new client attached to it.
|
|
// Optional parameters can be added for configuring the client.
|
|
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
|
|
switch driverName {
|
|
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
|
|
drv, err := sql.Open(driverName, dataSourceName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return NewClient(append(options, Driver(drv))...), nil
|
|
default:
|
|
return nil, fmt.Errorf("unsupported driver: %q", driverName)
|
|
}
|
|
}
|
|
|
|
// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
|
|
var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")
|
|
|
|
// Tx returns a new transactional client. The provided context
|
|
// is used until the transaction is committed or rolled back.
|
|
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
|
|
if _, ok := c.driver.(*txDriver); ok {
|
|
return nil, ErrTxStarted
|
|
}
|
|
tx, err := newTx(ctx, c.driver)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ent: starting a transaction: %w", err)
|
|
}
|
|
cfg := c.config
|
|
cfg.driver = tx
|
|
return &Tx{
|
|
ctx: ctx,
|
|
config: cfg,
|
|
Category: NewCategoryClient(cfg),
|
|
Post: NewPostClient(cfg),
|
|
Profile: NewProfileClient(cfg),
|
|
}, nil
|
|
}
|
|
|
|
// BeginTx returns a transactional client with specified options.
|
|
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
|
|
if _, ok := c.driver.(*txDriver); ok {
|
|
return nil, errors.New("ent: cannot start a transaction within a transaction")
|
|
}
|
|
tx, err := c.driver.(interface {
|
|
BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
|
|
}).BeginTx(ctx, opts)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ent: starting a transaction: %w", err)
|
|
}
|
|
cfg := c.config
|
|
cfg.driver = &txDriver{tx: tx, drv: c.driver}
|
|
return &Tx{
|
|
ctx: ctx,
|
|
config: cfg,
|
|
Category: NewCategoryClient(cfg),
|
|
Post: NewPostClient(cfg),
|
|
Profile: NewProfileClient(cfg),
|
|
}, nil
|
|
}
|
|
|
|
// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
|
|
//
|
|
// client.Debug().
|
|
// Category.
|
|
// Query().
|
|
// Count(ctx)
|
|
func (c *Client) Debug() *Client {
|
|
if c.debug {
|
|
return c
|
|
}
|
|
cfg := c.config
|
|
cfg.driver = dialect.Debug(c.driver, c.log)
|
|
client := &Client{config: cfg}
|
|
client.init()
|
|
return client
|
|
}
|
|
|
|
// Close closes the database connection and prevents new queries from starting.
|
|
func (c *Client) Close() error {
|
|
return c.driver.Close()
|
|
}
|
|
|
|
// Use adds the mutation hooks to all the entity clients.
|
|
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
|
|
func (c *Client) Use(hooks ...Hook) {
|
|
c.Category.Use(hooks...)
|
|
c.Post.Use(hooks...)
|
|
c.Profile.Use(hooks...)
|
|
}
|
|
|
|
// Intercept adds the query interceptors to all the entity clients.
|
|
// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
|
|
func (c *Client) Intercept(interceptors ...Interceptor) {
|
|
c.Category.Intercept(interceptors...)
|
|
c.Post.Intercept(interceptors...)
|
|
c.Profile.Intercept(interceptors...)
|
|
}
|
|
|
|
// Mutate implements the ent.Mutator interface.
|
|
func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
|
|
switch m := m.(type) {
|
|
case *CategoryMutation:
|
|
return c.Category.mutate(ctx, m)
|
|
case *PostMutation:
|
|
return c.Post.mutate(ctx, m)
|
|
case *ProfileMutation:
|
|
return c.Profile.mutate(ctx, m)
|
|
default:
|
|
return nil, fmt.Errorf("ent: unknown mutation type %T", m)
|
|
}
|
|
}
|
|
|
|
// CategoryClient is a client for the Category schema.
|
|
type CategoryClient struct {
|
|
config
|
|
}
|
|
|
|
// NewCategoryClient returns a client for the Category from the given config.
|
|
func NewCategoryClient(c config) *CategoryClient {
|
|
return &CategoryClient{config: c}
|
|
}
|
|
|
|
// Use adds a list of mutation hooks to the hooks stack.
|
|
// A call to `Use(f, g, h)` equals to `category.Hooks(f(g(h())))`.
|
|
func (c *CategoryClient) Use(hooks ...Hook) {
|
|
c.hooks.Category = append(c.hooks.Category, hooks...)
|
|
}
|
|
|
|
// Intercept adds a list of query interceptors to the interceptors stack.
|
|
// A call to `Intercept(f, g, h)` equals to `category.Intercept(f(g(h())))`.
|
|
func (c *CategoryClient) Intercept(interceptors ...Interceptor) {
|
|
c.inters.Category = append(c.inters.Category, interceptors...)
|
|
}
|
|
|
|
// Create returns a builder for creating a Category entity.
|
|
func (c *CategoryClient) Create() *CategoryCreate {
|
|
mutation := newCategoryMutation(c.config, OpCreate)
|
|
return &CategoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// CreateBulk returns a builder for creating a bulk of Category entities.
|
|
func (c *CategoryClient) CreateBulk(builders ...*CategoryCreate) *CategoryCreateBulk {
|
|
return &CategoryCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
|
|
// a builder and applies setFunc on it.
|
|
func (c *CategoryClient) MapCreateBulk(slice any, setFunc func(*CategoryCreate, int)) *CategoryCreateBulk {
|
|
rv := reflect.ValueOf(slice)
|
|
if rv.Kind() != reflect.Slice {
|
|
return &CategoryCreateBulk{err: fmt.Errorf("calling to CategoryClient.MapCreateBulk with wrong type %T, need slice", slice)}
|
|
}
|
|
builders := make([]*CategoryCreate, rv.Len())
|
|
for i := 0; i < rv.Len(); i++ {
|
|
builders[i] = c.Create()
|
|
setFunc(builders[i], i)
|
|
}
|
|
return &CategoryCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// Update returns an update builder for Category.
|
|
func (c *CategoryClient) Update() *CategoryUpdate {
|
|
mutation := newCategoryMutation(c.config, OpUpdate)
|
|
return &CategoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOne returns an update builder for the given entity.
|
|
func (c *CategoryClient) UpdateOne(ca *Category) *CategoryUpdateOne {
|
|
mutation := newCategoryMutation(c.config, OpUpdateOne, withCategory(ca))
|
|
return &CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOneID returns an update builder for the given id.
|
|
func (c *CategoryClient) UpdateOneID(id uuid.UUID) *CategoryUpdateOne {
|
|
mutation := newCategoryMutation(c.config, OpUpdateOne, withCategoryID(id))
|
|
return &CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// Delete returns a delete builder for Category.
|
|
func (c *CategoryClient) Delete() *CategoryDelete {
|
|
mutation := newCategoryMutation(c.config, OpDelete)
|
|
return &CategoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// DeleteOne returns a builder for deleting the given entity.
|
|
func (c *CategoryClient) DeleteOne(ca *Category) *CategoryDeleteOne {
|
|
return c.DeleteOneID(ca.ID)
|
|
}
|
|
|
|
// DeleteOneID returns a builder for deleting the given entity by its id.
|
|
func (c *CategoryClient) DeleteOneID(id uuid.UUID) *CategoryDeleteOne {
|
|
builder := c.Delete().Where(category.ID(id))
|
|
builder.mutation.id = &id
|
|
builder.mutation.op = OpDeleteOne
|
|
return &CategoryDeleteOne{builder}
|
|
}
|
|
|
|
// Query returns a query builder for Category.
|
|
func (c *CategoryClient) Query() *CategoryQuery {
|
|
return &CategoryQuery{
|
|
config: c.config,
|
|
ctx: &QueryContext{Type: TypeCategory},
|
|
inters: c.Interceptors(),
|
|
}
|
|
}
|
|
|
|
// Get returns a Category entity by its id.
|
|
func (c *CategoryClient) Get(ctx context.Context, id uuid.UUID) (*Category, error) {
|
|
return c.Query().Where(category.ID(id)).Only(ctx)
|
|
}
|
|
|
|
// GetX is like Get, but panics if an error occurs.
|
|
func (c *CategoryClient) GetX(ctx context.Context, id uuid.UUID) *Category {
|
|
obj, err := c.Get(ctx, id)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// QueryPosts queries the posts edge of a Category.
|
|
func (c *CategoryClient) QueryPosts(ca *Category) *PostQuery {
|
|
query := (&PostClient{config: c.config}).Query()
|
|
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
|
|
id := ca.ID
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(category.Table, category.FieldID, id),
|
|
sqlgraph.To(post.Table, post.FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, category.PostsTable, category.PostsColumn),
|
|
)
|
|
fromV = sqlgraph.Neighbors(ca.driver.Dialect(), step)
|
|
return fromV, nil
|
|
}
|
|
return query
|
|
}
|
|
|
|
// Hooks returns the client hooks.
|
|
func (c *CategoryClient) Hooks() []Hook {
|
|
return c.hooks.Category
|
|
}
|
|
|
|
// Interceptors returns the client interceptors.
|
|
func (c *CategoryClient) Interceptors() []Interceptor {
|
|
return c.inters.Category
|
|
}
|
|
|
|
func (c *CategoryClient) mutate(ctx context.Context, m *CategoryMutation) (Value, error) {
|
|
switch m.Op() {
|
|
case OpCreate:
|
|
return (&CategoryCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdate:
|
|
return (&CategoryUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdateOne:
|
|
return (&CategoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpDelete, OpDeleteOne:
|
|
return (&CategoryDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("ent: unknown Category mutation op: %q", m.Op())
|
|
}
|
|
}
|
|
|
|
// PostClient is a client for the Post schema.
|
|
type PostClient struct {
|
|
config
|
|
}
|
|
|
|
// NewPostClient returns a client for the Post from the given config.
|
|
func NewPostClient(c config) *PostClient {
|
|
return &PostClient{config: c}
|
|
}
|
|
|
|
// Use adds a list of mutation hooks to the hooks stack.
|
|
// A call to `Use(f, g, h)` equals to `post.Hooks(f(g(h())))`.
|
|
func (c *PostClient) Use(hooks ...Hook) {
|
|
c.hooks.Post = append(c.hooks.Post, hooks...)
|
|
}
|
|
|
|
// Intercept adds a list of query interceptors to the interceptors stack.
|
|
// A call to `Intercept(f, g, h)` equals to `post.Intercept(f(g(h())))`.
|
|
func (c *PostClient) Intercept(interceptors ...Interceptor) {
|
|
c.inters.Post = append(c.inters.Post, interceptors...)
|
|
}
|
|
|
|
// Create returns a builder for creating a Post entity.
|
|
func (c *PostClient) Create() *PostCreate {
|
|
mutation := newPostMutation(c.config, OpCreate)
|
|
return &PostCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// CreateBulk returns a builder for creating a bulk of Post entities.
|
|
func (c *PostClient) CreateBulk(builders ...*PostCreate) *PostCreateBulk {
|
|
return &PostCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
|
|
// a builder and applies setFunc on it.
|
|
func (c *PostClient) MapCreateBulk(slice any, setFunc func(*PostCreate, int)) *PostCreateBulk {
|
|
rv := reflect.ValueOf(slice)
|
|
if rv.Kind() != reflect.Slice {
|
|
return &PostCreateBulk{err: fmt.Errorf("calling to PostClient.MapCreateBulk with wrong type %T, need slice", slice)}
|
|
}
|
|
builders := make([]*PostCreate, rv.Len())
|
|
for i := 0; i < rv.Len(); i++ {
|
|
builders[i] = c.Create()
|
|
setFunc(builders[i], i)
|
|
}
|
|
return &PostCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// Update returns an update builder for Post.
|
|
func (c *PostClient) Update() *PostUpdate {
|
|
mutation := newPostMutation(c.config, OpUpdate)
|
|
return &PostUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOne returns an update builder for the given entity.
|
|
func (c *PostClient) UpdateOne(po *Post) *PostUpdateOne {
|
|
mutation := newPostMutation(c.config, OpUpdateOne, withPost(po))
|
|
return &PostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOneID returns an update builder for the given id.
|
|
func (c *PostClient) UpdateOneID(id uuid.UUID) *PostUpdateOne {
|
|
mutation := newPostMutation(c.config, OpUpdateOne, withPostID(id))
|
|
return &PostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// Delete returns a delete builder for Post.
|
|
func (c *PostClient) Delete() *PostDelete {
|
|
mutation := newPostMutation(c.config, OpDelete)
|
|
return &PostDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// DeleteOne returns a builder for deleting the given entity.
|
|
func (c *PostClient) DeleteOne(po *Post) *PostDeleteOne {
|
|
return c.DeleteOneID(po.ID)
|
|
}
|
|
|
|
// DeleteOneID returns a builder for deleting the given entity by its id.
|
|
func (c *PostClient) DeleteOneID(id uuid.UUID) *PostDeleteOne {
|
|
builder := c.Delete().Where(post.ID(id))
|
|
builder.mutation.id = &id
|
|
builder.mutation.op = OpDeleteOne
|
|
return &PostDeleteOne{builder}
|
|
}
|
|
|
|
// Query returns a query builder for Post.
|
|
func (c *PostClient) Query() *PostQuery {
|
|
return &PostQuery{
|
|
config: c.config,
|
|
ctx: &QueryContext{Type: TypePost},
|
|
inters: c.Interceptors(),
|
|
}
|
|
}
|
|
|
|
// Get returns a Post entity by its id.
|
|
func (c *PostClient) Get(ctx context.Context, id uuid.UUID) (*Post, error) {
|
|
return c.Query().Where(post.ID(id)).Only(ctx)
|
|
}
|
|
|
|
// GetX is like Get, but panics if an error occurs.
|
|
func (c *PostClient) GetX(ctx context.Context, id uuid.UUID) *Post {
|
|
obj, err := c.Get(ctx, id)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// QueryCategory queries the category edge of a Post.
|
|
func (c *PostClient) QueryCategory(po *Post) *CategoryQuery {
|
|
query := (&CategoryClient{config: c.config}).Query()
|
|
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
|
|
id := po.ID
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(post.Table, post.FieldID, id),
|
|
sqlgraph.To(category.Table, category.FieldID),
|
|
sqlgraph.Edge(sqlgraph.M2O, true, post.CategoryTable, post.CategoryColumn),
|
|
)
|
|
fromV = sqlgraph.Neighbors(po.driver.Dialect(), step)
|
|
return fromV, nil
|
|
}
|
|
return query
|
|
}
|
|
|
|
// QueryProfile queries the profile edge of a Post.
|
|
func (c *PostClient) QueryProfile(po *Post) *ProfileQuery {
|
|
query := (&ProfileClient{config: c.config}).Query()
|
|
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
|
|
id := po.ID
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(post.Table, post.FieldID, id),
|
|
sqlgraph.To(profile.Table, profile.FieldID),
|
|
sqlgraph.Edge(sqlgraph.M2O, true, post.ProfileTable, post.ProfileColumn),
|
|
)
|
|
fromV = sqlgraph.Neighbors(po.driver.Dialect(), step)
|
|
return fromV, nil
|
|
}
|
|
return query
|
|
}
|
|
|
|
// Hooks returns the client hooks.
|
|
func (c *PostClient) Hooks() []Hook {
|
|
return c.hooks.Post
|
|
}
|
|
|
|
// Interceptors returns the client interceptors.
|
|
func (c *PostClient) Interceptors() []Interceptor {
|
|
return c.inters.Post
|
|
}
|
|
|
|
func (c *PostClient) mutate(ctx context.Context, m *PostMutation) (Value, error) {
|
|
switch m.Op() {
|
|
case OpCreate:
|
|
return (&PostCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdate:
|
|
return (&PostUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdateOne:
|
|
return (&PostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpDelete, OpDeleteOne:
|
|
return (&PostDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("ent: unknown Post mutation op: %q", m.Op())
|
|
}
|
|
}
|
|
|
|
// ProfileClient is a client for the Profile schema.
|
|
type ProfileClient struct {
|
|
config
|
|
}
|
|
|
|
// NewProfileClient returns a client for the Profile from the given config.
|
|
func NewProfileClient(c config) *ProfileClient {
|
|
return &ProfileClient{config: c}
|
|
}
|
|
|
|
// Use adds a list of mutation hooks to the hooks stack.
|
|
// A call to `Use(f, g, h)` equals to `profile.Hooks(f(g(h())))`.
|
|
func (c *ProfileClient) Use(hooks ...Hook) {
|
|
c.hooks.Profile = append(c.hooks.Profile, hooks...)
|
|
}
|
|
|
|
// Intercept adds a list of query interceptors to the interceptors stack.
|
|
// A call to `Intercept(f, g, h)` equals to `profile.Intercept(f(g(h())))`.
|
|
func (c *ProfileClient) Intercept(interceptors ...Interceptor) {
|
|
c.inters.Profile = append(c.inters.Profile, interceptors...)
|
|
}
|
|
|
|
// Create returns a builder for creating a Profile entity.
|
|
func (c *ProfileClient) Create() *ProfileCreate {
|
|
mutation := newProfileMutation(c.config, OpCreate)
|
|
return &ProfileCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// CreateBulk returns a builder for creating a bulk of Profile entities.
|
|
func (c *ProfileClient) CreateBulk(builders ...*ProfileCreate) *ProfileCreateBulk {
|
|
return &ProfileCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
|
|
// a builder and applies setFunc on it.
|
|
func (c *ProfileClient) MapCreateBulk(slice any, setFunc func(*ProfileCreate, int)) *ProfileCreateBulk {
|
|
rv := reflect.ValueOf(slice)
|
|
if rv.Kind() != reflect.Slice {
|
|
return &ProfileCreateBulk{err: fmt.Errorf("calling to ProfileClient.MapCreateBulk with wrong type %T, need slice", slice)}
|
|
}
|
|
builders := make([]*ProfileCreate, rv.Len())
|
|
for i := 0; i < rv.Len(); i++ {
|
|
builders[i] = c.Create()
|
|
setFunc(builders[i], i)
|
|
}
|
|
return &ProfileCreateBulk{config: c.config, builders: builders}
|
|
}
|
|
|
|
// Update returns an update builder for Profile.
|
|
func (c *ProfileClient) Update() *ProfileUpdate {
|
|
mutation := newProfileMutation(c.config, OpUpdate)
|
|
return &ProfileUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOne returns an update builder for the given entity.
|
|
func (c *ProfileClient) UpdateOne(pr *Profile) *ProfileUpdateOne {
|
|
mutation := newProfileMutation(c.config, OpUpdateOne, withProfile(pr))
|
|
return &ProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// UpdateOneID returns an update builder for the given id.
|
|
func (c *ProfileClient) UpdateOneID(id uuid.UUID) *ProfileUpdateOne {
|
|
mutation := newProfileMutation(c.config, OpUpdateOne, withProfileID(id))
|
|
return &ProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// Delete returns a delete builder for Profile.
|
|
func (c *ProfileClient) Delete() *ProfileDelete {
|
|
mutation := newProfileMutation(c.config, OpDelete)
|
|
return &ProfileDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
|
|
}
|
|
|
|
// DeleteOne returns a builder for deleting the given entity.
|
|
func (c *ProfileClient) DeleteOne(pr *Profile) *ProfileDeleteOne {
|
|
return c.DeleteOneID(pr.ID)
|
|
}
|
|
|
|
// DeleteOneID returns a builder for deleting the given entity by its id.
|
|
func (c *ProfileClient) DeleteOneID(id uuid.UUID) *ProfileDeleteOne {
|
|
builder := c.Delete().Where(profile.ID(id))
|
|
builder.mutation.id = &id
|
|
builder.mutation.op = OpDeleteOne
|
|
return &ProfileDeleteOne{builder}
|
|
}
|
|
|
|
// Query returns a query builder for Profile.
|
|
func (c *ProfileClient) Query() *ProfileQuery {
|
|
return &ProfileQuery{
|
|
config: c.config,
|
|
ctx: &QueryContext{Type: TypeProfile},
|
|
inters: c.Interceptors(),
|
|
}
|
|
}
|
|
|
|
// Get returns a Profile entity by its id.
|
|
func (c *ProfileClient) Get(ctx context.Context, id uuid.UUID) (*Profile, error) {
|
|
return c.Query().Where(profile.ID(id)).Only(ctx)
|
|
}
|
|
|
|
// GetX is like Get, but panics if an error occurs.
|
|
func (c *ProfileClient) GetX(ctx context.Context, id uuid.UUID) *Profile {
|
|
obj, err := c.Get(ctx, id)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// QueryPosts queries the posts edge of a Profile.
|
|
func (c *ProfileClient) QueryPosts(pr *Profile) *PostQuery {
|
|
query := (&PostClient{config: c.config}).Query()
|
|
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
|
|
id := pr.ID
|
|
step := sqlgraph.NewStep(
|
|
sqlgraph.From(profile.Table, profile.FieldID, id),
|
|
sqlgraph.To(post.Table, post.FieldID),
|
|
sqlgraph.Edge(sqlgraph.O2M, false, profile.PostsTable, profile.PostsColumn),
|
|
)
|
|
fromV = sqlgraph.Neighbors(pr.driver.Dialect(), step)
|
|
return fromV, nil
|
|
}
|
|
return query
|
|
}
|
|
|
|
// Hooks returns the client hooks.
|
|
func (c *ProfileClient) Hooks() []Hook {
|
|
return c.hooks.Profile
|
|
}
|
|
|
|
// Interceptors returns the client interceptors.
|
|
func (c *ProfileClient) Interceptors() []Interceptor {
|
|
return c.inters.Profile
|
|
}
|
|
|
|
func (c *ProfileClient) mutate(ctx context.Context, m *ProfileMutation) (Value, error) {
|
|
switch m.Op() {
|
|
case OpCreate:
|
|
return (&ProfileCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdate:
|
|
return (&ProfileUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpUpdateOne:
|
|
return (&ProfileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
|
|
case OpDelete, OpDeleteOne:
|
|
return (&ProfileDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
|
|
default:
|
|
return nil, fmt.Errorf("ent: unknown Profile mutation op: %q", m.Op())
|
|
}
|
|
}
|
|
|
|
// hooks and interceptors per client, for fast access.
|
|
type (
|
|
hooks struct {
|
|
Category, Post, Profile []ent.Hook
|
|
}
|
|
inters struct {
|
|
Category, Post, Profile []ent.Interceptor
|
|
}
|
|
)
|