cypher

type Condition struct {
	Variable string // "f"
	Property string // "name"
	Operator string // "=", "<>", "=~", "CONTAINS", "STARTS WITH", "ENDS WITH", "IS NULL", "IS NOT NULL", "IN", ">", "<", ">=", "<="
	Value    string // the comparison value (unused for IN, IS NULL, IS NOT NULL)

	// ValueIsString is true when Value came from a string literal. Ordered
	// comparisons (<, >, <=, >=) use it to pick lexicographic vs numeric
	// semantics, matching openCypher's type-aware comparison.
	ValueIsString bool

	// Values holds the list literal for the IN operator: WHERE n.x IN ['a','b'].
	// Empty for all other operators.
	Values []string
}

type Executor struct {
	Store   *store.Store
	MaxRows int // 0 means defaultMaxRows

	// MaxUnboundedPathDepth overrides the depth used when a query uses a
	// bare `*` variable-length pattern with no upper bound. Zero means
	// defaultUnboundedPathDepth. The effective cap is always reported on
	// Result.UnboundedDepthCap when the cap fires so callers see when
	// their `*` was clipped.
	MaxUnboundedPathDepth int
	// contains filtered or unexported fields
}

type ExpandRelationship struct {
	FromVar   string // source variable (already bound)
	ToVar     string // target variable (to bind)
	RelVar    string // optional relationship variable (to bind edge)
	ToLabel   string // optional label filter on target
	ToProps   map[string]string
	EdgeTypes []string // required edge types
	Direction string   // "outbound", "inbound", "any"
	MinHops   int
	MaxHops   int
}

type FilterWhere struct {
	Conditions []Condition
	Operator   string // "AND" or "OR"
}

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

type MatchClause struct {
	Pattern *Pattern
}

type NodePattern struct {
	Variable string            // e.g. "f"
	Label    string            // e.g. "Function" (optional)
	Props    map[string]string // inline property filters (optional)
}

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

type Pattern struct {
	Elements []PatternElement
}

type PatternElement interface {
	// contains filtered or unexported methods
}

type Plan struct {
	Steps      []PlanStep
	ReturnSpec *ReturnClause
}

type PlanStep interface {
	// contains filtered or unexported methods
}

type Query struct {
	Match  *MatchClause
	Where  *WhereClause
	Return *ReturnClause
}

type RelPattern struct {
	Variable  string   // (optional)
	Types     []string // relationship types, e.g. ["CALLS", "HTTP_CALLS"]
	Direction string   // "outbound", "inbound", "any"
	MinHops   int      // for variable-length, default 1
	MaxHops   int      // for variable-length, default 1 (0 means unbounded)
}

type Result struct {
	Columns []string         `json:"columns"`
	Rows    []map[string]any `json:"rows"`

	// Truncated is true if any clipping step (final LIMIT/max_rows cap or an
	// intermediate binding-set cap during path expansion) dropped rows. When
	// true, the returned Rows is a sample — not the full matching set. Clients
	// should either raise max_rows, narrow the query with WHERE filters, or
	// shard the query to retrieve the complete result.
	Truncated bool `json:"truncated,omitempty"`

	// EffectiveCap is the row cap that was active for this query. Reflects the
	// lower of (user-supplied max_rows, absoluteMaxRows), defaulting to
	// defaultMaxRows when max_rows is not set. Always populated so clients
	// can report "capped at N" even when Truncated is false.
	EffectiveCap int `json:"effective_cap"`

	// SkippedProjects lists projects whose execution returned an error and
	// were excluded from the merged result. Empty when no projects were
	// skipped. Populating this (instead of silently dropping the project)
	// lets callers see when a single corrupt project DB or transient query
	// failure is shaping the result set.
	SkippedProjects []SkippedProject `json:"skipped_projects,omitempty"`

	// UnboundedDepthCap is set to the depth used when a query uses a bare
	// `*` variable-length pattern and the engine had to apply its default
	// cap. Zero means no unbounded pattern was capped. Callers that issued
	// an unbounded `*` should treat any non-zero value as "this is a
	// sample to depth N — raise MaxUnboundedPathDepth or use an explicit
	// upper bound for full coverage."
	UnboundedDepthCap int `json:"unbounded_depth_cap,omitempty"`
}

type ReturnClause struct {
	Items    []ReturnItem
	OrderBy  string // "f.name" (optional)
	OrderDir string // "ASC" or "DESC"
	Limit    int    // meaningful only when HasLimit; LIMIT 0 is a valid empty result
	HasLimit bool   // true when an explicit LIMIT clause was present
	Distinct bool
}

type ReturnItem struct {
	Variable string // "f"
	Property string // "name" (empty = return whole node)
	Alias    string // "AS call_count" (optional)
	Func     string // "COUNT" / "LABELS" (optional aggregation or function)

	// Distinct is true for COUNT(DISTINCT x) — count unique non-null
	// values of x rather than total bindings. Only meaningful when
	// Func == "COUNT".
	Distinct bool
}

type ScanNodes struct {
	Variable string
	Label    string
	Props    map[string]string // inline property filters
}

type SkippedProject struct {
	Name string `json:"name"`
	Err  string `json:"err"`
}

type Token struct {
	Type  TokenType
	Value string
	Pos   int // byte offset in the input
}

type TokenType int

type WhereClause struct {
	Conditions []Condition
	Operator   string // "AND" or "OR"
}