Method dispatch_document

nodedb/src/data/executor/dispatch/document.rs:13–371

(&mut self, task: &ExecutionTask, op: &DocumentOp)

impl CoreLoop {
    pub(super) fn dispatch_document(&mut self, task: &ExecutionTask, op: &DocumentOp) -> Response {
        let tid = task.request.tenant_id.as_u64();
        // Pressure guard for write operations.
        let is_write = matches!(
            op,
            DocumentOp::PointPut { .. }
                | DocumentOp::PointInsert { .. }
                | DocumentOp::PointUpdate { .. }
                | DocumentOp::PointDelete { .. }
                | DocumentOp::BatchInsert { .. }
                | DocumentOp::BulkUpdate { .. }
                | DocumentOp::BulkDelete { .. }
                | DocumentOp::UpdateFromJoin { .. }
                | DocumentOp::Upsert { .. }
                | DocumentOp::InsertSelect { .. }
                | DocumentOp::BackfillIndex { .. }
                | DocumentOp::Merge { .. }
        );
        if is_write {
            if let Some(r) =
                self.check_engine_pressure(task, nodedb_mem::EngineId::DocumentSchemaless)
            {
                return r;
            }
            // FTS indexing is a side effect of every document write.
            if let Some(r) = self.check_engine_pressure(task, nodedb_mem::EngineId::Fts) {
                return r;
            }
        }
        match op {
            DocumentOp::PointGet {
                collection,
                document_id,
                surrogate,
                pk_bytes: _,
                rls_filters,
                system_as_of_ms,
                valid_at_ms,
            } => self.execute_point_get(
                task,
                super::super::handlers::point::get::PointGetParams {
                    tid,
                    collection,
                    document_id,
                    surrogate: *surrogate,
                    rls_filters,
                    system_as_of_ms: *system_as_of_ms,
                    valid_at_ms: *valid_at_ms,
                },
            ),

            DocumentOp::PointPut {
                collection,
                document_id,
                value,
                surrogate,
                pk_bytes: _,
            } => self.execute_point_put(task, tid, collection, document_id, *surrogate, value),