gql

type AIArg struct {
	Name         symbol.ID  // =symbol.Invalid iff the arg is positional.
	Type         AIType     // Set when the value is eagerly evaluated
	Env          aiBindings // Env and Expr form a closure
	Expr         ASTNode    // Syntactic node. Nil iff the arg is optional and is omitted by the caller.
	Symbol       symbol.ID  // Set iff FormalArg.Symbol=true.
	DefaultValue Value      // Copied from FormalArg.DefaultValue
}

type AIType struct {
	// ValueType is the type of the node.
	Type ValueType

	// Literal is non-nil if the type refers to a compile-time constant.
	Literal *Value

	// Any is set when the type is unknown. An any type matches anything.
	Any bool

	// Formal args to the function.
	FormalArgs []FormalArg
	// TypeCB is called via ASTNode.Analyze to run a
	// function-implementation-specific typecheck.
	//
	// Note: the types of non-lazy args in []FormalArgs are checked by
	// ASTFunctionCall.Analeze, so TypeCB implementations don't need to check
	// them.
	TypeCB TypeCallback
}

type ASTBlock struct {
	Pos        scanner.Position
	Statements []ASTStatement
}

type ASTColumnRef struct {
	// Pos is the location of this node in the source file.
	Pos scanner.Position
	// Col is the column name
	Col symbol.ID

	// Deprecated is true if this syntax node was created by a "$column"
	// expression, as opposed to "&column".
	Deprecated bool
}

type ASTCondOp struct {
	// Pos is the position of the start of the expression.
	Pos scanner.Position
	// Cond is the conditional.
	Cond ASTNode
	// Then is the positive clause.
	Then ASTNode
	// Else is the negative clause.
	Else ASTNode
}

type ASTFuncall struct {
	Pos      scanner.Position
	Function ASTNode       // function body.
	Raw      []ASTParamVal // set by yacc.
	Args     []AIArg       // set in analyze
	Analyzed bool          // true after analyze() runs.
}

type ASTImplicitColumnRef struct {
	// Pos is the location of this node in the source file.
	Pos scanner.Position
	// Col is the column name.
	Col symbol.ID
}

type ASTLambda struct {
	Pos  scanner.Position
	Args []FormalArg
	// Body is the function body.
	Body ASTNode
}

type ASTLiteral struct {
	// Pos is the source-code location of this node.
	Pos scanner.Position
	// Literal stores the const value.
	Literal Value
	// Org stores the original expression, if this node was created as a result of
	// constant-propagation optimization. Otherwise Org is nil.
	Org ASTNode
}

type ASTLogicalOp struct {
	// AndAnd is true for "&&", false for "||"
	AndAnd   bool
	LHS, RHS ASTNode
}

type ASTNode interface {

	// String produces a human-readable description of the expression node.  The
	// resulting string is only for logging; it may not be a valid GQL expression.
	String() string
	// contains filtered or unexported methods
}

type ASTParamVal struct {
	Pos scanner.Position
	// Name is set to symbol.Intern("foo") if the actual arg is 'foo:=expr'. It is
	// symbol.Invalid for a positional arg.
	Name symbol.ID
	// Expr is the actual arg expression.
	Expr ASTNode
	// PipeSource is true if if this arg is a LHS of a pipe operator.  E.g., take
	// expression `read("foo.tsv") | map($col==0)`. It is syntactically translated
	// into `map(read("foo.tsv"), $col==0)`. Its first arg, `read("foo.tsv")` is
	// marked as PipeSource. A pipesource argument is exempted from '&' expansion.
	PipeSource bool
}

type ASTStatement struct {
	// Pos is the location of this node in the source file.
	Pos scanner.Position

	// LHS is set when the statement is of form "var := expr".
	LHS symbol.ID

	// Expr is the right-hand side of "var := expr". It is also set when the
	// statement is a naked expression.
	Expr ASTNode
}

type ASTStatementOrLoad struct {
	ASTStatement
	// Load is set when the statement is of form "load `path`". The value is the
	// pathname. Other fields are unset.
	LoadPath string
}

type ASTStructFieldRef struct {
	Parent ASTNode   // Refers to the struct object.
	Field  symbol.ID // Field in the struct.
}

type ASTStructFieldRegex struct {
	Pos scanner.Position
	// contains filtered or unexported fields
}

type ASTStructLiteral struct {
	Pos    scanner.Position
	Fields []ASTStructLiteralField
}

type ASTStructLiteralField struct {
	Pos  scanner.Position
	Name symbol.ID // column name. may be symbol.Invalid.
	Expr ASTNode
}

type ASTUnknown struct{}

type ASTVarRef struct {
	Pos scanner.Position
	Var symbol.ID // variable name
}

type ActualArg struct {
	Name   symbol.ID // Formal arg name. Copied from FormalArg.Name
	Value  Value     // Set for eagerly evaluated arg.
	Expr   ASTNode   // Points to the source code element. Set unless the arg is optional and is not provided by the caller.
	Symbol symbol.ID // Set only for symbol arg.
}

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

type ClosureFormalArg struct {
	// Name is the default name of the arg
	Name symbol.ID
	// Override specifies the name of the argument to the (outer) function that
	// overrides the Name. For example, the builtin map() function has an optional
	// argument "row" that overrides the name of the arguments to filter and map
	// callbacks. For these callbacks, Name=symbol.Intern("_"),
	// Override=symbol.Intern("row").
	Override symbol.ID
}

type CountMode int

type FileHandler interface {
	// Name returns the file-type name, e.g., "tsv" for TSV handler, "bam" for BAM
	// handler.
	Name() string
	// Open opens the file and returns a Table that reads its contents.  Arg "ast"
	// can be passed to functions such as Logf, Panicf to report the source-code
	// location on error.
	Open(ctx context.Context, path string, ast ASTNode, hash hash.Hash) Table
	// Write writes the contents of the table to the given file. "nshard" the
	// number of file shards to create. It is meaningful only for btsv files.
	// "overwrite" is true iff. the caller wishes to overwrite the file if it
	// exits already.
	//
	// Arg "ast" can be passed to functions such as Logf, Panicf to report the
	// source-code location on error.
	Write(ctx context.Context, path string, ast ASTNode, table Table, nShard int, overwrite bool)
}

type FormalArg struct {
	// Name must be set for a named argument. For positional args, this field is
	// only informational.
	Name symbol.ID
	// Positional is true if the caller need not name the arg in form
	// "arg:=value".
	Positional bool
	// Required is true if the arg must be provided by the caller.
	Required bool
	// Variadic causes this arg to consume all the remaining, unnamed actual args
	Variadic bool

	// Closure is true if the argument is treated as a lambda body with the args
	// specified in ClosureArgs. A Closure argument is translated into a
	// user-defined function during the analysis phase.
	Closure     bool
	ClosureArgs []ClosureFormalArg

	// Joinclosure is a special kind of closure that's used to specify the join
	// condition and map arg for the join function. The formal args to these
	// callbacks need to be extraced from the 1st arg to join ({t0:table0, ...,
	// tN:tableN}).
	JoinClosure bool

	// If Symbol=true, the actual arg must be a naked symbol that specifies a
	// variable name. It is used, e.g., as the "row:=foobar" arg in map() and
	// filter().
	Symbol bool
	// DefaultSymbol is set as the value of the symbol arg if it is not provided
	// by the caller.
	//
	// INVARIANT: If DefaultSymbol!=symbol.Invalid then Symbol==true.
	DefaultSymbol symbol.ID

	// DefaultValue is set as the arg value if it is not provided by the caller.
	// It is meaningful only for non-lazy, non-symbol args.
	DefaultValue Value

	// The list of types allowed as the arg. Meaningful only if !Symbol. This
	// field is optional. The parser will check for type conformance if len(Types)
	// len(Types)>0. This field may be nil, in which case it is up to the
	// typecheck callback to validate arg types.
	Types []ValueType
}

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

type FuncCallback func(ctx context.Context, ast ASTNode, args []ActualArg) Value

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

type NullStatus int

type NullTableScanner struct{}

type Opts struct {
	// BackgroundContext is the default context used in stringers and other
	// non-critical codepaths.
	// If unset, context.Background() is used.
	BackgroundContext context.Context
	// CacheDir is directory that stores materialized tables for caching.  If
	// unset, gql.DefaultCacheRoot is used when bsSession != nil. Else
	// gql.DefaultLocalCacheRoot is used.
	CacheDir string
	// OverwriteFiles controls whether write() function overwrites existing files.
	OverwriteFiles bool
	// BigsliceSession is an initialized bigslice session. If unset, a local
	// bigslice executor will be created.
	BigsliceSession *exec.Session
	// ImmutableFilesRE x lists regexps of paths of files that can be assumed to
	// be immutable.  Immutable files can be hashed quickly using just their
	// pathnames, so they improve performance of gql.
	//
	// If nil, "^s3://grail-clinical.*" and "^s3://grail-results.*" are used.
	ImmutableFilesRE []*regexp.Regexp
}

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

type PrintArgs struct {
	// Out is the output destination
	Out termutil.Printer

	// Mode defines how the value is printed
	Mode PrintMode
	// TmpVars collects names of subtables in case they are not printed in-line.
	// The user can later print the subtable contents by typing these names.  If
	// TmpVars is nil, a nested table will be printed as "[omitted]".
	TmpVars *TmpVars

	// MaxInlinedTableLen is the threshold for printing a nested table inline.
	// When a table's compact representation exceeds this length (bytes), it is
	// printed as "tmpNN" or "[omitted]" depending on whether TmpVars!=nil.
	//
	// If MaxInlinedTableLen <= 0, it is set to 78.
	MaxInlinedTableLen int
}

type PrintMode int

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

type Struct interface {
	// Len returns the number of fields (columns) in the struct.
	Len() int
	// Field returns the name and the value of the i'th field.
	//
	// REQUIRES: 0 <= i < Len()
	Field(i int) StructField
	// Value returns the value for the specified column. It returns false if the
	// column is not found.
	Value(colName symbol.ID) (Value, bool)
}

type StructField struct {
	Name  symbol.ID
	Value Value
}

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

type TSVColumn struct {
	// Name is the column name
	Name string
	// Type is the type of the cells in the column.
	Type ValueType
	// Description is an optional description of the column.
	Description string `json:",omitempty"`
}

type TSVFormat struct {
	// HeaderLines is the number of comment lines at the beginning of the file.
	// The value is typically 0 or 1.
	HeaderLines int
	// List of columns in each row.
	Columns []TSVColumn
}

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

type Table interface {
	// Attrs obtains the table metadata. Any of the attr fields may be empty.
	Attrs(ctx context.Context) TableAttrs
	// Scanner creates a table scanner. The parameters are used to scan the part
	// [start,limit) of the table, where range [0,total) represents the whole
	// table.
	//
	// For example, Scanner(0,2,3) reads the 2/3rds of the table, and
	// Scanner(2,3,3) reads the remaining 1/3rd of the table. Note that the
	// scanner implementation need not guarantee that the shard size is uniform
	// (but they strive to). Also, it need not always range-shard the table -- it
	// can hash-shard the table, it that's more convenient.
	//
	// REQUIRES: 0 <= start <= limit <= total.
	Scanner(ctx context.Context, start, limit, total int) TableScanner

	// Len returns the number of rows in the table. When mode==Approx, this method
	// should return the approx number of rows quickly. The Approx mode is used to
	// guide sharding and parallelizing policies. When mode==Exact, this method
	// must compute the exact # of rows in the table.
	Len(ctx context.Context, mode CountMode) int

	// Hash computes a hash value for this table.
	Hash() hash.Hash
	// Marshal produces a string that can be fed to parser to reconstruct this table.
	Marshal(ctx MarshalContext, enc *marshal.Encoder)
	// Prefetch is called to fetch the contents in the background, if possible.
	// This method shall never block.
	Prefetch(ctx context.Context)
}

type TableAttrs struct {
	// Name is a short description of the the table, "tsv", "mapfilter", etc.
	Name string
	// Path is the file from which the contents were read. It is "" for a computed
	// table.
	Path string
	// List of columns in the table.
	Columns []TSVColumn
	// Description can be any string.
	Description string
}

type TableScanner interface {
	// Scan fetches the next value. It returns false on EOF.
	Scan() bool
	// Value returns the current value.
	//
	// REQUIRES: the last Scan() call returned true.
	Value() Value
}

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

type TypeCallback func(ast ASTNode, args []AIArg) AIType

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

type UnmarshalMagic [2]byte

type UnmarshalTableCallback func(ctx UnmarshalContext, hash hash.Hash, dec *marshal.Decoder) Table

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

type ValueType byte