qcode

type AggregrateOp int8

type Arg struct {
	Type  ArgType
	DType string
	Name  string
	Val   string
	Col   sdata.DBColumn
	Expr  *Exp // populated when Type == ArgTypeExpr
}

type ArgType int8

type Cache struct {
	Header string
}

type CaseArm struct {
	When *Exp
	Then *Exp
}

type ColKey struct {
	Name string
	Base bool
}

type Column struct {
	Col         sdata.DBColumn
	FieldFilter Filter
	FieldName   string
}

type Compiler struct {
	// contains filtered or unexported fields
}

type Config struct {
	Vars            map[string]string
	TConfig         map[string]TConfig
	DefaultBlock    bool
	DefaultLimit    int
	AnalyticsMode   bool
	DisableAgg      bool
	DisableFuncs    bool
	EnableCamelcase bool
	DBSchema        string
	Validators      map[string]Validator

	// EnableCacheTracking injects __gj_id fields with primary keys for cache row tracking
	EnableCacheTracking bool
	// contains filtered or unexported fields
}

type Constraint struct {
	VarName string
	// contains filtered or unexported fields
}

type DeleteConfig struct {
	Filters []string
	Columns []string
	Block   bool
}

type Exp struct {
	Op    ExpOp
	Joins []Join
	Order
	OrderBy bool

	Left struct {
		ID      int32
		Table   string
		Col     sdata.DBColumn
		ColName string
		Path    []string
	}
	Right struct {
		ValType  ValType
		Val      string
		ID       int32
		Table    string
		Col      sdata.DBColumn
		ColName  string
		ListType ValType
		ListVal  []string
		Path     []string
	}
	Geo      *GeoExp // GIS-specific expression data
	Children []*Exp

	// Scalar-expression payloads (set only for the corresponding Op).
	// These are unused for boolean/comparison ops; keeping them inline
	// avoids allocating a separate struct per leaf node.
	Lit      ExpLit    // OpLiteral
	CaseArms []CaseArm // OpCase
	Else     *Exp      // OpCase ELSE branch (optional)
	CastType string    // OpCast — target SQL type
	RelPath  []sdata.DBRel
	// contains filtered or unexported fields
}

type ExpLit struct {
	Val     string
	ValType ValType
}

type ExpOp int8

type Field struct {
	ID          int32
	ParentID    int32
	Type        FieldType
	Col         sdata.DBColumn
	Func        sdata.DBFunction
	FieldName   string
	FieldFilter Filter
	Args        []Arg
	SkipRender  SkipType
}

type FieldType int8

type Filter struct {
	*Exp
}

type Fragment struct {
	Name  string
	Value []byte
}

type Function struct {
	Name string
	// Col       sdata.DBColumn
	Func sdata.DBFunction
	Args []Arg
	Agg  bool
}

type GeoExp struct {
	// Geometry specification (one of these will be set)
	Point   []float64   // [longitude, latitude] for point
	Polygon [][]float64 // Array of [lon, lat] pairs for polygon ring
	GeoJSON []byte      // Full GeoJSON geometry object

	// Operation parameters
	Distance    float64 // Distance value for st_dwithin
	DistanceVar string  // Variable name for distance if parameterized
	Unit        GeoUnit // Distance unit (meters, km, miles, feet)
	SRID        int     // Spatial Reference ID (default 4326 = WGS84)

	// For MongoDB
	MinDistance float64 // $minDistance for $near
	Spherical   bool    // Use spherical calculations
}

type GeoUnit int8

type InsertConfig struct {
	Columns []string
	Presets map[string]string
	Block   bool
}

type Join struct {
	Filter *Exp
	Rel    sdata.DBRel
	Local  bool
}

type MColumn struct {
	Col       sdata.DBColumn
	FieldName string
	Alias     string
	Value     string
	Set       bool
}

type MRColumn struct {
	Col  sdata.DBColumn
	VCol sdata.DBColumn
}

type MTable struct {
	Ti sdata.DBTable
}

type MType uint8

type Mutate struct {
	Field

	ID        int32
	ParentID  int32
	SelID     int32
	DependsOn map[int32]struct{}
	Type      MType
	// CType     uint8
	Key   string
	Path  []string
	Val   json.RawMessage
	Cols  []MColumn
	RCols []MRColumn
	Ti    sdata.DBTable
	Rel   sdata.DBRel
	Where Filter
	Multi bool
	// contains filtered or unexported fields
}

type NewValidFn func(args []string) (fn ValidFn, err error)

type Order int8

type OrderBy struct {
	KeyVar string
	Key    string
	Col    sdata.DBColumn
	Var    string
	Order  Order
	Func   sdata.DBFunction
	IsFunc bool
	// Alias is set when the user ordered by a SELECT-list alias rather
	// than a column name (e.g. order_by: { revenue: desc } where
	// `revenue` is an expression aggregate field's alias). The validator
	// confirms the alias resolves to a compiled field after
	// compileChildColumns runs; the renderer emits a bare quoted alias
	// (ORDER BY "revenue" DESC), which all 7 SQL dialects accept.
	Alias string
}

type Paging struct {
	Type      PagingType
	LimitVar  string
	Limit     int32
	OffsetVar string
	Offset    int32
	Cursor    bool
	CursorVar string // "cursor" or "<fieldname>_cursor" for named cursor pagination
	NoLimit   bool
}

type PagingType int8

type QCode struct {
	Type      QType
	SType     QType
	Name      string
	ActionVar string
	ActionVal json.RawMessage
	Vars      []Var
	Selects   []Select
	Consts    []Constraint
	Roots     []int32

	Mutates   []Mutate
	MUnions   map[string][]int32
	Schema    *sdata.DBSchema
	Remotes   int32
	Cache     Cache
	Typename  bool
	Query     []byte
	Fragments []Fragment
	Warnings  []string // Non-fatal warnings (e.g., missing partition filter)
	// contains filtered or unexported fields
}

type QType int8

type QueryConfig struct {
	Limit            int
	Filters          []string
	Columns          []string
	DisableFunctions bool
	Block            bool
}

type Schema struct {
	Type           string
	Version        int
	Schema         string
	Columns        []sdata.DBColumn
	Functions      []sdata.DBFunction
	ClusteringKeys []TableCluster
}

type Script struct {
	Source string
	Name   string
}

type SelType int8

type Select struct {
	Field
	Type     SelType
	Singular bool
	Typename bool
	Table    string
	Schema   string
	// Database is the target database for this select (multi-database support).
	// Empty string means the default database.
	Database   string
	Fields     []Field
	BCols      []Column
	IArgs      []Arg
	Where      Filter
	OrderBy    []OrderBy
	DistinctOn []sdata.DBColumn
	GroupCols  bool
	// GlobalAgg is true when this select uses aggregate functions
	// without `distinct` — i.e. the entire selection collapses to a
	// single row of global aggregates. Set in compileChildColumns
	// when aggExists && len(DistinctOn) == 0 && this is the top-level
	// select. Drives outer SELECT to skip __gj_id, BCols rendering to
	// emit nothing, and LIMIT to be omitted (a single row is the entire
	// result). Without this flag, the existing render path would emit
	// `LIMIT 20` and produce 20 degenerate per-row rows of aggregates
	// (the bug captured in broken.md).
	GlobalAgg               bool
	Paging                  Paging
	Children                []int32
	Ti                      sdata.DBTable
	Rel                     sdata.DBRel
	Joins                   []Join
	PartitionFilterRequired string
	Unrestricted            bool
	// contains filtered or unexported fields
}

type SkipType int8

type TConfig struct {
	OrderBy map[string][][2]string
}

type TRConfig struct {
	Query  QueryConfig
	Insert InsertConfig
	Update UpdateConfig
	Upsert UpsertConfig
	Delete DeleteConfig
}

type TableCluster struct {
	Schema, Database, Table string
	Keys                    []string
}

type TableInfo struct {
	sdata.DBTable
}

type UpdateConfig struct {
	Filters []string
	Columns []string
	Presets map[string]string
	Block   bool
}

type UpsertConfig struct {
	Filters []string
	Columns []string
	Presets map[string]string
	Block   bool
}

type ValType int8

type ValidErr struct {
	FieldName  string `json:"field_name"`
	Constraint string `json:"constraint"`
}

type ValidFn func(Vars, Constraint) bool

type Validation struct {
	Source string
	Type   string
}

type Validator struct {
	Description string
	Type        string
	List        bool
	Types       []graph.ParserType
	NewFn       NewValidFn
}

type Var struct {
	Name string
	Val  json.RawMessage
}

type Vars map[string]json.RawMessage