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