async def _create_edgedb_template_database(cluster, conn):
instance_params = cluster.get_runtime_params().instance_params
capabilities = instance_params.capabilities
have_c_utf8 = (capabilities & pgcluster.BackendCapabilities.C_UTF8_LOCALE)
logger.info('Creating template database...')
block = dbops.SQLBlock()
dbid = uuidgen.uuid1mc()
db = dbops.Database(
edbdef.EDGEDB_TEMPLATE_DB,
owner=edbdef.EDGEDB_SUPERUSER,
is_template=True,
template='template0',
lc_collate='C',
lc_ctype='C.UTF-8' if have_c_utf8 else 'en_US.UTF-8',
encoding='UTF8',
metadata=dict(
id=str(dbid),
builtin=True,
),
)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
return dbid
def _compile_and_apply_ddl_command(self, ctx: CompileContext, cmd):
current_tx = ctx.state.current_tx()
schema = current_tx.get_schema()
if debug.flags.delta_plan_input:
debug.header('Delta Plan Input')
debug.dump(cmd)
# Do a dry-run on test_schema to canonicalize
# the schema delta-commands.
test_schema = schema
context = self._new_delta_context(ctx)
cmd.apply(test_schema, context=context)
cmd.canonical = True
# Apply and adapt delta, build native delta plan, which
# will also update the schema.
schema, plan = self._process_delta(ctx, cmd, schema)
if isinstance(plan, (s_db.CreateDatabase, s_db.DropDatabase)):
block = pg_dbops.SQLBlock()
else:
block = pg_dbops.PLTopBlock()
plan.generate(block)
sql = block.to_string().encode('utf-8')
current_tx.update_schema(schema)
if debug.flags.delta_execute:
debug.header('Delta Script')
debug.dump_code(sql, lexer='sql')
return dbstate.DDLQuery(sql=(sql, ))
async def _make_stdlib(testmode: bool):
schema = s_schema.Schema()
current_block = None
std_texts = []
for modname in s_schema.STD_LIB + ('stdgraphql', ):
std_texts.append(s_std.get_std_module_text(modname))
if testmode:
std_texts.append(s_std.get_std_module_text('_testmode'))
ddl_text = '\n'.join(std_texts)
for ddl_cmd in edgeql.parse_block(ddl_text):
delta_command = s_ddl.delta_from_ddl(ddl_cmd,
schema=schema,
modaliases={None: 'std'},
stdmode=True)
if debug.flags.delta_plan_input:
debug.header('Delta Plan Input')
debug.dump(delta_command)
# Do a dry-run on test_schema to canonicalize
# the schema delta-commands.
test_schema = schema
context = sd.CommandContext()
context.stdmode = True
delta_command.apply(test_schema, context=context)
# Apply and adapt delta, build native delta plan, which
# will also update the schema.
schema, plan = _process_delta(delta_command, schema)
if isinstance(plan, (s_db.CreateDatabase, s_db.DropDatabase)):
if (current_block is not None
and not isinstance(current_block, dbops.SQLBlock)):
raise errors.QueryError(
'cannot mix DATABASE commands with regular DDL '
'commands in a single block')
if current_block is None:
current_block = dbops.SQLBlock()
else:
if (current_block is not None
and not isinstance(current_block, dbops.PLTopBlock)):
raise errors.QueryError(
'cannot mix DATABASE commands with regular DDL '
'commands in a single block')
if current_block is None:
current_block = dbops.PLTopBlock()
plan.generate(current_block)
sql_text = current_block.to_string()
return schema, sql_text
async def _ensure_edgedb_database(
conn,
database,
owner,
*,
cluster,
builtin: bool = False,
objid: Optional[uuid.UUID] = None,
):
result = await _get_db_info(conn, database)
if not result:
logger.info(f'Creating database: ' f'{database}')
block = dbops.SQLBlock()
if objid is None:
objid = uuidgen.uuid1mc()
db = dbops.Database(
database,
owner=owner,
metadata=dict(
id=str(objid),
builtin=builtin,
),
)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
async def _create_edgedb_database(
ctx: BootstrapContext,
database: str,
owner: str,
*,
builtin: bool = False,
objid: Optional[uuid.UUID] = None,
) -> uuid.UUID:
logger.info(f'Creating database: {database}')
block = dbops.SQLBlock()
if objid is None:
objid = uuidgen.uuid1mc()
instance_params = ctx.cluster.get_runtime_params().instance_params
db = dbops.Database(
ctx.cluster.get_db_name(database),
owner=ctx.cluster.get_role_name(owner),
metadata=dict(
id=str(objid),
tenant_id=instance_params.tenant_id,
name=database,
builtin=builtin,
),
)
tpl_db = ctx.cluster.get_db_name(edbdef.EDGEDB_TEMPLATE_DB)
dbops.CreateDatabase(db, template=tpl_db).generate(block)
await _execute_block(ctx.conn, block)
return objid
async def _create_edgedb_template_database(
ctx: BootstrapContext,
) -> uuid.UUID:
backend_params = ctx.cluster.get_runtime_params()
have_c_utf8 = backend_params.has_c_utf8_locale
logger.info('Creating template database...')
block = dbops.SQLBlock()
dbid = uuidgen.uuid1mc()
db = dbops.Database(
ctx.cluster.get_db_name(edbdef.EDGEDB_TEMPLATE_DB),
owner=ctx.cluster.get_role_name(edbdef.EDGEDB_SUPERUSER),
is_template=True,
lc_collate='C',
lc_ctype='C.UTF-8' if have_c_utf8 else 'en_US.UTF-8',
encoding='UTF8',
metadata=dict(
id=str(dbid),
tenant_id=backend_params.tenant_id,
name=edbdef.EDGEDB_TEMPLATE_DB,
builtin=True,
),
)
dbops.CreateDatabase(db, template='template0').generate(block)
await _execute_block(ctx.conn, block)
return dbid
async def _ensure_edgedb_database(conn, database, owner, *, cluster):
result = await _get_db_info(conn, database)
if not result:
logger.info(
f'Creating database: '
f'{database}')
block = dbops.SQLBlock()
db = dbops.Database(database, owner=owner)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
async def _ensure_edgedb_template_database(cluster, conn):
result = await _get_db_info(conn, edbdef.EDGEDB_TEMPLATE_DB)
if not result:
logger.info('Creating template database...')
block = dbops.SQLBlock()
dbid = uuidgen.uuid1mc()
db = dbops.Database(
edbdef.EDGEDB_TEMPLATE_DB,
owner=edbdef.EDGEDB_SUPERUSER,
is_template=True,
template='template0',
lc_collate='C',
lc_ctype=('C.UTF-8' if cluster.supports_c_utf8_locale()
else 'en_US.UTF-8'),
encoding='UTF8',
metadata=dict(
id=str(dbid),
builtin=True,
),
)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
return dbid
else:
alter = []
alter_owner = False
if not result['datistemplate']:
alter.append('IS_TEMPLATE = true')
if result['rolname'] != edbdef.EDGEDB_SUPERUSER:
alter_owner = True
if alter or alter_owner:
logger.info('Altering template database parameters...')
if alter:
await _execute(
conn,
'ALTER DATABASE {} WITH {}'.format(
edbdef.EDGEDB_TEMPLATE_DB,
' '.join(alter)))
if alter_owner:
await _execute(
conn,
'ALTER DATABASE {} OWNER TO {}'.format(
edbdef.EDGEDB_TEMPLATE_DB,
edbdef.EDGEDB_SUPERUSER))
return None
async def _ensure_edgedb_database(conn, database, owner, *, cluster):
result = await _get_db_info(conn, database)
if not result:
logger.info(f'Creating database: ' f'{database}')
block = dbops.SQLBlock()
db = dbops.Database(database, owner=owner)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
if owner != edgedb_defines.EDGEDB_SUPERUSER:
block = dbops.SQLBlock()
reassign = dbops.ReassignOwned(edgedb_defines.EDGEDB_SUPERUSER,
owner)
reassign.generate(block)
dbconn = await cluster.connect(
database=database, user=edgedb_defines.EDGEDB_SUPERUSER)
try:
await _execute_block(dbconn, block)
finally:
await dbconn.close()
async def _set_edgedb_database_metadata(
ctx: BootstrapContext,
database: str,
*,
objid: Optional[uuid.UUID] = None,
) -> uuid.UUID:
logger.info(f'Configuring database: {database}')
block = dbops.SQLBlock()
if objid is None:
objid = uuidgen.uuid1mc()
instance_params = ctx.cluster.get_runtime_params().instance_params
db = dbops.Database(ctx.cluster.get_db_name(database))
metadata = dict(
id=str(objid),
tenant_id=instance_params.tenant_id,
name=database,
builtin=False,
)
dbops.SetMetadata(db, metadata).generate(block)
await _execute_block(ctx.conn, block)
return objid
async def _create_edgedb_database(
conn,
database,
owner,
*,
builtin: bool = False,
objid: Optional[uuid.UUID] = None,
) -> uuid.UUID:
logger.info(f'Creating database: {database}')
block = dbops.SQLBlock()
if objid is None:
objid = uuidgen.uuid1mc()
db = dbops.Database(
database,
owner=owner,
metadata=dict(
id=str(objid),
builtin=builtin,
),
)
dbops.CreateDatabase(db).generate(block)
await _execute_block(conn, block)
return objid
async def _make_stdlib(
testmode: bool) -> Tuple[s_schema.Schema, str, Set[uuid.UUID]]:
schema = s_schema.Schema()
schema, _ = s_mod.Module.create_in_schema(schema, name='__derived__')
schema = s_pseudo.populate_types(schema)
current_block = None
std_texts = []
for modname in s_schema.STD_LIB + ('stdgraphql', ):
std_texts.append(s_std.get_std_module_text(modname))
if testmode:
std_texts.append(s_std.get_std_module_text('_testmode'))
ddl_text = '\n'.join(std_texts)
new_types: Set[uuid.UUID] = set()
for ddl_cmd in edgeql.parse_block(ddl_text):
delta_command = s_ddl.delta_from_ddl(ddl_cmd,
modaliases={},
schema=schema,
stdmode=True)
if debug.flags.delta_plan_input:
debug.header('Delta Plan Input')
debug.dump(delta_command)
# Apply and adapt delta, build native delta plan, which
# will also update the schema.
schema, plan = _process_delta(delta_command, schema)
if isinstance(plan, (s_db.CreateDatabase, s_db.DropDatabase)):
if (current_block is not None
and not isinstance(current_block, dbops.SQLBlock)):
raise errors.QueryError(
'cannot mix DATABASE commands with regular DDL '
'commands in a single block')
if current_block is None:
current_block = dbops.SQLBlock()
else:
new_types.update(plan.new_types)
if (current_block is not None
and not isinstance(current_block, dbops.PLTopBlock)):
raise errors.QueryError(
'cannot mix DATABASE commands with regular DDL '
'commands in a single block')
if current_block is None:
current_block = dbops.PLTopBlock()
plan.generate(current_block)
assert current_block is not None
sql_text = current_block.to_string()
mods = {
mod.get_name(schema)
for mod in schema.get_modules() if mod.get_builtin(schema)
}
if mods != s_schema.STD_MODULES:
raise errors.SchemaError(
f'modules {s_schema.STD_MODULES - mods} are not marked as builtin')
return schema, sql_text, new_types
