def compile_FloatConstant(expr: irast.BaseConstant, *,
ctx: context.CompilerContextLevel) -> pgast.BaseExpr:
return pgast.TypeCast(
arg=pgast.NumericConstant(val=expr.value),
type_name=pgast.TypeName(
name=pg_types.pg_type_from_ir_typeref(expr.typeref)))
def unnamed_tuple_as_json_object(expr, *, styperef, env):
has_colls = any(irtyputils.is_collection(st) for st in styperef.subtypes)
if not has_colls:
# No nested collections, take the fast path.
return pgast.FuncCall(
name=('edgedb',) + _get_json_func('row_to_array', env=env),
args=[expr], null_safe=True, ser_safe=True, nullable=expr.nullable)
vals = []
for el_idx, el_type in enumerate(styperef.subtypes):
type_sentinel = pgast.TypeCast(
arg=pgast.NullConstant(),
type_name=pgast.TypeName(
name=pgtypes.pg_type_from_ir_typeref(el_type)
)
)
val = pgast.FuncCall(
name=('edgedb', 'row_getattr_by_num'),
args=[
expr,
pgast.NumericConstant(val=str(el_idx + 1)),
type_sentinel
])
if irtyputils.is_collection(el_type):
val = coll_as_json_object(val, styperef=el_type, env=env)
vals.append(val)
return pgast.FuncCall(
name=_get_json_func('build_array', env=env),
args=vals, null_safe=True, ser_safe=True, nullable=expr.nullable)
def named_tuple_as_json_object(expr, *, styperef, env):
keyvals = []
for el_idx, el_type in enumerate(styperef.subtypes):
keyvals.append(pgast.StringConstant(val=el_type.element_name))
type_sentinel = pgast.TypeCast(
arg=pgast.NullConstant(),
type_name=pgast.TypeName(
name=pgtypes.pg_type_from_ir_typeref(el_type)
)
)
val = pgast.FuncCall(
name=('edgedb', 'row_getattr_by_num'),
args=[
expr,
pgast.NumericConstant(val=str(el_idx + 1)),
type_sentinel
])
if irtyputils.is_collection(el_type):
val = coll_as_json_object(val, styperef=el_type, env=env)
keyvals.append(val)
return pgast.FuncCall(
name=_get_json_func('build_object', env=env),
args=keyvals, null_safe=True, ser_safe=True, nullable=expr.nullable)
def scan_check_ctes(
stmt: pgast.Query,
check_ctes: List[pgast.CommonTableExpr],
*,
ctx: context.CompilerContextLevel,
) -> None:
if not check_ctes:
return
# Scan all of the check CTEs to enforce constraints that are
# checked as explicit queries and not Postgres constraints or
# triggers.
# To make sure that Postgres can't optimize the checks away, we
# reference them in the where clause of an UPDATE to a dummy
# table.
# Add a big random number, so that different queries should try to
# access different "rows" of the table, in case that matters.
base_int = random.randint(0, (1 << 60) - 1)
val: pgast.BaseExpr = pgast.NumericConstant(val=str(base_int))
for check_cte in check_ctes:
# We want the CTE to be MATERIALIZED, because otherwise
# Postgres might not fully evaluate all its columns when
# scanning it.
check_cte.materialized = True
check = pgast.SelectStmt(
target_list=[
pgast.ResTarget(val=pgast.FuncCall(name=('count', ),
args=[pgast.Star()]), )
],
from_clause=[
relctx.rvar_for_rel(check_cte, ctx=ctx),
],
)
val = pgast.Expr(kind=pgast.ExprKind.OP,
name='+',
lexpr=val,
rexpr=check)
update_query = pgast.UpdateStmt(
targets=[
pgast.UpdateTarget(name='flag',
val=pgast.BooleanConstant(val='true'))
],
relation=pgast.RelRangeVar(
relation=pgast.Relation(schemaname='edgedb', name='_dml_dummy')),
where_clause=pgast.Expr(
kind=pgast.ExprKind.OP,
name='=',
lexpr=pgast.ColumnRef(name=['id']),
rexpr=val,
))
stmt.append_cte(
pgast.CommonTableExpr(query=update_query,
name=ctx.env.aliases.get(hint='check_scan')))
def _compile_config_value(
op: irast.ConfigSet,
*,
ctx: context.CompilerContextLevel,
) -> pgast.BaseExpr:
val: pgast.BaseExpr
if op.backend_setting:
assert op.backend_expr is not None
expr = op.backend_expr
else:
expr = op.expr
with ctx.new() as subctx:
if op.backend_setting or op.scope == qltypes.ConfigScope.GLOBAL:
output_format = context.OutputFormat.NATIVE
else:
output_format = context.OutputFormat.JSONB
with context.output_format(ctx, output_format):
if isinstance(expr, irast.EmptySet):
# Special handling for empty sets, because we want a
# singleton representation of the value and not an empty rel
# in this context.
if op.cardinality is qltypes.SchemaCardinality.One:
val = pgast.NullConstant()
elif subctx.env.output_format is context.OutputFormat.JSONB:
val = pgast.TypeCast(
arg=pgast.StringConstant(val='[]'),
type_name=pgast.TypeName(name=('jsonb', ), ),
)
else:
val = pgast.TypeCast(
arg=pgast.ArrayExpr(elements=[]),
type_name=pgast.TypeName(name=('text[]', ), ),
)
else:
val = dispatch.compile(expr, ctx=subctx)
assert isinstance(val, pgast.SelectStmt), "expected SelectStmt"
pathctx.get_path_serialized_output(val,
expr.path_id,
env=ctx.env)
if op.cardinality is qltypes.SchemaCardinality.Many:
val = output.aggregate_json_output(val, expr, env=ctx.env)
# For globals, we need to output the binary encoding so that we
# can just hand it back to the server. We abuse `record_send` to
# act as a generic `_send` function
if op.scope is qltypes.ConfigScope.GLOBAL:
val = pgast.FuncCall(
name=('substring', ),
args=[
pgast.FuncCall(
name=('record_send', ),
args=[pgast.RowExpr(args=[val])],
),
# The first twelve bytes are header, the rest is the
# encoding of the actual element
pgast.NumericConstant(val="13"),
],
)
cast_name = s_casts.get_cast_fullname_from_names(
'std', 'std::bytes', 'std::json')
val = pgast.FuncCall(
name=common.get_cast_backend_name(cast_name, aspect='function'),
args=[val],
)
if op.backend_setting and op.scope is qltypes.ConfigScope.INSTANCE:
assert isinstance(val, pgast.SelectStmt) and len(val.target_list) == 1
val = val.target_list[0].val
if isinstance(val, pgast.TypeCast):
val = val.arg
if not isinstance(val, pgast.BaseConstant):
raise AssertionError('value is not a constant in ConfigSet')
return val
