SelectQueryNode

interface SelectQueryNode extends OperationNode {

readonly distinctOn?: ReadonlyArray<OperationNode>;

readonly endModifiers?: ReadonlyArray<SelectModifierNode>;

readonly explain?: ExplainNode;

readonly fetch?: FetchNode;

readonly from?: FromNode;

readonly frontModifiers?: ReadonlyArray<SelectModifierNode>;

readonly groupBy?: GroupByNode;

readonly having?: HavingNode;

readonly joins?: ReadonlyArray<JoinNode>;

readonly kind: "SelectQueryNode";

readonly limit?: LimitNode;

readonly offset?: OffsetNode;

readonly orderBy?: OrderByNode;

readonly selections?: ReadonlyArray<SelectionNode>;

readonly setOperations?: ReadonlyArray<SetOperationNode>;

readonly top?: TopNode;

readonly where?: WhereNode;

readonly with?: WithNode;

}

const SelectQueryNode: Readonly<{

is(node: OperationNode): node is SelectQueryNode;

create(withNode?: WithNode): SelectQueryNode;

createFrom(fromItems: ReadonlyArray<OperationNode>, withNode?: WithNode): SelectQueryNode;

cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;

cloneWithDistinctOn(select: SelectQueryNode, expressions: ReadonlyArray<OperationNode>): SelectQueryNode;

cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;

cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;

cloneWithOrderByItems(selectNode: SelectQueryNode, items: ReadonlyArray<OrderByItemNode>): SelectQueryNode;

cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;

cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;

cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;

cloneWithFetch(selectNode: SelectQueryNode, fetch: FetchNode): SelectQueryNode;

cloneWithHaving(selectNode: SelectQueryNode, operation: OperationNode): SelectQueryNode;

cloneWithSetOperations(selectNode: SelectQueryNode, setOperations: ReadonlyArray<SetOperationNode>): SelectQueryNode;

cloneWithoutSelections(select: SelectQueryNode): SelectQueryNode;

cloneWithoutLimit(select: SelectQueryNode): SelectQueryNode;

cloneWithoutOffset(select: SelectQueryNode): SelectQueryNode;

cloneWithoutOrderBy(select: SelectQueryNode): SelectQueryNode;

}>;

§Extends

OperationNode

[src]

§Properties

readonly distinctOn?: ReadonlyArray<OperationNode>

[src]

readonly endModifiers?: ReadonlyArray<SelectModifierNode>

[src]

readonly explain?: ExplainNode

[src]

readonly fetch?: FetchNode

[src]

readonly from?: FromNode

[src]

readonly frontModifiers?: ReadonlyArray<SelectModifierNode>

[src]

readonly groupBy?: GroupByNode

[src]

readonly having?: HavingNode

[src]

readonly joins?: ReadonlyArray<JoinNode>

[src]

readonly kind: "SelectQueryNode"

[src]

readonly limit?: LimitNode

[src]

readonly offset?: OffsetNode

[src]

readonly orderBy?: OrderByNode

[src]

readonly selections?: ReadonlyArray<SelectionNode>

[src]

readonly setOperations?: ReadonlyArray<SetOperationNode>

[src]

readonly top?: TopNode

[src]

readonly where?: WhereNode

[src]

readonly with?: WithNode

[src]