package thought

import (
	"entgo.io/ent/dialect/sql"
	"github.com/d-exclaimation/fx-graphql-kit/ent/predicate"
)

func ID(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

func IDEQ(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

func IDNEQ(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

func IDIn(ids ...int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {

		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

func IDNotIn(ids ...int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {

		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

func IDGT(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

func IDGTE(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

func IDLT(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

func IDLTE(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

func Title(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTitle), v))
	})
}

func Body(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

func ImageURL(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImageURL), v))
	})
}

func UserId(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUserId), v))
	})
}

func TitleEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTitle), v))
	})
}

func TitleNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTitle), v))
	})
}

func TitleIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldTitle), v...))
	})
}

func TitleNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldTitle), v...))
	})
}

func TitleGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldTitle), v))
	})
}

func TitleGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldTitle), v))
	})
}

func TitleLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldTitle), v))
	})
}

func TitleLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldTitle), v))
	})
}

func TitleContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldTitle), v))
	})
}

func TitleHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldTitle), v))
	})
}

func TitleHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldTitle), v))
	})
}

func TitleEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldTitle), v))
	})
}

func TitleContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldTitle), v))
	})
}

func BodyEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

func BodyNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldBody), v))
	})
}

func BodyIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldBody), v...))
	})
}

func BodyNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldBody), v...))
	})
}

func BodyGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldBody), v))
	})
}

func BodyGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldBody), v))
	})
}

func BodyLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldBody), v))
	})
}

func BodyLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldBody), v))
	})
}

func BodyContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldBody), v))
	})
}

func BodyHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldBody), v))
	})
}

func BodyHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldBody), v))
	})
}

func BodyEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldBody), v))
	})
}

func BodyContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldBody), v))
	})
}

func ImageURLEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImageURL), v))
	})
}

func ImageURLNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldImageURL), v))
	})
}

func ImageURLIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldImageURL), v...))
	})
}

func ImageURLNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldImageURL), v...))
	})
}

func ImageURLGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldImageURL), v))
	})
}

func ImageURLGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldImageURL), v))
	})
}

func ImageURLLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldImageURL), v))
	})
}

func ImageURLLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldImageURL), v))
	})
}

func ImageURLContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldImageURL), v))
	})
}

func ImageURLHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldImageURL), v))
	})
}

func ImageURLHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldImageURL), v))
	})
}

func ImageURLEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldImageURL), v))
	})
}

func ImageURLContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldImageURL), v))
	})
}

func UserIdEQ(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUserId), v))
	})
}

func UserIdNEQ(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUserId), v))
	})
}

func UserIdIn(vs ...int64) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUserId), v...))
	})
}

func UserIdNotIn(vs ...int64) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {

		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUserId), v...))
	})
}

func UserIdGT(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUserId), v))
	})
}

func UserIdGTE(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUserId), v))
	})
}

func UserIdLT(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUserId), v))
	})
}

func UserIdLTE(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUserId), v))
	})
}

func And(predicates ...predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

func Or(predicates ...predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

func Not(p predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		p(s.Not())
	})
}
// Code generated by entc, DO NOT EDIT.

package thought

import (
	"entgo.io/ent/dialect/sql"
	"github.com/d-exclaimation/fx-graphql-kit/ent/predicate"
)

// ID filters vertices based on their ID field.
func ID(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id int) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

// Title applies equality check predicate on the "title" field. It's identical to TitleEQ.
func Title(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTitle), v))
	})
}

// Body applies equality check predicate on the "body" field. It's identical to BodyEQ.
func Body(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

// ImageURL applies equality check predicate on the "imageURL" field. It's identical to ImageURLEQ.
func ImageURL(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImageURL), v))
	})
}

// UserId applies equality check predicate on the "userId" field. It's identical to UserIdEQ.
func UserId(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUserId), v))
	})
}

// TitleEQ applies the EQ predicate on the "title" field.
func TitleEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTitle), v))
	})
}

// TitleNEQ applies the NEQ predicate on the "title" field.
func TitleNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTitle), v))
	})
}

// TitleIn applies the In predicate on the "title" field.
func TitleIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldTitle), v...))
	})
}

// TitleNotIn applies the NotIn predicate on the "title" field.
func TitleNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldTitle), v...))
	})
}

// TitleGT applies the GT predicate on the "title" field.
func TitleGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldTitle), v))
	})
}

// TitleGTE applies the GTE predicate on the "title" field.
func TitleGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldTitle), v))
	})
}

// TitleLT applies the LT predicate on the "title" field.
func TitleLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldTitle), v))
	})
}

// TitleLTE applies the LTE predicate on the "title" field.
func TitleLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldTitle), v))
	})
}

// TitleContains applies the Contains predicate on the "title" field.
func TitleContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldTitle), v))
	})
}

// TitleHasPrefix applies the HasPrefix predicate on the "title" field.
func TitleHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldTitle), v))
	})
}

// TitleHasSuffix applies the HasSuffix predicate on the "title" field.
func TitleHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldTitle), v))
	})
}

// TitleEqualFold applies the EqualFold predicate on the "title" field.
func TitleEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldTitle), v))
	})
}

// TitleContainsFold applies the ContainsFold predicate on the "title" field.
func TitleContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldTitle), v))
	})
}

// BodyEQ applies the EQ predicate on the "body" field.
func BodyEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

// BodyNEQ applies the NEQ predicate on the "body" field.
func BodyNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldBody), v))
	})
}

// BodyIn applies the In predicate on the "body" field.
func BodyIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldBody), v...))
	})
}

// BodyNotIn applies the NotIn predicate on the "body" field.
func BodyNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldBody), v...))
	})
}

// BodyGT applies the GT predicate on the "body" field.
func BodyGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldBody), v))
	})
}

// BodyGTE applies the GTE predicate on the "body" field.
func BodyGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldBody), v))
	})
}

// BodyLT applies the LT predicate on the "body" field.
func BodyLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldBody), v))
	})
}

// BodyLTE applies the LTE predicate on the "body" field.
func BodyLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldBody), v))
	})
}

// BodyContains applies the Contains predicate on the "body" field.
func BodyContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldBody), v))
	})
}

// BodyHasPrefix applies the HasPrefix predicate on the "body" field.
func BodyHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldBody), v))
	})
}

// BodyHasSuffix applies the HasSuffix predicate on the "body" field.
func BodyHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldBody), v))
	})
}

// BodyEqualFold applies the EqualFold predicate on the "body" field.
func BodyEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldBody), v))
	})
}

// BodyContainsFold applies the ContainsFold predicate on the "body" field.
func BodyContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldBody), v))
	})
}

// ImageURLEQ applies the EQ predicate on the "imageURL" field.
func ImageURLEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldImageURL), v))
	})
}

// ImageURLNEQ applies the NEQ predicate on the "imageURL" field.
func ImageURLNEQ(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldImageURL), v))
	})
}

// ImageURLIn applies the In predicate on the "imageURL" field.
func ImageURLIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldImageURL), v...))
	})
}

// ImageURLNotIn applies the NotIn predicate on the "imageURL" field.
func ImageURLNotIn(vs ...string) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldImageURL), v...))
	})
}

// ImageURLGT applies the GT predicate on the "imageURL" field.
func ImageURLGT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldImageURL), v))
	})
}

// ImageURLGTE applies the GTE predicate on the "imageURL" field.
func ImageURLGTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldImageURL), v))
	})
}

// ImageURLLT applies the LT predicate on the "imageURL" field.
func ImageURLLT(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldImageURL), v))
	})
}

// ImageURLLTE applies the LTE predicate on the "imageURL" field.
func ImageURLLTE(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldImageURL), v))
	})
}

// ImageURLContains applies the Contains predicate on the "imageURL" field.
func ImageURLContains(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldImageURL), v))
	})
}

// ImageURLHasPrefix applies the HasPrefix predicate on the "imageURL" field.
func ImageURLHasPrefix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldImageURL), v))
	})
}

// ImageURLHasSuffix applies the HasSuffix predicate on the "imageURL" field.
func ImageURLHasSuffix(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldImageURL), v))
	})
}

// ImageURLEqualFold applies the EqualFold predicate on the "imageURL" field.
func ImageURLEqualFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldImageURL), v))
	})
}

// ImageURLContainsFold applies the ContainsFold predicate on the "imageURL" field.
func ImageURLContainsFold(v string) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldImageURL), v))
	})
}

// UserIdEQ applies the EQ predicate on the "userId" field.
func UserIdEQ(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldUserId), v))
	})
}

// UserIdNEQ applies the NEQ predicate on the "userId" field.
func UserIdNEQ(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldUserId), v))
	})
}

// UserIdIn applies the In predicate on the "userId" field.
func UserIdIn(vs ...int64) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldUserId), v...))
	})
}

// UserIdNotIn applies the NotIn predicate on the "userId" field.
func UserIdNotIn(vs ...int64) predicate.Thought {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Thought(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldUserId), v...))
	})
}

// UserIdGT applies the GT predicate on the "userId" field.
func UserIdGT(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldUserId), v))
	})
}

// UserIdGTE applies the GTE predicate on the "userId" field.
func UserIdGTE(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldUserId), v))
	})
}

// UserIdLT applies the LT predicate on the "userId" field.
func UserIdLT(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldUserId), v))
	})
}

// UserIdLTE applies the LTE predicate on the "userId" field.
func UserIdLTE(v int64) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldUserId), v))
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Not applies the not operator on the given predicate.
func Not(p predicate.Thought) predicate.Thought {
	return predicate.Thought(func(s *sql.Selector) {
		p(s.Not())
	})
}
