food.pb.pgdb.go

// Code generated by protoc-gen-pgdb 0.1.0 from models/food/v1/food.proto. DO NOT EDIT
package v1

import (
	"strings"

	"net/netip"
	"time"

	llm_v1 "github.com/ductone/protoc-gen-pgdb/example/models/llm/v1"

	"github.com/doug-martin/goqu/v9/exp"
	pgdb_v1 "github.com/ductone/protoc-gen-pgdb/pgdb/v1"
	"github.com/ductone/protoc-gen-pgdb/pgdb/v1/xpq"
	"google.golang.org/protobuf/proto"
)

type pgdbDescriptorPasta struct{}

var (
	instancepgdbDescriptorPasta pgdb_v1.Descriptor = &pgdbDescriptorPasta{}
)

func (d *pgdbDescriptorPasta) TableName() string {
	return "pb_pasta_models_food_v1_29fd1107"
}

func (d *pgdbDescriptorPasta) IsPartitioned() bool {
	return true
}

func (d *pgdbDescriptorPasta) Fields(opts ...pgdb_v1.DescriptorFieldOptionFunc) []*pgdb_v1.Column {
	df := pgdb_v1.NewDescriptorFieldOption(opts)
	_ = df

	rv := make([]*pgdb_v1.Column, 0)

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("tenant_id"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pksk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "varchar GENERATED ALWAYS AS (pb$pk || '|' || pb$sk) STORED",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("sk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("fts_data"),
			Type:               "tsvector",
			Nullable:           df.Nullable(true),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pb_data"),
			Type:               "bytea",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("id"),
		Type:               "text",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "''",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("created_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("updated_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("deleted_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	return rv
}

func (d *pgdbDescriptorPasta) PKSKField() *pgdb_v1.Column {
	return &pgdb_v1.Column{
		Table: "pb_pasta_models_food_v1_29fd1107",
		Name:  "pb$pksk",
		Type:  "varchar",
	}
}

func (d *pgdbDescriptorPasta) DataField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_models_food_v1_29fd1107", Name: "pb$pb_data", Type: "bytea"}
}

func (d *pgdbDescriptorPasta) SearchField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_models_food_v1_29fd1107", Name: "pb$fts_data", Type: "tsvector"}
}

func (d *pgdbDescriptorPasta) VersioningField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_models_food_v1_29fd1107", Name: "pb$updated_at", Type: "timestamptz"}
}

func (d *pgdbDescriptorPasta) TenantField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_models_food_v1_29fd1107", Name: "pb$tenant_id", Type: "varchar"}
}

func (d *pgdbDescriptorPasta) IndexPrimaryKey(opts ...pgdb_v1.IndexOptionsFunc) *pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io

	return &pgdb_v1.Index{
		Name:               io.IndexName("pksk_pasta_models_food_v1_441e44c9"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          true,
		IsUnique:           true,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
		OverrideExpression: "",
	}

}

func (d *pgdbDescriptorPasta) Indexes(opts ...pgdb_v1.IndexOptionsFunc) []*pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io
	rv := make([]*pgdb_v1.Index, 0)

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_pasta_models_food_v1_441e44c9"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          true,
			IsUnique:           true,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split_pasta_models_food_v1_4c4cc274"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          true,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split2_pasta_models_food_v1_65c526aa"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("fts_data_pasta_models_food_v1_77400ba0"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE_GIN,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("fts_data")},
			OverrideExpression: "",
		})

	}

	return rv
}

func (d *pgdbDescriptorPasta) Statistics(opts ...pgdb_v1.StatisticOptionsFunc) []*pgdb_v1.Statistic {
	io := pgdb_v1.NewStatisticOption(opts)
	_ = io
	rv := make([]*pgdb_v1.Statistic, 0)

	return rv
}

type pgdbMessagePasta struct {
	self *Pasta
}

func (dbr *Pasta) DBReflect() pgdb_v1.Message {
	return &pgdbMessagePasta{
		self: dbr,
	}
}

func (m *pgdbMessagePasta) Descriptor() pgdb_v1.Descriptor {
	return instancepgdbDescriptorPasta
}

func (m *pgdbMessagePasta) Record(opts ...pgdb_v1.RecordOptionsFunc) (exp.Record, error) {
	ro := pgdb_v1.NewRecordOptions(opts)
	_ = ro
	nullExp := exp.NewLiteralExpression("NULL")
	_ = nullExp

	var sb strings.Builder

	rv := exp.Record{}

	if !ro.IsNested {

		cfv0 := string(m.self.TenantId)

		if ro.Nulled {
			rv[ro.ColumnName("tenant_id")] = nullExp
		} else {
			rv[ro.ColumnName("tenant_id")] = cfv0
		}

	}

	if !ro.IsNested {

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("models_food_v1_pasta")

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.TenantId)

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.Id)

		cfv2 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("pk")] = nullExp
		} else {
			rv[ro.ColumnName("pk")] = cfv2
		}

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("example")

		cfv3 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("sk")] = nullExp
		} else {
			rv[ro.ColumnName("sk")] = cfv3
		}

	}

	if !ro.IsNested {

		cfv4tmp := []*pgdb_v1.SearchContent{

			{
				Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
				Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
				Value:  m.self.GetId(),
			},
		}

		cfv4 := pgdb_v1.FullTextSearchVectors(cfv4tmp)

		if ro.Nulled {
			rv[ro.ColumnName("fts_data")] = nullExp
		} else {
			rv[ro.ColumnName("fts_data")] = cfv4
		}

	}

	if !ro.IsNested {

		cfv5, err := proto.Marshal(m.self)
		if err != nil {
			return nil, err
		}

		if ro.Nulled {
			rv[ro.ColumnName("pb_data")] = nullExp
		} else {
			rv[ro.ColumnName("pb_data")] = cfv5
		}

	}

	v1 := string(m.self.GetId())

	if ro.Nulled {
		rv[ro.ColumnName("id")] = nullExp
	} else {
		rv[ro.ColumnName("id")] = v1
	}

	var v2 *time.Time
	if m.self.GetCreatedAt().IsValid() {
		v2tmp := m.self.GetCreatedAt().AsTime()
		v2 = &v2tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("created_at")] = nullExp
	} else {
		rv[ro.ColumnName("created_at")] = v2
	}

	var v3 *time.Time
	if m.self.GetUpdatedAt().IsValid() {
		v3tmp := m.self.GetUpdatedAt().AsTime()
		v3 = &v3tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("updated_at")] = nullExp
	} else {
		rv[ro.ColumnName("updated_at")] = v3
	}

	var v4 *time.Time
	if m.self.GetDeletedAt().IsValid() {
		v4tmp := m.self.GetDeletedAt().AsTime()
		v4 = &v4tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("deleted_at")] = nullExp
	} else {
		rv[ro.ColumnName("deleted_at")] = v4
	}

	return rv, nil
}

func (m *pgdbMessagePasta) SearchData(opts ...pgdb_v1.RecordOptionsFunc) []*pgdb_v1.SearchContent {
	rv := []*pgdb_v1.SearchContent{

		{
			Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
			Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
			Value:  m.self.GetId(),
		},
	}

	return rv
}

type PastaDB struct {
	tableName string
}

type PastaDBQueryBuilder struct {
	tableName string
}

type PastaDBQueryUnsafe struct {
	tableName string
}

type PastaDBColumns struct {
	tableName string
}

func (x *Pasta) DB() *PastaDB {
	return &PastaDB{tableName: x.DBReflect().Descriptor().TableName()}
}

func (x *PastaDB) TableName() string {
	return x.tableName
}

func (x *PastaDB) Query() *PastaDBQueryBuilder {
	return &PastaDBQueryBuilder{tableName: x.tableName}
}

func (x *PastaDB) Columns() *PastaDBColumns {
	return &PastaDBColumns{tableName: x.tableName}
}

func (x *PastaDB) WithTable(t string) *PastaDB {
	return &PastaDB{tableName: t}
}

func (x *PastaDBQueryBuilder) WithTable(t string) *PastaDBQueryBuilder {
	return &PastaDBQueryBuilder{tableName: t}
}

func (x *PastaDBQueryBuilder) Unsafe() *PastaDBQueryUnsafe {
	return &PastaDBQueryUnsafe{tableName: x.tableName}
}

type PastaTenantIdSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaTenantIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaTenantIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaTenantIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaTenantIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaTenantIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaTenantIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaTenantIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaTenantIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaTenantIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaTenantIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaTenantIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaTenantIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaTenantIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaDBQueryBuilder) TenantId() *PastaTenantIdSafeOperators {
	return &PastaTenantIdSafeOperators{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

type PastaPKSKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaPKSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaPKSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaPKSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaPKSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaPKSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaPKSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaPKSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaPKSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaPKSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaPKSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaPKSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaPKSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaPKSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaDBQueryBuilder) PKSK() *PastaPKSKSafeOperators {
	return &PastaPKSKSafeOperators{tableName: x.tableName, column: "pb$" + "pksk"}
}

type PastaPKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaPKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaPKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaPKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaPKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaPKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaPKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaPKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaPKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaPKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaPKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaPKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaPKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaPKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaDBQueryBuilder) PK() *PastaPKSafeOperators {
	return &PastaPKSafeOperators{tableName: x.tableName, column: "pb$" + "pk"}
}

type PastaSKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaDBQueryBuilder) SK() *PastaSKSafeOperators {
	return &PastaSKSafeOperators{tableName: x.tableName, column: "pb$" + "sk"}
}

type PastaFTSDataSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaFTSDataSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaFTSDataSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaDBQueryBuilder) FTSData() *PastaFTSDataSafeOperators {
	return &PastaFTSDataSafeOperators{tableName: x.tableName, column: "pb$" + "fts_data"}
}

type PastaTenantIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) TenantId() *PastaTenantIdQueryType {
	return &PastaTenantIdQueryType{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

func (x *PastaTenantIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaPKSKQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) PKSK() *PastaPKSKQueryType {
	return &PastaPKSKQueryType{tableName: x.tableName, column: "pb$" + "pksk"}
}

func (x *PastaPKSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaPKQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) PK() *PastaPKQueryType {
	return &PastaPKQueryType{tableName: x.tableName, column: "pb$" + "pk"}
}

func (x *PastaPKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaSKQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) SK() *PastaSKQueryType {
	return &PastaSKQueryType{tableName: x.tableName, column: "pb$" + "sk"}
}

func (x *PastaSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaFTSDataQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) FTSData() *PastaFTSDataQueryType {
	return &PastaFTSDataQueryType{tableName: x.tableName, column: "pb$" + "fts_data"}
}

func (x *PastaFTSDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaPBDataQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) PBData() *PastaPBDataQueryType {
	return &PastaPBDataQueryType{tableName: x.tableName, column: "pb$" + "pb_data"}
}

func (x *PastaPBDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) Id() *PastaIdQueryType {
	return &PastaIdQueryType{tableName: x.tableName, column: "pb$" + "id"}
}

func (x *PastaIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaCreatedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) CreatedAt() *PastaCreatedAtQueryType {
	return &PastaCreatedAtQueryType{tableName: x.tableName, column: "pb$" + "created_at"}
}

func (x *PastaCreatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaUpdatedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) UpdatedAt() *PastaUpdatedAtQueryType {
	return &PastaUpdatedAtQueryType{tableName: x.tableName, column: "pb$" + "updated_at"}
}

func (x *PastaUpdatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaDeletedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaDBQueryUnsafe) DeletedAt() *PastaDeletedAtQueryType {
	return &PastaDeletedAtQueryType{tableName: x.tableName, column: "pb$" + "deleted_at"}
}

func (x *PastaDeletedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaDBColumns) WithTable(t string) *PastaDBColumns {
	return &PastaDBColumns{tableName: t}
}

func (x *PastaDBColumns) TenantId() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "tenant_id")
}

func (x *PastaDBColumns) PKSK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pksk")
}

func (x *PastaDBColumns) PK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pk")
}

func (x *PastaDBColumns) SK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "sk")
}

func (x *PastaDBColumns) FTSData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "fts_data")
}

func (x *PastaDBColumns) PBData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pb_data")
}

func (x *PastaDBColumns) Id() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "id")
}

func (x *PastaDBColumns) CreatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "created_at")
}

func (x *PastaDBColumns) UpdatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "updated_at")
}

func (x *PastaDBColumns) DeletedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "deleted_at")
}

type pgdbDescriptorPastaIngredient struct{}

var (
	instancepgdbDescriptorPastaIngredient pgdb_v1.Descriptor = &pgdbDescriptorPastaIngredient{}
)

func (d *pgdbDescriptorPastaIngredient) TableName() string {
	return "pb_pasta_ingredient_models_food_v1_0565c036"
}

func (d *pgdbDescriptorPastaIngredient) IsPartitioned() bool {
	return true
}

func (d *pgdbDescriptorPastaIngredient) Fields(opts ...pgdb_v1.DescriptorFieldOptionFunc) []*pgdb_v1.Column {
	df := pgdb_v1.NewDescriptorFieldOption(opts)
	_ = df

	rv := make([]*pgdb_v1.Column, 0)

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("tenant_id"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pksk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "varchar GENERATED ALWAYS AS (pb$pk || '|' || pb$sk) STORED",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("sk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("fts_data"),
			Type:               "tsvector",
			Nullable:           df.Nullable(true),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pb_data"),
			Type:               "bytea",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("model_embeddings_1"),
			Type:               "vector",
			Nullable:           df.Nullable(true),
			OverrideExpression: "vector(3)",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("model_embeddings_2"),
			Type:               "vector",
			Nullable:           df.Nullable(true),
			OverrideExpression: "vector(4)",
			Default:            "",
		})

	}

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("ingredient_id"),
		Type:               "text",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "''",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("created_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("updated_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("deleted_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("pasta_id"),
		Type:               "text",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "''",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("id"),
		Type:               "text",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "''",
	})

	return rv
}

func (d *pgdbDescriptorPastaIngredient) PKSKField() *pgdb_v1.Column {
	return &pgdb_v1.Column{
		Table: "pb_pasta_ingredient_models_food_v1_0565c036",
		Name:  "pb$pksk",
		Type:  "varchar",
	}
}

func (d *pgdbDescriptorPastaIngredient) DataField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_ingredient_models_food_v1_0565c036", Name: "pb$pb_data", Type: "bytea"}
}

func (d *pgdbDescriptorPastaIngredient) SearchField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_ingredient_models_food_v1_0565c036", Name: "pb$fts_data", Type: "tsvector"}
}

func (d *pgdbDescriptorPastaIngredient) VersioningField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_ingredient_models_food_v1_0565c036", Name: "pb$updated_at", Type: "timestamptz"}
}

func (d *pgdbDescriptorPastaIngredient) TenantField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_pasta_ingredient_models_food_v1_0565c036", Name: "pb$tenant_id", Type: "varchar"}
}

func (d *pgdbDescriptorPastaIngredient) IndexPrimaryKey(opts ...pgdb_v1.IndexOptionsFunc) *pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io

	return &pgdb_v1.Index{
		Name:               io.IndexName("pksk_pasta_ingredient_models_food_v1_401e5d6d"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          true,
		IsUnique:           true,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
		OverrideExpression: "",
	}

}

func (d *pgdbDescriptorPastaIngredient) Indexes(opts ...pgdb_v1.IndexOptionsFunc) []*pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io
	rv := make([]*pgdb_v1.Index, 0)

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_pasta_ingredient_models_food_v1_401e5d6d"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          true,
			IsUnique:           true,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split_pasta_ingredient_models_food_3a6d51a9"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          true,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split2_pasta_ingredient_models_foo_abfc90b5"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("fts_data_pasta_ingredient_models_food_v_39d92e94"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE_GIN,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("fts_data")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("vector_index_model_3dims_pasta_ingredie_c7c366c4"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_HNSW_COSINE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("model_embeddings_1")},
			OverrideExpression: "pb$model_embeddings_1 vector_cosine_ops",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("vector_index_model_4dims_pasta_ingredie_e01d008e"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_HNSW_COSINE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("model_embeddings_2")},
			OverrideExpression: "pb$model_embeddings_2 vector_cosine_ops",
		})

	}

	rv = append(rv, &pgdb_v1.Index{
		Name:               io.IndexName("pastas_pasta_ingredient_models_food_v1_e3bd47ef"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          false,
		IsUnique:           false,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pasta_id"), io.ColumnName("id")},
		OverrideExpression: "",
	})

	rv = append(rv, &pgdb_v1.Index{
		Name:               io.IndexName("ingredients_pasta_ingredient_models_foo_cc57095e"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          false,
		IsUnique:           false,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("ingredient_id"), io.ColumnName("id")},
		OverrideExpression: "",
	})

	rv = append(rv, &pgdb_v1.Index{
		Name:               io.IndexName("everythingggg_pasta_ingredient_models_f_30c0b1c3"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          false,
		IsUnique:           false,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("ingredient_id"), io.ColumnName("pasta_id"), io.ColumnName("id")},
		OverrideExpression: "",
	})

	return rv
}

func (d *pgdbDescriptorPastaIngredient) Statistics(opts ...pgdb_v1.StatisticOptionsFunc) []*pgdb_v1.Statistic {
	io := pgdb_v1.NewStatisticOption(opts)
	_ = io
	rv := make([]*pgdb_v1.Statistic, 0)

	rv = append(rv, &pgdb_v1.Statistic{
		Name:      io.StatsName("tenant_id_ingredient_id_pasta_ingredien_1990f7e0"),
		IsDropped: false,
		Kinds:     []pgdb_v1.MessageOptions_Stat_StatsKind{},
		Columns:   []string{io.ColumnName("tenant_id"), io.ColumnName("ingredient_id")},
	})

	return rv
}

type pgdbMessagePastaIngredient struct {
	self *PastaIngredient
}

func (dbr *PastaIngredient) DBReflect() pgdb_v1.Message {
	return &pgdbMessagePastaIngredient{
		self: dbr,
	}
}

func (m *pgdbMessagePastaIngredient) Descriptor() pgdb_v1.Descriptor {
	return instancepgdbDescriptorPastaIngredient
}

func (m *pgdbMessagePastaIngredient) Record(opts ...pgdb_v1.RecordOptionsFunc) (exp.Record, error) {
	ro := pgdb_v1.NewRecordOptions(opts)
	_ = ro
	nullExp := exp.NewLiteralExpression("NULL")
	_ = nullExp

	var sb strings.Builder

	rv := exp.Record{}

	if !ro.IsNested {

		cfv0 := string(m.self.TenantId)

		if ro.Nulled {
			rv[ro.ColumnName("tenant_id")] = nullExp
		} else {
			rv[ro.ColumnName("tenant_id")] = cfv0
		}

	}

	if !ro.IsNested {

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("models_food_v1_pasta_ingredient")

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.TenantId)

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.PastaId)

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.IngredientId)

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.Id)

		cfv2 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("pk")] = nullExp
		} else {
			rv[ro.ColumnName("pk")] = cfv2
		}

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("exampleingredient")

		cfv3 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("sk")] = nullExp
		} else {
			rv[ro.ColumnName("sk")] = cfv3
		}

	}

	if !ro.IsNested {

		cfv4tmp := []*pgdb_v1.SearchContent{

			{
				Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
				Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
				Value:  m.self.GetPastaId(),
			},

			{
				Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
				Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
				Value:  m.self.GetId(),
			},
		}

		cfv4 := pgdb_v1.FullTextSearchVectors(cfv4tmp)

		if ro.Nulled {
			rv[ro.ColumnName("fts_data")] = nullExp
		} else {
			rv[ro.ColumnName("fts_data")] = cfv4
		}

	}

	if !ro.IsNested {

		cfv5, err := proto.Marshal(m.self)
		if err != nil {
			return nil, err
		}

		if ro.Nulled {
			rv[ro.ColumnName("pb_data")] = nullExp
		} else {
			rv[ro.ColumnName("pb_data")] = cfv5
		}

	}

	if !ro.IsNested {

		var cfv5 interface{} = nullExp
		for _, v := range m.self.ModelEmbeddings {
			if v.Model != llm_v1.Model_MODEL_3DIMS {
				continue
			}
			if len(v.Embedding) == 0 {
				break
			}
			cfv5 = pgdb_v1.FloatToVector(v.Embedding)
		}

		if ro.Nulled {
			rv[ro.ColumnName("model_embeddings_1")] = nullExp
		} else {
			rv[ro.ColumnName("model_embeddings_1")] = cfv5
		}

	}

	if !ro.IsNested {

		var cfv5 interface{} = nullExp
		for _, v := range m.self.ModelEmbeddings {
			if v.Model != llm_v1.Model_MODEL_4DIMS {
				continue
			}
			if len(v.Embedding) == 0 {
				break
			}
			cfv5 = pgdb_v1.FloatToVector(v.Embedding)
		}

		if ro.Nulled {
			rv[ro.ColumnName("model_embeddings_2")] = nullExp
		} else {
			rv[ro.ColumnName("model_embeddings_2")] = cfv5
		}

	}

	v1 := string(m.self.GetIngredientId())

	if ro.Nulled {
		rv[ro.ColumnName("ingredient_id")] = nullExp
	} else {
		rv[ro.ColumnName("ingredient_id")] = v1
	}

	var v2 *time.Time
	if m.self.GetCreatedAt().IsValid() {
		v2tmp := m.self.GetCreatedAt().AsTime()
		v2 = &v2tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("created_at")] = nullExp
	} else {
		rv[ro.ColumnName("created_at")] = v2
	}

	var v3 *time.Time
	if m.self.GetUpdatedAt().IsValid() {
		v3tmp := m.self.GetUpdatedAt().AsTime()
		v3 = &v3tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("updated_at")] = nullExp
	} else {
		rv[ro.ColumnName("updated_at")] = v3
	}

	var v4 *time.Time
	if m.self.GetDeletedAt().IsValid() {
		v4tmp := m.self.GetDeletedAt().AsTime()
		v4 = &v4tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("deleted_at")] = nullExp
	} else {
		rv[ro.ColumnName("deleted_at")] = v4
	}

	v5 := string(m.self.GetPastaId())

	if ro.Nulled {
		rv[ro.ColumnName("pasta_id")] = nullExp
	} else {
		rv[ro.ColumnName("pasta_id")] = v5
	}

	v6 := string(m.self.GetId())

	if ro.Nulled {
		rv[ro.ColumnName("id")] = nullExp
	} else {
		rv[ro.ColumnName("id")] = v6
	}

	return rv, nil
}

func (m *pgdbMessagePastaIngredient) SearchData(opts ...pgdb_v1.RecordOptionsFunc) []*pgdb_v1.SearchContent {
	rv := []*pgdb_v1.SearchContent{

		{
			Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
			Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
			Value:  m.self.GetPastaId(),
		},

		{
			Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
			Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
			Value:  m.self.GetId(),
		},
	}

	return rv
}

type PastaIngredientDB struct {
	tableName string
}

type PastaIngredientDBQueryBuilder struct {
	tableName string
}

type PastaIngredientDBQueryUnsafe struct {
	tableName string
}

type PastaIngredientDBColumns struct {
	tableName string
}

func (x *PastaIngredient) DB() *PastaIngredientDB {
	return &PastaIngredientDB{tableName: x.DBReflect().Descriptor().TableName()}
}

func (x *PastaIngredientDB) TableName() string {
	return x.tableName
}

func (x *PastaIngredientDB) Query() *PastaIngredientDBQueryBuilder {
	return &PastaIngredientDBQueryBuilder{tableName: x.tableName}
}

func (x *PastaIngredientDB) Columns() *PastaIngredientDBColumns {
	return &PastaIngredientDBColumns{tableName: x.tableName}
}

func (x *PastaIngredientDB) WithTable(t string) *PastaIngredientDB {
	return &PastaIngredientDB{tableName: t}
}

func (x *PastaIngredientDBQueryBuilder) WithTable(t string) *PastaIngredientDBQueryBuilder {
	return &PastaIngredientDBQueryBuilder{tableName: t}
}

func (x *PastaIngredientDBQueryBuilder) Unsafe() *PastaIngredientDBQueryUnsafe {
	return &PastaIngredientDBQueryUnsafe{tableName: x.tableName}
}

type PastaIngredientTenantIdSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientTenantIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientTenantIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientTenantIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientTenantIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientTenantIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientTenantIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientTenantIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientTenantIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientTenantIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientTenantIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientTenantIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientTenantIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientTenantIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) TenantId() *PastaIngredientTenantIdSafeOperators {
	return &PastaIngredientTenantIdSafeOperators{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

type PastaIngredientPKSKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientPKSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientPKSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientPKSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientPKSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientPKSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientPKSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientPKSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientPKSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientPKSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientPKSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientPKSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientPKSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientPKSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) PKSK() *PastaIngredientPKSKSafeOperators {
	return &PastaIngredientPKSKSafeOperators{tableName: x.tableName, column: "pb$" + "pksk"}
}

type PastaIngredientPKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientPKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientPKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientPKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientPKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientPKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientPKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientPKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientPKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientPKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientPKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientPKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientPKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientPKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) PK() *PastaIngredientPKSafeOperators {
	return &PastaIngredientPKSafeOperators{tableName: x.tableName, column: "pb$" + "pk"}
}

type PastaIngredientSKSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) SK() *PastaIngredientSKSafeOperators {
	return &PastaIngredientSKSafeOperators{tableName: x.tableName, column: "pb$" + "sk"}
}

type PastaIngredientFTSDataSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientFTSDataSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientFTSDataSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientDBQueryBuilder) FTSData() *PastaIngredientFTSDataSafeOperators {
	return &PastaIngredientFTSDataSafeOperators{tableName: x.tableName, column: "pb$" + "fts_data"}
}

type PastaIngredientModelEmbeddings_3DIMSSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientModelEmbeddings_3DIMSSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientDBQueryBuilder) ModelEmbeddings_3DIMS() *PastaIngredientModelEmbeddings_3DIMSSafeOperators {
	return &PastaIngredientModelEmbeddings_3DIMSSafeOperators{tableName: x.tableName, column: "pb$" + "model_embeddings_1"}
}

type PastaIngredientModelEmbeddings_4DIMSSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientModelEmbeddings_4DIMSSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientDBQueryBuilder) ModelEmbeddings_4DIMS() *PastaIngredientModelEmbeddings_4DIMSSafeOperators {
	return &PastaIngredientModelEmbeddings_4DIMSSafeOperators{tableName: x.tableName, column: "pb$" + "model_embeddings_2"}
}

type PastaIngredientIngredientIdSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientIngredientIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientIngredientIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientIngredientIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientIngredientIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientIngredientIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientIngredientIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientIngredientIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) IngredientId() *PastaIngredientIngredientIdSafeOperators {
	return &PastaIngredientIngredientIdSafeOperators{tableName: x.tableName, column: "pb$" + "ingredient_id"}
}

type PastaIngredientPastaIdSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientPastaIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientPastaIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientPastaIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientPastaIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientPastaIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientPastaIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientPastaIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientPastaIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientPastaIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientPastaIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientPastaIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientPastaIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientPastaIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) PastaId() *PastaIngredientPastaIdSafeOperators {
	return &PastaIngredientPastaIdSafeOperators{tableName: x.tableName, column: "pb$" + "pasta_id"}
}

type PastaIngredientIdSafeOperators struct {
	column    string
	tableName string
}

func (x *PastaIngredientIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *PastaIngredientIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *PastaIngredientIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *PastaIngredientIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *PastaIngredientIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *PastaIngredientIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *PastaIngredientIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *PastaIngredientIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *PastaIngredientIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *PastaIngredientIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *PastaIngredientIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *PastaIngredientDBQueryBuilder) Id() *PastaIngredientIdSafeOperators {
	return &PastaIngredientIdSafeOperators{tableName: x.tableName, column: "pb$" + "id"}
}

type PastaIngredientTenantIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) TenantId() *PastaIngredientTenantIdQueryType {
	return &PastaIngredientTenantIdQueryType{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

func (x *PastaIngredientTenantIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientPKSKQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) PKSK() *PastaIngredientPKSKQueryType {
	return &PastaIngredientPKSKQueryType{tableName: x.tableName, column: "pb$" + "pksk"}
}

func (x *PastaIngredientPKSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientPKQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) PK() *PastaIngredientPKQueryType {
	return &PastaIngredientPKQueryType{tableName: x.tableName, column: "pb$" + "pk"}
}

func (x *PastaIngredientPKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientSKQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) SK() *PastaIngredientSKQueryType {
	return &PastaIngredientSKQueryType{tableName: x.tableName, column: "pb$" + "sk"}
}

func (x *PastaIngredientSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientFTSDataQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) FTSData() *PastaIngredientFTSDataQueryType {
	return &PastaIngredientFTSDataQueryType{tableName: x.tableName, column: "pb$" + "fts_data"}
}

func (x *PastaIngredientFTSDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientPBDataQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) PBData() *PastaIngredientPBDataQueryType {
	return &PastaIngredientPBDataQueryType{tableName: x.tableName, column: "pb$" + "pb_data"}
}

func (x *PastaIngredientPBDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientModelEmbeddings_3DIMSQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) ModelEmbeddings_3DIMS() *PastaIngredientModelEmbeddings_3DIMSQueryType {
	return &PastaIngredientModelEmbeddings_3DIMSQueryType{tableName: x.tableName, column: "pb$" + "model_embeddings_1"}
}

func (x *PastaIngredientModelEmbeddings_3DIMSQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientModelEmbeddings_4DIMSQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) ModelEmbeddings_4DIMS() *PastaIngredientModelEmbeddings_4DIMSQueryType {
	return &PastaIngredientModelEmbeddings_4DIMSQueryType{tableName: x.tableName, column: "pb$" + "model_embeddings_2"}
}

func (x *PastaIngredientModelEmbeddings_4DIMSQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientIngredientIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) IngredientId() *PastaIngredientIngredientIdQueryType {
	return &PastaIngredientIngredientIdQueryType{tableName: x.tableName, column: "pb$" + "ingredient_id"}
}

func (x *PastaIngredientIngredientIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientCreatedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) CreatedAt() *PastaIngredientCreatedAtQueryType {
	return &PastaIngredientCreatedAtQueryType{tableName: x.tableName, column: "pb$" + "created_at"}
}

func (x *PastaIngredientCreatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientUpdatedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) UpdatedAt() *PastaIngredientUpdatedAtQueryType {
	return &PastaIngredientUpdatedAtQueryType{tableName: x.tableName, column: "pb$" + "updated_at"}
}

func (x *PastaIngredientUpdatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientDeletedAtQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) DeletedAt() *PastaIngredientDeletedAtQueryType {
	return &PastaIngredientDeletedAtQueryType{tableName: x.tableName, column: "pb$" + "deleted_at"}
}

func (x *PastaIngredientDeletedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientPastaIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) PastaId() *PastaIngredientPastaIdQueryType {
	return &PastaIngredientPastaIdQueryType{tableName: x.tableName, column: "pb$" + "pasta_id"}
}

func (x *PastaIngredientPastaIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredientIdQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredientDBQueryUnsafe) Id() *PastaIngredientIdQueryType {
	return &PastaIngredientIdQueryType{tableName: x.tableName, column: "pb$" + "id"}
}

func (x *PastaIngredientIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredientDBColumns) WithTable(t string) *PastaIngredientDBColumns {
	return &PastaIngredientDBColumns{tableName: t}
}

func (x *PastaIngredientDBColumns) TenantId() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "tenant_id")
}

func (x *PastaIngredientDBColumns) PKSK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pksk")
}

func (x *PastaIngredientDBColumns) PK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pk")
}

func (x *PastaIngredientDBColumns) SK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "sk")
}

func (x *PastaIngredientDBColumns) FTSData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "fts_data")
}

func (x *PastaIngredientDBColumns) PBData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pb_data")
}

func (x *PastaIngredientDBColumns) ModelEmbeddings_3DIMS() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "model_embeddings_1")
}

func (x *PastaIngredientDBColumns) ModelEmbeddings_4DIMS() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "model_embeddings_2")
}

func (x *PastaIngredientDBColumns) IngredientId() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "ingredient_id")
}

func (x *PastaIngredientDBColumns) CreatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "created_at")
}

func (x *PastaIngredientDBColumns) UpdatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "updated_at")
}

func (x *PastaIngredientDBColumns) DeletedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "deleted_at")
}

func (x *PastaIngredientDBColumns) PastaId() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pasta_id")
}

func (x *PastaIngredientDBColumns) Id() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "id")
}

type pgdbDescriptorSauceIngredient struct{}

var (
	instancepgdbDescriptorSauceIngredient pgdb_v1.Descriptor = &pgdbDescriptorSauceIngredient{}
)

func (d *pgdbDescriptorSauceIngredient) TableName() string {
	return "pb_sauce_ingredient_models_food_v1_e37b4524"
}

func (d *pgdbDescriptorSauceIngredient) IsPartitioned() bool {
	return false
}

func (d *pgdbDescriptorSauceIngredient) Fields(opts ...pgdb_v1.DescriptorFieldOptionFunc) []*pgdb_v1.Column {
	df := pgdb_v1.NewDescriptorFieldOption(opts)
	_ = df

	rv := make([]*pgdb_v1.Column, 0)

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("tenant_id"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pksk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "varchar GENERATED ALWAYS AS (pb$pk || '|' || pb$sk) STORED",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("sk"),
			Type:               "varchar",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("fts_data"),
			Type:               "tsvector",
			Nullable:           df.Nullable(true),
			OverrideExpression: "",
			Default:            "",
		})

	}

	if !df.IsNested {

		rv = append(rv, &pgdb_v1.Column{
			Name:               df.ColumnName("pb_data"),
			Type:               "bytea",
			Nullable:           df.Nullable(false),
			OverrideExpression: "",
			Default:            "",
		})

	}

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("id"),
		Type:               "text",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "''",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("created_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("updated_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("deleted_at"),
		Type:               "timestamptz",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("source_addr"),
		Type:               "inet",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "NULL",
	})

	return rv
}

func (d *pgdbDescriptorSauceIngredient) PKSKField() *pgdb_v1.Column {
	return &pgdb_v1.Column{
		Table: "pb_sauce_ingredient_models_food_v1_e37b4524",
		Name:  "pb$pksk",
		Type:  "varchar",
	}
}

func (d *pgdbDescriptorSauceIngredient) DataField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_sauce_ingredient_models_food_v1_e37b4524", Name: "pb$pb_data", Type: "bytea"}
}

func (d *pgdbDescriptorSauceIngredient) SearchField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_sauce_ingredient_models_food_v1_e37b4524", Name: "pb$fts_data", Type: "tsvector"}
}

func (d *pgdbDescriptorSauceIngredient) VersioningField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_sauce_ingredient_models_food_v1_e37b4524", Name: "pb$updated_at", Type: "timestamptz"}
}

func (d *pgdbDescriptorSauceIngredient) TenantField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_sauce_ingredient_models_food_v1_e37b4524", Name: "pb$tenant_id", Type: "varchar"}
}

func (d *pgdbDescriptorSauceIngredient) IndexPrimaryKey(opts ...pgdb_v1.IndexOptionsFunc) *pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io

	return &pgdb_v1.Index{
		Name:               io.IndexName("pksk_sauce_ingredient_models_food_v1_86464d5b"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          true,
		IsUnique:           true,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
		OverrideExpression: "",
	}

}

func (d *pgdbDescriptorSauceIngredient) Indexes(opts ...pgdb_v1.IndexOptionsFunc) []*pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io
	rv := make([]*pgdb_v1.Index, 0)

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_sauce_ingredient_models_food_v1_86464d5b"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          true,
			IsUnique:           true,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pksk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split_sauce_ingredient_models_food_b82c5af3"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          true,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("pksk_split2_sauce_ingredient_models_foo_b576dd2d"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("pk"), io.ColumnName("sk")},
			OverrideExpression: "",
		})

	}

	if !io.IsNested {

		rv = append(rv, &pgdb_v1.Index{
			Name:               io.IndexName("fts_data_sauce_ingredient_models_food_v_43892256"),
			Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE_GIN,
			IsPrimary:          false,
			IsUnique:           false,
			IsDropped:          false,
			Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("fts_data")},
			OverrideExpression: "",
		})

	}

	rv = append(rv, &pgdb_v1.Index{
		Name:               io.IndexName("source_addr_index_sauce_ingredient_mode_af6b7a10"),
		Method:             pgdb_v1.MessageOptions_Index_INDEX_METHOD_BTREE,
		IsPrimary:          false,
		IsUnique:           false,
		IsDropped:          false,
		Columns:            []string{io.ColumnName("tenant_id"), io.ColumnName("source_addr")},
		OverrideExpression: "",
	})

	return rv
}

func (d *pgdbDescriptorSauceIngredient) Statistics(opts ...pgdb_v1.StatisticOptionsFunc) []*pgdb_v1.Statistic {
	io := pgdb_v1.NewStatisticOption(opts)
	_ = io
	rv := make([]*pgdb_v1.Statistic, 0)

	return rv
}

type pgdbMessageSauceIngredient struct {
	self *SauceIngredient
}

func (dbr *SauceIngredient) DBReflect() pgdb_v1.Message {
	return &pgdbMessageSauceIngredient{
		self: dbr,
	}
}

func (m *pgdbMessageSauceIngredient) Descriptor() pgdb_v1.Descriptor {
	return instancepgdbDescriptorSauceIngredient
}

func (m *pgdbMessageSauceIngredient) Record(opts ...pgdb_v1.RecordOptionsFunc) (exp.Record, error) {
	ro := pgdb_v1.NewRecordOptions(opts)
	_ = ro
	nullExp := exp.NewLiteralExpression("NULL")
	_ = nullExp

	var sb strings.Builder

	rv := exp.Record{}

	if !ro.IsNested {

		cfv0 := string(m.self.TenantId)

		if ro.Nulled {
			rv[ro.ColumnName("tenant_id")] = nullExp
		} else {
			rv[ro.ColumnName("tenant_id")] = cfv0
		}

	}

	if !ro.IsNested {

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("models_food_v1_sauce_ingredient")

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.TenantId)

		_, _ = sb.WriteString(":")

		_, _ = sb.WriteString(m.self.Id)

		cfv2 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("pk")] = nullExp
		} else {
			rv[ro.ColumnName("pk")] = cfv2
		}

	}

	if !ro.IsNested {

		sb.Reset()

		_, _ = sb.WriteString("examplesauce")

		cfv3 := sb.String()

		if ro.Nulled {
			rv[ro.ColumnName("sk")] = nullExp
		} else {
			rv[ro.ColumnName("sk")] = cfv3
		}

	}

	if !ro.IsNested {

		cfv4tmp := []*pgdb_v1.SearchContent{

			{
				Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
				Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
				Value:  m.self.GetId(),
			},
		}

		cfv4 := pgdb_v1.FullTextSearchVectors(cfv4tmp)

		if ro.Nulled {
			rv[ro.ColumnName("fts_data")] = nullExp
		} else {
			rv[ro.ColumnName("fts_data")] = cfv4
		}

	}

	if !ro.IsNested {

		cfv5, err := proto.Marshal(m.self)
		if err != nil {
			return nil, err
		}

		if ro.Nulled {
			rv[ro.ColumnName("pb_data")] = nullExp
		} else {
			rv[ro.ColumnName("pb_data")] = cfv5
		}

	}

	v1 := string(m.self.GetId())

	if ro.Nulled {
		rv[ro.ColumnName("id")] = nullExp
	} else {
		rv[ro.ColumnName("id")] = v1
	}

	var v2 *time.Time
	if m.self.GetCreatedAt().IsValid() {
		v2tmp := m.self.GetCreatedAt().AsTime()
		v2 = &v2tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("created_at")] = nullExp
	} else {
		rv[ro.ColumnName("created_at")] = v2
	}

	var v3 *time.Time
	if m.self.GetUpdatedAt().IsValid() {
		v3tmp := m.self.GetUpdatedAt().AsTime()
		v3 = &v3tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("updated_at")] = nullExp
	} else {
		rv[ro.ColumnName("updated_at")] = v3
	}

	var v4 *time.Time
	if m.self.GetDeletedAt().IsValid() {
		v4tmp := m.self.GetDeletedAt().AsTime()
		v4 = &v4tmp
	}

	if ro.Nulled {
		rv[ro.ColumnName("deleted_at")] = nullExp
	} else {
		rv[ro.ColumnName("deleted_at")] = v4
	}

	var v5 *string
	if m.self.GetSourceAddr() != "" {
		v5tmp, err := netip.ParseAddr(m.self.GetSourceAddr())
		if err != nil {
			return nil, err
		}
		v5val := v5tmp.Unmap().String()
		v5 = &v5val
	}

	if ro.Nulled {
		rv[ro.ColumnName("source_addr")] = nullExp
	} else {
		rv[ro.ColumnName("source_addr")] = v5
	}

	return rv, nil
}

func (m *pgdbMessageSauceIngredient) SearchData(opts ...pgdb_v1.RecordOptionsFunc) []*pgdb_v1.SearchContent {
	rv := []*pgdb_v1.SearchContent{

		{
			Type:   pgdb_v1.FieldOptions_FULL_TEXT_TYPE_EXACT,
			Weight: pgdb_v1.FieldOptions_FULL_TEXT_WEIGHT_UNSPECIFIED,
			Value:  m.self.GetId(),
		},
	}

	return rv
}

type SauceIngredientDB struct {
	tableName string
}

type SauceIngredientDBQueryBuilder struct {
	tableName string
}

type SauceIngredientDBQueryUnsafe struct {
	tableName string
}

type SauceIngredientDBColumns struct {
	tableName string
}

func (x *SauceIngredient) DB() *SauceIngredientDB {
	return &SauceIngredientDB{tableName: x.DBReflect().Descriptor().TableName()}
}

func (x *SauceIngredientDB) TableName() string {
	return x.tableName
}

func (x *SauceIngredientDB) Query() *SauceIngredientDBQueryBuilder {
	return &SauceIngredientDBQueryBuilder{tableName: x.tableName}
}

func (x *SauceIngredientDB) Columns() *SauceIngredientDBColumns {
	return &SauceIngredientDBColumns{tableName: x.tableName}
}

func (x *SauceIngredientDB) WithTable(t string) *SauceIngredientDB {
	return &SauceIngredientDB{tableName: t}
}

func (x *SauceIngredientDBQueryBuilder) WithTable(t string) *SauceIngredientDBQueryBuilder {
	return &SauceIngredientDBQueryBuilder{tableName: t}
}

func (x *SauceIngredientDBQueryBuilder) Unsafe() *SauceIngredientDBQueryUnsafe {
	return &SauceIngredientDBQueryUnsafe{tableName: x.tableName}
}

type SauceIngredientTenantIdSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientTenantIdSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientTenantIdSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientTenantIdSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *SauceIngredientTenantIdSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *SauceIngredientTenantIdSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *SauceIngredientTenantIdSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *SauceIngredientTenantIdSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *SauceIngredientTenantIdSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *SauceIngredientTenantIdSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *SauceIngredientTenantIdSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *SauceIngredientTenantIdSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *SauceIngredientTenantIdSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientTenantIdSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientDBQueryBuilder) TenantId() *SauceIngredientTenantIdSafeOperators {
	return &SauceIngredientTenantIdSafeOperators{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

type SauceIngredientPKSKSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientPKSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientPKSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientPKSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *SauceIngredientPKSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *SauceIngredientPKSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *SauceIngredientPKSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *SauceIngredientPKSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *SauceIngredientPKSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *SauceIngredientPKSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *SauceIngredientPKSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *SauceIngredientPKSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *SauceIngredientPKSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientPKSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientDBQueryBuilder) PKSK() *SauceIngredientPKSKSafeOperators {
	return &SauceIngredientPKSKSafeOperators{tableName: x.tableName, column: "pb$" + "pksk"}
}

type SauceIngredientPKSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientPKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientPKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientPKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *SauceIngredientPKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *SauceIngredientPKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *SauceIngredientPKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *SauceIngredientPKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *SauceIngredientPKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *SauceIngredientPKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *SauceIngredientPKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *SauceIngredientPKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *SauceIngredientPKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientPKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientDBQueryBuilder) PK() *SauceIngredientPKSafeOperators {
	return &SauceIngredientPKSafeOperators{tableName: x.tableName, column: "pb$" + "pk"}
}

type SauceIngredientSKSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientSKSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientSKSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientSKSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *SauceIngredientSKSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *SauceIngredientSKSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *SauceIngredientSKSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *SauceIngredientSKSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *SauceIngredientSKSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *SauceIngredientSKSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *SauceIngredientSKSafeOperators) IsNotEmpty() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt("")
}

func (x *SauceIngredientSKSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *SauceIngredientSKSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientSKSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientDBQueryBuilder) SK() *SauceIngredientSKSafeOperators {
	return &SauceIngredientSKSafeOperators{tableName: x.tableName, column: "pb$" + "sk"}
}

type SauceIngredientFTSDataSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientFTSDataSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientFTSDataSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientDBQueryBuilder) FTSData() *SauceIngredientFTSDataSafeOperators {
	return &SauceIngredientFTSDataSafeOperators{tableName: x.tableName, column: "pb$" + "fts_data"}
}

type SauceIngredientSourceAddrSafeOperators struct {
	column    string
	tableName string
}

func (x *SauceIngredientSourceAddrSafeOperators) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientSourceAddrSafeOperators) Eq(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Eq(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) Gt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gt(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) Gte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Gte(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) Lt(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lt(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) Lte(v string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Lte(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) In(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).In(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) NotIn(v []string) exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotIn(v)
}

func (x *SauceIngredientSourceAddrSafeOperators) IsNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNull()
}

func (x *SauceIngredientSourceAddrSafeOperators) IsNotNull() exp.BooleanExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).IsNotNull()
}

func (x *SauceIngredientSourceAddrSafeOperators) InNetworkPrefix(cidr netip.Prefix) exp.RangeExpression {
	start, end := xpq.NetworkRange(cidr)
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start.String(), end.String()))
}

func (x *SauceIngredientSourceAddrSafeOperators) Between(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).Between(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientSourceAddrSafeOperators) NotBetween(start string, end string) exp.RangeExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column).NotBetween(exp.NewRangeVal(start, end))
}

func (x *SauceIngredientDBQueryBuilder) SourceAddr() *SauceIngredientSourceAddrSafeOperators {
	return &SauceIngredientSourceAddrSafeOperators{tableName: x.tableName, column: "pb$" + "source_addr"}
}

type SauceIngredientTenantIdQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) TenantId() *SauceIngredientTenantIdQueryType {
	return &SauceIngredientTenantIdQueryType{tableName: x.tableName, column: "pb$" + "tenant_id"}
}

func (x *SauceIngredientTenantIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientPKSKQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) PKSK() *SauceIngredientPKSKQueryType {
	return &SauceIngredientPKSKQueryType{tableName: x.tableName, column: "pb$" + "pksk"}
}

func (x *SauceIngredientPKSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientPKQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) PK() *SauceIngredientPKQueryType {
	return &SauceIngredientPKQueryType{tableName: x.tableName, column: "pb$" + "pk"}
}

func (x *SauceIngredientPKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientSKQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) SK() *SauceIngredientSKQueryType {
	return &SauceIngredientSKQueryType{tableName: x.tableName, column: "pb$" + "sk"}
}

func (x *SauceIngredientSKQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientFTSDataQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) FTSData() *SauceIngredientFTSDataQueryType {
	return &SauceIngredientFTSDataQueryType{tableName: x.tableName, column: "pb$" + "fts_data"}
}

func (x *SauceIngredientFTSDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientPBDataQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) PBData() *SauceIngredientPBDataQueryType {
	return &SauceIngredientPBDataQueryType{tableName: x.tableName, column: "pb$" + "pb_data"}
}

func (x *SauceIngredientPBDataQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientIdQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) Id() *SauceIngredientIdQueryType {
	return &SauceIngredientIdQueryType{tableName: x.tableName, column: "pb$" + "id"}
}

func (x *SauceIngredientIdQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientCreatedAtQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) CreatedAt() *SauceIngredientCreatedAtQueryType {
	return &SauceIngredientCreatedAtQueryType{tableName: x.tableName, column: "pb$" + "created_at"}
}

func (x *SauceIngredientCreatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientUpdatedAtQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) UpdatedAt() *SauceIngredientUpdatedAtQueryType {
	return &SauceIngredientUpdatedAtQueryType{tableName: x.tableName, column: "pb$" + "updated_at"}
}

func (x *SauceIngredientUpdatedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientDeletedAtQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) DeletedAt() *SauceIngredientDeletedAtQueryType {
	return &SauceIngredientDeletedAtQueryType{tableName: x.tableName, column: "pb$" + "deleted_at"}
}

func (x *SauceIngredientDeletedAtQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type SauceIngredientSourceAddrQueryType struct {
	column    string
	tableName string
}

func (x *SauceIngredientDBQueryUnsafe) SourceAddr() *SauceIngredientSourceAddrQueryType {
	return &SauceIngredientSourceAddrQueryType{tableName: x.tableName, column: "pb$" + "source_addr"}
}

func (x *SauceIngredientSourceAddrQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *SauceIngredientDBColumns) WithTable(t string) *SauceIngredientDBColumns {
	return &SauceIngredientDBColumns{tableName: t}
}

func (x *SauceIngredientDBColumns) TenantId() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "tenant_id")
}

func (x *SauceIngredientDBColumns) PKSK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pksk")
}

func (x *SauceIngredientDBColumns) PK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pk")
}

func (x *SauceIngredientDBColumns) SK() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "sk")
}

func (x *SauceIngredientDBColumns) FTSData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "fts_data")
}

func (x *SauceIngredientDBColumns) PBData() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "pb_data")
}

func (x *SauceIngredientDBColumns) Id() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "id")
}

func (x *SauceIngredientDBColumns) CreatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "created_at")
}

func (x *SauceIngredientDBColumns) UpdatedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "updated_at")
}

func (x *SauceIngredientDBColumns) DeletedAt() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "deleted_at")
}

func (x *SauceIngredientDBColumns) SourceAddr() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "source_addr")
}

type pgdbDescriptorPastaIngredient_ModelEmbedding struct{}

var (
	instancepgdbDescriptorPastaIngredient_ModelEmbedding pgdb_v1.Descriptor = &pgdbDescriptorPastaIngredient_ModelEmbedding{}
)

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) TableName() string {
	return "pb_model_embedding_models_food_v1_de910e59"
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) IsPartitioned() bool {
	return false
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) Fields(opts ...pgdb_v1.DescriptorFieldOptionFunc) []*pgdb_v1.Column {
	df := pgdb_v1.NewDescriptorFieldOption(opts)
	_ = df

	rv := make([]*pgdb_v1.Column, 0)

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("model"),
		Type:               "int4",
		Nullable:           df.Nullable(false),
		OverrideExpression: "",
		Default:            "0",
	})

	rv = append(rv, &pgdb_v1.Column{
		Name:               df.ColumnName("embedding"),
		Type:               "_float4",
		Nullable:           df.Nullable(true),
		OverrideExpression: "",
		Default:            "",
	})

	return rv
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) PKSKField() *pgdb_v1.Column {
	return &pgdb_v1.Column{
		Table: "pb_model_embedding_models_food_v1_de910e59",
		Name:  "pb$pksk",
		Type:  "varchar",
	}
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) DataField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_model_embedding_models_food_v1_de910e59", Name: "pb$pb_data", Type: "bytea"}
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) SearchField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_model_embedding_models_food_v1_de910e59", Name: "pb$fts_data", Type: "tsvector"}
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) VersioningField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_model_embedding_models_food_v1_de910e59", Name: "pb$", Type: "timestamptz"}
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) TenantField() *pgdb_v1.Column {
	return &pgdb_v1.Column{Table: "pb_model_embedding_models_food_v1_de910e59", Name: "pb$tenant_id", Type: "varchar"}
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) IndexPrimaryKey(opts ...pgdb_v1.IndexOptionsFunc) *pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io

	return nil

}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) Indexes(opts ...pgdb_v1.IndexOptionsFunc) []*pgdb_v1.Index {
	io := pgdb_v1.NewIndexOptions(opts)
	_ = io
	rv := make([]*pgdb_v1.Index, 0)

	return rv
}

func (d *pgdbDescriptorPastaIngredient_ModelEmbedding) Statistics(opts ...pgdb_v1.StatisticOptionsFunc) []*pgdb_v1.Statistic {
	io := pgdb_v1.NewStatisticOption(opts)
	_ = io
	rv := make([]*pgdb_v1.Statistic, 0)

	return rv
}

type pgdbMessagePastaIngredient_ModelEmbedding struct {
	self *PastaIngredient_ModelEmbedding
}

func (dbr *PastaIngredient_ModelEmbedding) DBReflect() pgdb_v1.Message {
	return &pgdbMessagePastaIngredient_ModelEmbedding{
		self: dbr,
	}
}

func (m *pgdbMessagePastaIngredient_ModelEmbedding) Descriptor() pgdb_v1.Descriptor {
	return instancepgdbDescriptorPastaIngredient_ModelEmbedding
}

func (m *pgdbMessagePastaIngredient_ModelEmbedding) Record(opts ...pgdb_v1.RecordOptionsFunc) (exp.Record, error) {
	ro := pgdb_v1.NewRecordOptions(opts)
	_ = ro
	nullExp := exp.NewLiteralExpression("NULL")
	_ = nullExp

	rv := exp.Record{}

	v1 := int32(m.self.GetModel())

	if ro.Nulled {
		rv[ro.ColumnName("model")] = nullExp
	} else {
		rv[ro.ColumnName("model")] = v1
	}

	v2 := make(xpq.Array[float32], 0, len(m.self.GetEmbedding()))
	for _, v2arrTmp := range m.self.GetEmbedding() {
		v2 = append(v2, float32(v2arrTmp))
	}

	if ro.Nulled {
		rv[ro.ColumnName("embedding")] = nullExp
	} else {
		rv[ro.ColumnName("embedding")] = v2
	}

	return rv, nil
}

func (m *pgdbMessagePastaIngredient_ModelEmbedding) SearchData(opts ...pgdb_v1.RecordOptionsFunc) []*pgdb_v1.SearchContent {
	rv := []*pgdb_v1.SearchContent{}

	return rv
}

type PastaIngredient_ModelEmbeddingDB struct {
	tableName string
}

type PastaIngredient_ModelEmbeddingDBQueryBuilder struct {
	tableName string
}

type PastaIngredient_ModelEmbeddingDBQueryUnsafe struct {
	tableName string
}

type PastaIngredient_ModelEmbeddingDBColumns struct {
	tableName string
}

func (x *PastaIngredient_ModelEmbedding) DB() *PastaIngredient_ModelEmbeddingDB {
	return &PastaIngredient_ModelEmbeddingDB{tableName: x.DBReflect().Descriptor().TableName()}
}

func (x *PastaIngredient_ModelEmbeddingDB) TableName() string {
	return x.tableName
}

func (x *PastaIngredient_ModelEmbeddingDB) Query() *PastaIngredient_ModelEmbeddingDBQueryBuilder {
	return &PastaIngredient_ModelEmbeddingDBQueryBuilder{tableName: x.tableName}
}

func (x *PastaIngredient_ModelEmbeddingDB) Columns() *PastaIngredient_ModelEmbeddingDBColumns {
	return &PastaIngredient_ModelEmbeddingDBColumns{tableName: x.tableName}
}

func (x *PastaIngredient_ModelEmbeddingDB) WithTable(t string) *PastaIngredient_ModelEmbeddingDB {
	return &PastaIngredient_ModelEmbeddingDB{tableName: t}
}

func (x *PastaIngredient_ModelEmbeddingDBQueryBuilder) WithTable(t string) *PastaIngredient_ModelEmbeddingDBQueryBuilder {
	return &PastaIngredient_ModelEmbeddingDBQueryBuilder{tableName: t}
}

func (x *PastaIngredient_ModelEmbeddingDBQueryBuilder) Unsafe() *PastaIngredient_ModelEmbeddingDBQueryUnsafe {
	return &PastaIngredient_ModelEmbeddingDBQueryUnsafe{tableName: x.tableName}
}

type PastaIngredient_ModelEmbeddingModelQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredient_ModelEmbeddingDBQueryUnsafe) Model() *PastaIngredient_ModelEmbeddingModelQueryType {
	return &PastaIngredient_ModelEmbeddingModelQueryType{tableName: x.tableName, column: "pb$" + "model"}
}

func (x *PastaIngredient_ModelEmbeddingModelQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

type PastaIngredient_ModelEmbeddingEmbeddingQueryType struct {
	column    string
	tableName string
}

func (x *PastaIngredient_ModelEmbeddingDBQueryUnsafe) Embedding() *PastaIngredient_ModelEmbeddingEmbeddingQueryType {
	return &PastaIngredient_ModelEmbeddingEmbeddingQueryType{tableName: x.tableName, column: "pb$" + "embedding"}
}

func (x *PastaIngredient_ModelEmbeddingEmbeddingQueryType) Identifier() exp.IdentifierExpression {
	return exp.NewIdentifierExpression("", x.tableName, x.column)
}

func (x *PastaIngredient_ModelEmbeddingDBColumns) WithTable(t string) *PastaIngredient_ModelEmbeddingDBColumns {
	return &PastaIngredient_ModelEmbeddingDBColumns{tableName: t}
}

func (x *PastaIngredient_ModelEmbeddingDBColumns) Model() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "model")
}

func (x *PastaIngredient_ModelEmbeddingDBColumns) Embedding() exp.Expression {
	return exp.NewIdentifierExpression("", x.tableName, "embedding")
}