Function init_database_inner

crates/core/src/host/module_host.rs:582–651

(
    replica_ctx: &ReplicaContext,
    module_def: &ModuleDef,
    program: Program,
    call_reducer: impl FnOnce(Option<MutTxId>, CallReducerParams) -> (ReducerCallResult, bool),
)

}

fn init_database_inner(
    replica_ctx: &ReplicaContext,
    module_def: &ModuleDef,
    program: Program,
    call_reducer: impl FnOnce(Option<MutTxId>, CallReducerParams) -> (ReducerCallResult, bool),
) -> anyhow::Result<(Option<ReducerCallResult>, bool)> {
    log::debug!("init database");
    let timestamp = Timestamp::now();
    let stdb = replica_ctx.relational_db();
    let logger = replica_ctx.logger.system_logger();
    let owner_identity = replica_ctx.database.owner_identity;

    let tx = stdb.begin_mut_tx(IsolationLevel::Serializable, Workload::Internal);
    let auth_ctx = AuthCtx::for_current(owner_identity);
    let (tx, ()) = stdb
        .with_auto_rollback(tx, |tx| {
            // Create all in-memory tables defined by the module,
            // with IDs ordered lexicographically by the table names.
            let mut table_defs: Vec<_> = module_def.tables().collect();
            table_defs.sort_by_key(|x| &x.name);
            for def in table_defs {
                logger.info(&format!("Creating table `{}`", &def.name));
                spacetimedb_engine::update::create_table_from_def(stdb, tx, module_def, def)?;
            }

            // Create all in-memory views defined by the module.
            let mut view_defs: Vec<_> = module_def.views().collect();
            view_defs.sort_by_key(|x| &x.name);
            for def in view_defs {
                logger.info(&format!("Creating table for view `{}`", &def.name));
                create_table_from_view_def(stdb, tx, module_def, def)?;
            }

            // Insert the late-bound row-level security expressions.
            for rls in module_def.row_level_security() {
                logger.info(&format!("Creating row level security `{}`", rls.sql));

                let rls = RowLevelExpr::build_row_level_expr(tx, &auth_ctx, rls)
                    .with_context(|| format!("failed to create row-level security: `{}`", rls.sql))?;
                let table_id = rls.def.table_id;
                let sql = rls.def.sql.clone();
                stdb.create_row_level_security(tx, rls.def)
                    .with_context(|| format!("failed to create row-level security for table `{table_id}`: `{sql}`",))?;
            }

            stdb.set_initialized(tx, program)?;

            anyhow::Ok(())
        })
        .inspect_err(|e| log::error!("{e:?}"))?;

    let rcr = match module_def.lifecycle_reducer(Lifecycle::Init) {
        None => {
            if let Some((_tx_offset, tx_data, tx_metrics, reducer)) = stdb.commit_tx(tx)? {
                stdb.report_mut_tx_metrics(reducer, tx_metrics, Some(tx_data));
            }
            (None, false)
        }