aboutsummaryrefslogtreecommitdiff
path: root/src/models/posts.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/models/posts.go')
-rw-r--r--src/models/posts.go1102
1 files changed, 1102 insertions, 0 deletions
diff --git a/src/models/posts.go b/src/models/posts.go
new file mode 100644
index 0000000..d644268
--- /dev/null
+++ b/src/models/posts.go
@@ -0,0 +1,1102 @@
+// Code generated by SQLBoiler 4.16.1 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package models
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/friendsofgo/errors"
+ "github.com/volatiletech/null/v8"
+ "github.com/volatiletech/sqlboiler/v4/boil"
+ "github.com/volatiletech/sqlboiler/v4/queries"
+ "github.com/volatiletech/sqlboiler/v4/queries/qm"
+ "github.com/volatiletech/sqlboiler/v4/queries/qmhelper"
+ "github.com/volatiletech/strmangle"
+)
+
+// Post is an object representing the database table.
+type Post struct {
+ ID int `boil:"id" json:"id" toml:"id" yaml:"id"`
+ Title string `boil:"title" json:"title" toml:"title" yaml:"title"`
+ URL null.String `boil:"url" json:"url,omitempty" toml:"url" yaml:"url,omitempty"`
+ Description string `boil:"description" json:"description" toml:"description" yaml:"description"`
+ CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"`
+ UpdatedAt time.Time `boil:"updated_at" json:"updated_at" toml:"updated_at" yaml:"updated_at"`
+
+ R *postR `boil:"-" json:"-" toml:"-" yaml:"-"`
+ L postL `boil:"-" json:"-" toml:"-" yaml:"-"`
+}
+
+var PostColumns = struct {
+ ID string
+ Title string
+ URL string
+ Description string
+ CreatedAt string
+ UpdatedAt string
+}{
+ ID: "id",
+ Title: "title",
+ URL: "url",
+ Description: "description",
+ CreatedAt: "created_at",
+ UpdatedAt: "updated_at",
+}
+
+var PostTableColumns = struct {
+ ID string
+ Title string
+ URL string
+ Description string
+ CreatedAt string
+ UpdatedAt string
+}{
+ ID: "posts.id",
+ Title: "posts.title",
+ URL: "posts.url",
+ Description: "posts.description",
+ CreatedAt: "posts.created_at",
+ UpdatedAt: "posts.updated_at",
+}
+
+// Generated where
+
+type whereHelperint struct{ field string }
+
+func (w whereHelperint) EQ(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) }
+func (w whereHelperint) NEQ(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.NEQ, x) }
+func (w whereHelperint) LT(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) }
+func (w whereHelperint) LTE(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LTE, x) }
+func (w whereHelperint) GT(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) }
+func (w whereHelperint) GTE(x int) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) }
+func (w whereHelperint) IN(slice []int) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...)
+}
+func (w whereHelperint) NIN(slice []int) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...)
+}
+
+type whereHelperstring struct{ field string }
+
+func (w whereHelperstring) EQ(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) }
+func (w whereHelperstring) NEQ(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.NEQ, x) }
+func (w whereHelperstring) LT(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) }
+func (w whereHelperstring) LTE(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LTE, x) }
+func (w whereHelperstring) GT(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) }
+func (w whereHelperstring) GTE(x string) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) }
+func (w whereHelperstring) LIKE(x string) qm.QueryMod { return qm.Where(w.field+" LIKE ?", x) }
+func (w whereHelperstring) NLIKE(x string) qm.QueryMod { return qm.Where(w.field+" NOT LIKE ?", x) }
+func (w whereHelperstring) ILIKE(x string) qm.QueryMod { return qm.Where(w.field+" ILIKE ?", x) }
+func (w whereHelperstring) NILIKE(x string) qm.QueryMod { return qm.Where(w.field+" NOT ILIKE ?", x) }
+func (w whereHelperstring) IN(slice []string) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...)
+}
+func (w whereHelperstring) NIN(slice []string) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...)
+}
+
+type whereHelpernull_String struct{ field string }
+
+func (w whereHelpernull_String) EQ(x null.String) qm.QueryMod {
+ return qmhelper.WhereNullEQ(w.field, false, x)
+}
+func (w whereHelpernull_String) NEQ(x null.String) qm.QueryMod {
+ return qmhelper.WhereNullEQ(w.field, true, x)
+}
+func (w whereHelpernull_String) LT(x null.String) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.LT, x)
+}
+func (w whereHelpernull_String) LTE(x null.String) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.LTE, x)
+}
+func (w whereHelpernull_String) GT(x null.String) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.GT, x)
+}
+func (w whereHelpernull_String) GTE(x null.String) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.GTE, x)
+}
+func (w whereHelpernull_String) LIKE(x null.String) qm.QueryMod {
+ return qm.Where(w.field+" LIKE ?", x)
+}
+func (w whereHelpernull_String) NLIKE(x null.String) qm.QueryMod {
+ return qm.Where(w.field+" NOT LIKE ?", x)
+}
+func (w whereHelpernull_String) ILIKE(x null.String) qm.QueryMod {
+ return qm.Where(w.field+" ILIKE ?", x)
+}
+func (w whereHelpernull_String) NILIKE(x null.String) qm.QueryMod {
+ return qm.Where(w.field+" NOT ILIKE ?", x)
+}
+func (w whereHelpernull_String) IN(slice []string) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...)
+}
+func (w whereHelpernull_String) NIN(slice []string) qm.QueryMod {
+ values := make([]interface{}, 0, len(slice))
+ for _, value := range slice {
+ values = append(values, value)
+ }
+ return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...)
+}
+
+func (w whereHelpernull_String) IsNull() qm.QueryMod { return qmhelper.WhereIsNull(w.field) }
+func (w whereHelpernull_String) IsNotNull() qm.QueryMod { return qmhelper.WhereIsNotNull(w.field) }
+
+type whereHelpertime_Time struct{ field string }
+
+func (w whereHelpertime_Time) EQ(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.EQ, x)
+}
+func (w whereHelpertime_Time) NEQ(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.NEQ, x)
+}
+func (w whereHelpertime_Time) LT(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.LT, x)
+}
+func (w whereHelpertime_Time) LTE(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.LTE, x)
+}
+func (w whereHelpertime_Time) GT(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.GT, x)
+}
+func (w whereHelpertime_Time) GTE(x time.Time) qm.QueryMod {
+ return qmhelper.Where(w.field, qmhelper.GTE, x)
+}
+
+var PostWhere = struct {
+ ID whereHelperint
+ Title whereHelperstring
+ URL whereHelpernull_String
+ Description whereHelperstring
+ CreatedAt whereHelpertime_Time
+ UpdatedAt whereHelpertime_Time
+}{
+ ID: whereHelperint{field: "\"posts\".\"id\""},
+ Title: whereHelperstring{field: "\"posts\".\"title\""},
+ URL: whereHelpernull_String{field: "\"posts\".\"url\""},
+ Description: whereHelperstring{field: "\"posts\".\"description\""},
+ CreatedAt: whereHelpertime_Time{field: "\"posts\".\"created_at\""},
+ UpdatedAt: whereHelpertime_Time{field: "\"posts\".\"updated_at\""},
+}
+
+// PostRels is where relationship names are stored.
+var PostRels = struct {
+}{}
+
+// postR is where relationships are stored.
+type postR struct {
+}
+
+// NewStruct creates a new relationship struct
+func (*postR) NewStruct() *postR {
+ return &postR{}
+}
+
+// postL is where Load methods for each relationship are stored.
+type postL struct{}
+
+var (
+ postAllColumns = []string{"id", "title", "url", "description", "created_at", "updated_at"}
+ postColumnsWithoutDefault = []string{"title", "description"}
+ postColumnsWithDefault = []string{"id", "url", "created_at", "updated_at"}
+ postPrimaryKeyColumns = []string{"id"}
+ postGeneratedColumns = []string{}
+)
+
+type (
+ // PostSlice is an alias for a slice of pointers to Post.
+ // This should almost always be used instead of []Post.
+ PostSlice []*Post
+ // PostHook is the signature for custom Post hook methods
+ PostHook func(context.Context, boil.ContextExecutor, *Post) error
+
+ postQuery struct {
+ *queries.Query
+ }
+)
+
+// Cache for insert, update and upsert
+var (
+ postType = reflect.TypeOf(&Post{})
+ postMapping = queries.MakeStructMapping(postType)
+ postPrimaryKeyMapping, _ = queries.BindMapping(postType, postMapping, postPrimaryKeyColumns)
+ postInsertCacheMut sync.RWMutex
+ postInsertCache = make(map[string]insertCache)
+ postUpdateCacheMut sync.RWMutex
+ postUpdateCache = make(map[string]updateCache)
+ postUpsertCacheMut sync.RWMutex
+ postUpsertCache = make(map[string]insertCache)
+)
+
+var (
+ // Force time package dependency for automated UpdatedAt/CreatedAt.
+ _ = time.Second
+ // Force qmhelper dependency for where clause generation (which doesn't
+ // always happen)
+ _ = qmhelper.Where
+)
+
+var postAfterSelectMu sync.Mutex
+var postAfterSelectHooks []PostHook
+
+var postBeforeInsertMu sync.Mutex
+var postBeforeInsertHooks []PostHook
+var postAfterInsertMu sync.Mutex
+var postAfterInsertHooks []PostHook
+
+var postBeforeUpdateMu sync.Mutex
+var postBeforeUpdateHooks []PostHook
+var postAfterUpdateMu sync.Mutex
+var postAfterUpdateHooks []PostHook
+
+var postBeforeDeleteMu sync.Mutex
+var postBeforeDeleteHooks []PostHook
+var postAfterDeleteMu sync.Mutex
+var postAfterDeleteHooks []PostHook
+
+var postBeforeUpsertMu sync.Mutex
+var postBeforeUpsertHooks []PostHook
+var postAfterUpsertMu sync.Mutex
+var postAfterUpsertHooks []PostHook
+
+// doAfterSelectHooks executes all "after Select" hooks.
+func (o *Post) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postAfterSelectHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doBeforeInsertHooks executes all "before insert" hooks.
+func (o *Post) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postBeforeInsertHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doAfterInsertHooks executes all "after Insert" hooks.
+func (o *Post) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postAfterInsertHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doBeforeUpdateHooks executes all "before Update" hooks.
+func (o *Post) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postBeforeUpdateHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doAfterUpdateHooks executes all "after Update" hooks.
+func (o *Post) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postAfterUpdateHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doBeforeDeleteHooks executes all "before Delete" hooks.
+func (o *Post) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postBeforeDeleteHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doAfterDeleteHooks executes all "after Delete" hooks.
+func (o *Post) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postAfterDeleteHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doBeforeUpsertHooks executes all "before Upsert" hooks.
+func (o *Post) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postBeforeUpsertHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// doAfterUpsertHooks executes all "after Upsert" hooks.
+func (o *Post) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) {
+ if boil.HooksAreSkipped(ctx) {
+ return nil
+ }
+
+ for _, hook := range postAfterUpsertHooks {
+ if err := hook(ctx, exec, o); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// AddPostHook registers your hook function for all future operations.
+func AddPostHook(hookPoint boil.HookPoint, postHook PostHook) {
+ switch hookPoint {
+ case boil.AfterSelectHook:
+ postAfterSelectMu.Lock()
+ postAfterSelectHooks = append(postAfterSelectHooks, postHook)
+ postAfterSelectMu.Unlock()
+ case boil.BeforeInsertHook:
+ postBeforeInsertMu.Lock()
+ postBeforeInsertHooks = append(postBeforeInsertHooks, postHook)
+ postBeforeInsertMu.Unlock()
+ case boil.AfterInsertHook:
+ postAfterInsertMu.Lock()
+ postAfterInsertHooks = append(postAfterInsertHooks, postHook)
+ postAfterInsertMu.Unlock()
+ case boil.BeforeUpdateHook:
+ postBeforeUpdateMu.Lock()
+ postBeforeUpdateHooks = append(postBeforeUpdateHooks, postHook)
+ postBeforeUpdateMu.Unlock()
+ case boil.AfterUpdateHook:
+ postAfterUpdateMu.Lock()
+ postAfterUpdateHooks = append(postAfterUpdateHooks, postHook)
+ postAfterUpdateMu.Unlock()
+ case boil.BeforeDeleteHook:
+ postBeforeDeleteMu.Lock()
+ postBeforeDeleteHooks = append(postBeforeDeleteHooks, postHook)
+ postBeforeDeleteMu.Unlock()
+ case boil.AfterDeleteHook:
+ postAfterDeleteMu.Lock()
+ postAfterDeleteHooks = append(postAfterDeleteHooks, postHook)
+ postAfterDeleteMu.Unlock()
+ case boil.BeforeUpsertHook:
+ postBeforeUpsertMu.Lock()
+ postBeforeUpsertHooks = append(postBeforeUpsertHooks, postHook)
+ postBeforeUpsertMu.Unlock()
+ case boil.AfterUpsertHook:
+ postAfterUpsertMu.Lock()
+ postAfterUpsertHooks = append(postAfterUpsertHooks, postHook)
+ postAfterUpsertMu.Unlock()
+ }
+}
+
+// One returns a single post record from the query.
+func (q postQuery) One(ctx context.Context, exec boil.ContextExecutor) (*Post, error) {
+ o := &Post{}
+
+ queries.SetLimit(q.Query, 1)
+
+ err := q.Bind(ctx, exec, o)
+ if err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ return nil, sql.ErrNoRows
+ }
+ return nil, errors.Wrap(err, "models: failed to execute a one query for posts")
+ }
+
+ if err := o.doAfterSelectHooks(ctx, exec); err != nil {
+ return o, err
+ }
+
+ return o, nil
+}
+
+// All returns all Post records from the query.
+func (q postQuery) All(ctx context.Context, exec boil.ContextExecutor) (PostSlice, error) {
+ var o []*Post
+
+ err := q.Bind(ctx, exec, &o)
+ if err != nil {
+ return nil, errors.Wrap(err, "models: failed to assign all query results to Post slice")
+ }
+
+ if len(postAfterSelectHooks) != 0 {
+ for _, obj := range o {
+ if err := obj.doAfterSelectHooks(ctx, exec); err != nil {
+ return o, err
+ }
+ }
+ }
+
+ return o, nil
+}
+
+// Count returns the count of all Post records in the query.
+func (q postQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+ var count int64
+
+ queries.SetSelect(q.Query, nil)
+ queries.SetCount(q.Query)
+
+ err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: failed to count posts rows")
+ }
+
+ return count, nil
+}
+
+// Exists checks if the row exists in the table.
+func (q postQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
+ var count int64
+
+ queries.SetSelect(q.Query, nil)
+ queries.SetCount(q.Query)
+ queries.SetLimit(q.Query, 1)
+
+ err := q.Query.QueryRowContext(ctx, exec).Scan(&count)
+ if err != nil {
+ return false, errors.Wrap(err, "models: failed to check if posts exists")
+ }
+
+ return count > 0, nil
+}
+
+// Posts retrieves all the records using an executor.
+func Posts(mods ...qm.QueryMod) postQuery {
+ mods = append(mods, qm.From("\"posts\""))
+ q := NewQuery(mods...)
+ if len(queries.GetSelect(q)) == 0 {
+ queries.SetSelect(q, []string{"\"posts\".*"})
+ }
+
+ return postQuery{q}
+}
+
+// FindPost retrieves a single record by ID with an executor.
+// If selectCols is empty Find will return all columns.
+func FindPost(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Post, error) {
+ postObj := &Post{}
+
+ sel := "*"
+ if len(selectCols) > 0 {
+ sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
+ }
+ query := fmt.Sprintf(
+ "select %s from \"posts\" where \"id\"=$1", sel,
+ )
+
+ q := queries.Raw(query, iD)
+
+ err := q.Bind(ctx, exec, postObj)
+ if err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ return nil, sql.ErrNoRows
+ }
+ return nil, errors.Wrap(err, "models: unable to select from posts")
+ }
+
+ if err = postObj.doAfterSelectHooks(ctx, exec); err != nil {
+ return postObj, err
+ }
+
+ return postObj, nil
+}
+
+// Insert a single record using an executor.
+// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts.
+func (o *Post) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error {
+ if o == nil {
+ return errors.New("models: no posts provided for insertion")
+ }
+
+ var err error
+ if !boil.TimestampsAreSkipped(ctx) {
+ currTime := time.Now().In(boil.GetLocation())
+
+ if o.CreatedAt.IsZero() {
+ o.CreatedAt = currTime
+ }
+ if o.UpdatedAt.IsZero() {
+ o.UpdatedAt = currTime
+ }
+ }
+
+ if err := o.doBeforeInsertHooks(ctx, exec); err != nil {
+ return err
+ }
+
+ nzDefaults := queries.NonZeroDefaultSet(postColumnsWithDefault, o)
+
+ key := makeCacheKey(columns, nzDefaults)
+ postInsertCacheMut.RLock()
+ cache, cached := postInsertCache[key]
+ postInsertCacheMut.RUnlock()
+
+ if !cached {
+ wl, returnColumns := columns.InsertColumnSet(
+ postAllColumns,
+ postColumnsWithDefault,
+ postColumnsWithoutDefault,
+ nzDefaults,
+ )
+
+ cache.valueMapping, err = queries.BindMapping(postType, postMapping, wl)
+ if err != nil {
+ return err
+ }
+ cache.retMapping, err = queries.BindMapping(postType, postMapping, returnColumns)
+ if err != nil {
+ return err
+ }
+ if len(wl) != 0 {
+ cache.query = fmt.Sprintf("INSERT INTO \"posts\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1))
+ } else {
+ cache.query = "INSERT INTO \"posts\" %sDEFAULT VALUES%s"
+ }
+
+ var queryOutput, queryReturning string
+
+ if len(cache.retMapping) != 0 {
+ queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\""))
+ }
+
+ cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning)
+ }
+
+ value := reflect.Indirect(reflect.ValueOf(o))
+ vals := queries.ValuesFromMapping(value, cache.valueMapping)
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, cache.query)
+ fmt.Fprintln(writer, vals)
+ }
+
+ if len(cache.retMapping) != 0 {
+ err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...)
+ } else {
+ _, err = exec.ExecContext(ctx, cache.query, vals...)
+ }
+
+ if err != nil {
+ return errors.Wrap(err, "models: unable to insert into posts")
+ }
+
+ if !cached {
+ postInsertCacheMut.Lock()
+ postInsertCache[key] = cache
+ postInsertCacheMut.Unlock()
+ }
+
+ return o.doAfterInsertHooks(ctx, exec)
+}
+
+// Update uses an executor to update the Post.
+// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates.
+// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records.
+func (o *Post) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) {
+ if !boil.TimestampsAreSkipped(ctx) {
+ currTime := time.Now().In(boil.GetLocation())
+
+ o.UpdatedAt = currTime
+ }
+
+ var err error
+ if err = o.doBeforeUpdateHooks(ctx, exec); err != nil {
+ return 0, err
+ }
+ key := makeCacheKey(columns, nil)
+ postUpdateCacheMut.RLock()
+ cache, cached := postUpdateCache[key]
+ postUpdateCacheMut.RUnlock()
+
+ if !cached {
+ wl := columns.UpdateColumnSet(
+ postAllColumns,
+ postPrimaryKeyColumns,
+ )
+
+ if !columns.IsWhitelist() {
+ wl = strmangle.SetComplement(wl, []string{"created_at"})
+ }
+ if len(wl) == 0 {
+ return 0, errors.New("models: unable to update posts, could not build whitelist")
+ }
+
+ cache.query = fmt.Sprintf("UPDATE \"posts\" SET %s WHERE %s",
+ strmangle.SetParamNames("\"", "\"", 1, wl),
+ strmangle.WhereClause("\"", "\"", len(wl)+1, postPrimaryKeyColumns),
+ )
+ cache.valueMapping, err = queries.BindMapping(postType, postMapping, append(wl, postPrimaryKeyColumns...))
+ if err != nil {
+ return 0, err
+ }
+ }
+
+ values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping)
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, cache.query)
+ fmt.Fprintln(writer, values)
+ }
+ var result sql.Result
+ result, err = exec.ExecContext(ctx, cache.query, values...)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to update posts row")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: failed to get rows affected by update for posts")
+ }
+
+ if !cached {
+ postUpdateCacheMut.Lock()
+ postUpdateCache[key] = cache
+ postUpdateCacheMut.Unlock()
+ }
+
+ return rowsAff, o.doAfterUpdateHooks(ctx, exec)
+}
+
+// UpdateAll updates all rows with the specified column values.
+func (q postQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+ queries.SetUpdate(q.Query, cols)
+
+ result, err := q.Query.ExecContext(ctx, exec)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to update all for posts")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to retrieve rows affected for posts")
+ }
+
+ return rowsAff, nil
+}
+
+// UpdateAll updates all rows with the specified column values, using an executor.
+func (o PostSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) {
+ ln := int64(len(o))
+ if ln == 0 {
+ return 0, nil
+ }
+
+ if len(cols) == 0 {
+ return 0, errors.New("models: update all requires at least one column argument")
+ }
+
+ colNames := make([]string, len(cols))
+ args := make([]interface{}, len(cols))
+
+ i := 0
+ for name, value := range cols {
+ colNames[i] = name
+ args[i] = value
+ i++
+ }
+
+ // Append all of the primary key values for each column
+ for _, obj := range o {
+ pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), postPrimaryKeyMapping)
+ args = append(args, pkeyArgs...)
+ }
+
+ sql := fmt.Sprintf("UPDATE \"posts\" SET %s WHERE %s",
+ strmangle.SetParamNames("\"", "\"", 1, colNames),
+ strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, postPrimaryKeyColumns, len(o)))
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, sql)
+ fmt.Fprintln(writer, args...)
+ }
+ result, err := exec.ExecContext(ctx, sql, args...)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to update all in post slice")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all post")
+ }
+ return rowsAff, nil
+}
+
+// Upsert attempts an insert using an executor, and does an update or ignore on conflict.
+// See boil.Columns documentation for how to properly use updateColumns and insertColumns.
+func (o *Post) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns, opts ...UpsertOptionFunc) error {
+ if o == nil {
+ return errors.New("models: no posts provided for upsert")
+ }
+ if !boil.TimestampsAreSkipped(ctx) {
+ currTime := time.Now().In(boil.GetLocation())
+
+ if o.CreatedAt.IsZero() {
+ o.CreatedAt = currTime
+ }
+ o.UpdatedAt = currTime
+ }
+
+ if err := o.doBeforeUpsertHooks(ctx, exec); err != nil {
+ return err
+ }
+
+ nzDefaults := queries.NonZeroDefaultSet(postColumnsWithDefault, o)
+
+ // Build cache key in-line uglily - mysql vs psql problems
+ buf := strmangle.GetBuffer()
+ if updateOnConflict {
+ buf.WriteByte('t')
+ } else {
+ buf.WriteByte('f')
+ }
+ buf.WriteByte('.')
+ for _, c := range conflictColumns {
+ buf.WriteString(c)
+ }
+ buf.WriteByte('.')
+ buf.WriteString(strconv.Itoa(updateColumns.Kind))
+ for _, c := range updateColumns.Cols {
+ buf.WriteString(c)
+ }
+ buf.WriteByte('.')
+ buf.WriteString(strconv.Itoa(insertColumns.Kind))
+ for _, c := range insertColumns.Cols {
+ buf.WriteString(c)
+ }
+ buf.WriteByte('.')
+ for _, c := range nzDefaults {
+ buf.WriteString(c)
+ }
+ key := buf.String()
+ strmangle.PutBuffer(buf)
+
+ postUpsertCacheMut.RLock()
+ cache, cached := postUpsertCache[key]
+ postUpsertCacheMut.RUnlock()
+
+ var err error
+
+ if !cached {
+ insert, _ := insertColumns.InsertColumnSet(
+ postAllColumns,
+ postColumnsWithDefault,
+ postColumnsWithoutDefault,
+ nzDefaults,
+ )
+
+ update := updateColumns.UpdateColumnSet(
+ postAllColumns,
+ postPrimaryKeyColumns,
+ )
+
+ if updateOnConflict && len(update) == 0 {
+ return errors.New("models: unable to upsert posts, could not build update column list")
+ }
+
+ ret := strmangle.SetComplement(postAllColumns, strmangle.SetIntersect(insert, update))
+
+ conflict := conflictColumns
+ if len(conflict) == 0 && updateOnConflict && len(update) != 0 {
+ if len(postPrimaryKeyColumns) == 0 {
+ return errors.New("models: unable to upsert posts, could not build conflict column list")
+ }
+
+ conflict = make([]string, len(postPrimaryKeyColumns))
+ copy(conflict, postPrimaryKeyColumns)
+ }
+ cache.query = buildUpsertQueryPostgres(dialect, "\"posts\"", updateOnConflict, ret, update, conflict, insert, opts...)
+
+ cache.valueMapping, err = queries.BindMapping(postType, postMapping, insert)
+ if err != nil {
+ return err
+ }
+ if len(ret) != 0 {
+ cache.retMapping, err = queries.BindMapping(postType, postMapping, ret)
+ if err != nil {
+ return err
+ }
+ }
+ }
+
+ value := reflect.Indirect(reflect.ValueOf(o))
+ vals := queries.ValuesFromMapping(value, cache.valueMapping)
+ var returns []interface{}
+ if len(cache.retMapping) != 0 {
+ returns = queries.PtrsFromMapping(value, cache.retMapping)
+ }
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, cache.query)
+ fmt.Fprintln(writer, vals)
+ }
+ if len(cache.retMapping) != 0 {
+ err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...)
+ if errors.Is(err, sql.ErrNoRows) {
+ err = nil // Postgres doesn't return anything when there's no update
+ }
+ } else {
+ _, err = exec.ExecContext(ctx, cache.query, vals...)
+ }
+ if err != nil {
+ return errors.Wrap(err, "models: unable to upsert posts")
+ }
+
+ if !cached {
+ postUpsertCacheMut.Lock()
+ postUpsertCache[key] = cache
+ postUpsertCacheMut.Unlock()
+ }
+
+ return o.doAfterUpsertHooks(ctx, exec)
+}
+
+// Delete deletes a single Post record with an executor.
+// Delete will match against the primary key column to find the record to delete.
+func (o *Post) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+ if o == nil {
+ return 0, errors.New("models: no Post provided for delete")
+ }
+
+ if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
+ return 0, err
+ }
+
+ args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), postPrimaryKeyMapping)
+ sql := "DELETE FROM \"posts\" WHERE \"id\"=$1"
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, sql)
+ fmt.Fprintln(writer, args...)
+ }
+ result, err := exec.ExecContext(ctx, sql, args...)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to delete from posts")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: failed to get rows affected by delete for posts")
+ }
+
+ if err := o.doAfterDeleteHooks(ctx, exec); err != nil {
+ return 0, err
+ }
+
+ return rowsAff, nil
+}
+
+// DeleteAll deletes all matching rows.
+func (q postQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+ if q.Query == nil {
+ return 0, errors.New("models: no postQuery provided for delete all")
+ }
+
+ queries.SetDelete(q.Query)
+
+ result, err := q.Query.ExecContext(ctx, exec)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to delete all from posts")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for posts")
+ }
+
+ return rowsAff, nil
+}
+
+// DeleteAll deletes all rows in the slice, using an executor.
+func (o PostSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
+ if len(o) == 0 {
+ return 0, nil
+ }
+
+ if len(postBeforeDeleteHooks) != 0 {
+ for _, obj := range o {
+ if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
+ return 0, err
+ }
+ }
+ }
+
+ var args []interface{}
+ for _, obj := range o {
+ pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), postPrimaryKeyMapping)
+ args = append(args, pkeyArgs...)
+ }
+
+ sql := "DELETE FROM \"posts\" WHERE " +
+ strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, postPrimaryKeyColumns, len(o))
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, sql)
+ fmt.Fprintln(writer, args)
+ }
+ result, err := exec.ExecContext(ctx, sql, args...)
+ if err != nil {
+ return 0, errors.Wrap(err, "models: unable to delete all from post slice")
+ }
+
+ rowsAff, err := result.RowsAffected()
+ if err != nil {
+ return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for posts")
+ }
+
+ if len(postAfterDeleteHooks) != 0 {
+ for _, obj := range o {
+ if err := obj.doAfterDeleteHooks(ctx, exec); err != nil {
+ return 0, err
+ }
+ }
+ }
+
+ return rowsAff, nil
+}
+
+// Reload refetches the object from the database
+// using the primary keys with an executor.
+func (o *Post) Reload(ctx context.Context, exec boil.ContextExecutor) error {
+ ret, err := FindPost(ctx, exec, o.ID)
+ if err != nil {
+ return err
+ }
+
+ *o = *ret
+ return nil
+}
+
+// ReloadAll refetches every row with matching primary key column values
+// and overwrites the original object slice with the newly updated slice.
+func (o *PostSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error {
+ if o == nil || len(*o) == 0 {
+ return nil
+ }
+
+ slice := PostSlice{}
+ var args []interface{}
+ for _, obj := range *o {
+ pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), postPrimaryKeyMapping)
+ args = append(args, pkeyArgs...)
+ }
+
+ sql := "SELECT \"posts\".* FROM \"posts\" WHERE " +
+ strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, postPrimaryKeyColumns, len(*o))
+
+ q := queries.Raw(sql, args...)
+
+ err := q.Bind(ctx, exec, &slice)
+ if err != nil {
+ return errors.Wrap(err, "models: unable to reload all in PostSlice")
+ }
+
+ *o = slice
+
+ return nil
+}
+
+// PostExists checks if the Post row exists.
+func PostExists(ctx context.Context, exec boil.ContextExecutor, iD int) (bool, error) {
+ var exists bool
+ sql := "select exists(select 1 from \"posts\" where \"id\"=$1 limit 1)"
+
+ if boil.IsDebug(ctx) {
+ writer := boil.DebugWriterFrom(ctx)
+ fmt.Fprintln(writer, sql)
+ fmt.Fprintln(writer, iD)
+ }
+ row := exec.QueryRowContext(ctx, sql, iD)
+
+ err := row.Scan(&exists)
+ if err != nil {
+ return false, errors.Wrap(err, "models: unable to check if posts exists")
+ }
+
+ return exists, nil
+}
+
+// Exists checks if the Post row exists.
+func (o *Post) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) {
+ return PostExists(ctx, exec, o.ID)
+}
generated by cgit v1.2.3 (git 2.51.0) at 2026-01-10 04:35:47 +0000