class SelectStmt(Query):
# List of DISTINCT ON expressions, empty list for DISTINCT ALL
distinct_clause: typing.Optional[list] = None
# The target list
target_list: typing.List[ResTarget] = ast.field(factory=list)
# The FROM clause
from_clause: typing.List[BaseRangeVar] = ast.field(factory=list)
# The WHERE clause
where_clause: typing.Optional[BaseExpr] = None
# GROUP BY clauses
group_clause: typing.Optional[typing.List[Base]] = None
# HAVING expression
having: typing.Optional[BaseExpr] = None
# WINDOW window_name AS(...),
window_clause: typing.Optional[typing.List[Base]] = None
# List of ImplicitRow's in a VALUES query
values: typing.Optional[typing.List[Base]] = None
# ORDER BY clause
sort_clause: typing.Optional[typing.List[SortBy]] = None
# OFFSET expression
limit_offset: typing.Optional[BaseExpr] = None
# LIMIT expression
limit_count: typing.Optional[BaseExpr] = None
# FOR UPDATE clause
locking_clause: typing.Optional[list] = None
# Set operation type
op: typing.Optional[str] = None
# ALL modifier
all: bool = False
# Left operand of set op
larg: typing.Optional[Query] = None
# Right operand of set op,
rarg: typing.Optional[Query] = None
class EdgeQLPathInfo(Base):
"""A general mixin providing EdgeQL-specific metadata on certain nodes."""
# Ignore the below fields in AST visitor/transformer.
__ast_meta__ = {
'path_scope', 'path_outputs', 'path_id', 'is_distinct',
'path_id_mask', 'path_namespace'
}
# The path id represented by the node.
path_id: typing.Optional[irast.PathId] = None
# Whether the node represents a distinct set.
is_distinct: bool = True
# A subset of paths necessary to perform joining.
path_scope: typing.Set[irast.PathId] = ast.field(factory=set)
# Map of res target names corresponding to paths.
path_outputs: typing.Dict[
typing.Tuple[irast.PathId, str], OutputVar
] = ast.field(factory=dict)
# Map of res target names corresponding to materialized paths.
packed_path_outputs: typing.Optional[typing.Dict[
typing.Tuple[irast.PathId, str],
typing.Tuple[OutputVar, bool],
]] = None
path_id_mask: typing.Set[irast.PathId] = ast.field(factory=set)
# Map of col refs corresponding to paths.
path_namespace: typing.Dict[
typing.Tuple[irast.PathId, str], BaseExpr
] = ast.field(factory=dict)
class UpdateStmt(DMLQuery):
# The UPDATE target list
targets: typing.List[UpdateTarget] = ast.field(factory=list)
# WHERE clause
where_clause: typing.Optional[BaseExpr] = None
# optional FROM clause
from_clause: typing.List[BaseRangeVar] = ast.field(factory=list)
class EdgeQLPathInfo(Base):
"""A general mixin providing EdgeQL-specific metadata on certain nodes."""
# Ignore the below fields in AST visitor/transformer.
__ast_meta__ = {
'path_scope',
'path_outputs',
'path_id',
'is_distinct',
'path_id_mask',
'path_namespace',
'packed_path_outputs',
'packed_path_namespace',
}
# The path id represented by the node.
path_id: typing.Optional[irast.PathId] = None
# Whether the node represents a distinct set.
is_distinct: bool = True
# A subset of paths necessary to perform joining.
path_scope: typing.Set[irast.PathId] = ast.field(factory=set)
# Map of res target names corresponding to paths.
path_outputs: typing.Dict[typing.Tuple[irast.PathId, str],
OutputVar] = ast.field(factory=dict)
# Map of res target names corresponding to materialized paths.
packed_path_outputs: typing.Optional[typing.Dict[typing.Tuple[irast.PathId,
str],
OutputVar, ]] = None
def get_path_outputs(
self, flavor: str
) -> typing.Dict[typing.Tuple[irast.PathId, str], OutputVar]:
if flavor == 'packed':
if self.packed_path_outputs is None:
self.packed_path_outputs = {}
return self.packed_path_outputs
elif flavor == 'normal':
return self.path_outputs
else:
raise AssertionError(f'unexpected flavor "{flavor}"')
path_id_mask: typing.Set[irast.PathId] = ast.field(factory=set)
# Map of col refs corresponding to paths.
path_namespace: typing.Dict[typing.Tuple[irast.PathId, str],
BaseExpr] = ast.field(factory=dict)
# Same, but for packed.
packed_path_namespace: typing.Optional[typing.Dict[typing.Tuple[
irast.PathId, str], BaseExpr, ]] = None
class Query(ReturningQuery):
"""Generic superclass representing a query."""
# Ignore the below fields in AST visitor/transformer.
__ast_meta__ = {
'path_rvar_map', 'path_packed_rvar_map', 'view_path_id_map',
'argnames', 'nullable'
}
view_path_id_map: typing.Dict[irast.PathId,
irast.PathId] = ast.field(factory=dict)
# Map of RangeVars corresponding to paths.
path_rvar_map: typing.Dict[typing.Tuple[irast.PathId, str],
PathRangeVar] = ast.field(factory=dict)
# Map of materialized RangeVars corresponding to paths.
path_packed_rvar_map: typing.Optional[typing.Dict[typing.Tuple[
irast.PathId, str], PathRangeVar, ]] = None
argnames: typing.Optional[typing.Dict[str, Param]] = None
ctes: typing.Optional[typing.List[CommonTableExpr]] = None
def get_rvar_map(
self, flavor: str
) -> typing.Dict[typing.Tuple[irast.PathId, str], PathRangeVar]:
if flavor == 'packed':
if self.path_packed_rvar_map is None:
self.path_packed_rvar_map = {}
return self.path_packed_rvar_map
elif flavor == 'normal':
return self.path_rvar_map
else:
raise AssertionError(f'unexpected flavor "{flavor}"')
def maybe_get_rvar_map(
self, flavor: str
) -> typing.Optional[typing.Dict[typing.Tuple[irast.PathId, str],
PathRangeVar]]:
if flavor == 'packed':
return self.path_packed_rvar_map
elif flavor == 'normal':
return self.path_rvar_map
else:
raise AssertionError(f'unexpected flavor "{flavor}"')
@property
def ser_safe(self):
return all(t.ser_safe for t in self.target_list)
def append_cte(self, cte: CommonTableExpr) -> None:
if self.ctes is None:
self.ctes = []
self.ctes.append(cte)
class Node(Base):
field_list: list = ast.field(factory=list)
field_typing_list: typing.List[Base] = ast.field(factory=list)
field_typing_tuple: typing.Tuple[Base, ...] = ()
field_typing_union: typing.Union[str, bytes]
field_typing_union_list: typing.List[typing.Union[
str, bytes]] = ast.field(factory=list)
field_typing_str: str
field_typing_optional_str: typing.Optional[str]
field_typing_mapping: typing.Dict[int,
str] = ast.field(factory=dict)
field_typing_mapping_opt_key: \
typing.Dict[
typing.Optional[int], str] = ast.field(factory=dict)
class GroupStmt(FilteredStmt):
subject: Set = EmptySet() # type: ignore
using: typing.Dict[str, typing.Tuple[Set,
qltypes.Cardinality]] = (ast.field(
factory=dict))
by: typing.List[qlast.GroupingElement]
result: Set = EmptySet() # type: ignore
group_binding: Set = EmptySet() # type: ignore
grouping_binding: typing.Optional[Set] = None
orderby: typing.Optional[typing.List[SortExpr]] = None
# Optimization information
group_aggregate_sets: typing.Dict[typing.Optional[Set],
typing.FrozenSet[PathId]] = ast.field(
factory=dict)
class DMLQuery(Query):
"""Generic superclass for INSERT/UPDATE/DELETE statements."""
# Target relation to perform the operation on.
relation: typing.Optional[PathRangeVar] = None
# List of expressions returned
returning_list: typing.List[ResTarget] = ast.field(factory=list)
@property
def target_list(self):
return self.returning_list
class Options(Base):
options: typing.Dict[str, OptionValue] = ast.field(factory=dict)
def get_flag(self, k: str) -> Flag:
try:
flag = self[k]
except KeyError:
return Flag(name=k, val=False)
else:
assert isinstance(flag, Flag)
return flag
def __getitem__(self, k: str) -> OptionValue:
return self.options[k]
def __iter__(self) -> typing.Iterator[str]:
return iter(self.options)
def __len__(self) -> int:
return len(self.options)
class DeleteStmt(DMLQuery):
# WHERE clause
where_clause: typing.Optional[BaseExpr] = None
# optional USING clause
using_clause: typing.List[BaseRangeVar] = ast.field(factory=list)
class ReturningQuery(BaseRelation):
target_list: typing.List[ResTarget] = ast.field(factory=list)
class DDLOperation(DDL):
__abstract_node__ = True
commands: typing.List[DDLOperation] = ast.field(factory=list)
class FunctionCall(Expr):
func: typing.Union[tuple, str]
args: typing.List[Expr] = ast.field(factory=list)
kwargs: typing.Dict[str, Expr] = ast.field(factory=dict)
window: typing.Optional[WindowSpec] = None
class CallableObjectCommand(ObjectDDL):
__abstract_node__ = True
params: typing.List[FuncParam] = ast.field(factory=list)