Struct EntityGraphProviderImpl 

pub struct EntityGraphProviderImpl {
    query_engine: QueryEngineRef,
    catalog_manager: Weak<dyn CatalogManager>,
    permission_checker: Option<PermissionCheckerRef>,
}

The live [EntityGraphProvider], backed by the query engine.

Fields

query_engine: QueryEngineRef

catalog_manager: Weak<dyn CatalogManager>

permission_checker: Option<PermissionCheckerRef>

Implementations

impl EntityGraphProviderImpl

pub fn new( query_engine: QueryEngineRef, catalog_manager: Weak<dyn CatalogManager>, permission_checker: Option<PermissionCheckerRef>, ) -> Self

fn authorize_sources( &self, query_ctx: Option<&QueryContext>, targets: PermissionTableTargets, ) -> Result<bool, BoxedError>

Whether the caller may read the derivation sources named by targets. Ok(false) = denied: the source is silently excluded, per the derivation contract. Errors other than a denial abort the scan.

fn parse_declarations(table_info: &TableInfo) -> Vec<EntityDeclaration>

Parses greptime.semantic.entity.<type>.{id|descriptive|scope} options of one table into per-type declarations. A type with no id columns is skipped.

fn declarations_for( table_info: &TableInfo, conventions: &Conventions, ) -> Vec<EntityDeclaration>

All entity declarations of one table: the explicit options plus the zero-configuration conventions (otlp_trace_entities for trace-v1 tables — including the service identity of tables created before the ingest-side auto-stamp — and the Prometheus/OTel descriptor whitelists). An explicit declaration of a type always suppresses the implicit one, even when the explicit declaration is invalid and skipped: silently falling back would change entity identity behind the user’s back.

fn resolve_supersessions( declarations: &mut [EntityDeclaration], supersessions: Vec<(usize, String)>, )

Binds each superseded_by to the identity the superseding type has on this table, once every declaration is known. A type nothing declares here leaves the guard empty, so the superseded entity stands instead of yielding to a node that will never be derived.

fn explicitly_declares(table_info: &TableInfo, entity_type: &str) -> bool

Whether the table carries an explicit entity.<type>.id option.

fn extend_with_info_metric_conventions( table_info: &TableInfo, whitelist: &BTreeMap<String, Vec<ImplicitEntity>>, expected_source: &str, expected_metric_type: Option<&str>, declarations: &mut Vec<EntityDeclaration>, supersessions: &mut Vec<(usize, String)>, )

Implicit declarations of the well-known entity-descriptor metrics (the prometheus_info_metrics / otel_info_metrics whitelists of conventions.yaml), gated on the ingest-stamped signal_type=metric option plus the whitelist’s expected source; OTel descriptors also require metric.type=info. The metric engine’s physical table aggregates every logical table’s columns and must not contribute a duplicate source.

fn extend_with_implicit_entities( table_info: &TableInfo, entities: &[ImplicitEntity], declarations: &mut Vec<EntityDeclaration>, supersessions: &mut Vec<(usize, String)>, )

Synthesizes the applicable subset of entities on table_info: explicit declarations win, every id column must exist (no guessing), descriptive columns are filtered to those present.

async fn enumerate( &self, catalog: &str, query_ctx: Option<&QueryContext>, ) -> Result<(Vec<EntitySource>, Vec<TraceSource>), BoxedError>

Enumerates entity declarations and trace tables across a catalog. Trace tables are keyed off the engine-native table_data_model option (same check as the Jaeger query path) so pre-existing trace tables without the newer greptime.semantic.* stamps are recognized too.

fn query_window( request: &ScanRequest, ) -> Result<Option<GraphQueryWindow>, BoxedError>

The time window to derive over, taken from the scan’s observed_at predicate.

The contract (RFC “The contract”): no observed_at predicate → the product default (last hour); a missing upper bound means “up to now”; a predicate without a lower bound or in a shape that cannot be safely extracted is an error asking for an explicit range — never a silent fallback into incomplete results. Ok(None) = the window cannot match anything (e.g. a lower bound in the future with the implicit “up to now” upper bound): the scan streams empty instead of deriving.

fn read_table(&self, table: TableRef) -> Result<DataFrame, BoxedError>

async fn declared_source( &self, catalog: &str, query_ctx: Option<&QueryContext>, ) -> Result<Option<DeclaredSource>, BoxedError>

The declared-edge branch source, when the physical table exists, the caller may read it, and it still matches the canonical definition. A mismatch (upgrade skew) is an explicit error, not a silent skip: dropping declared edges would misrepresent the graph.

async fn execute_plan( &self, catalog: &str, plan: LogicalPlan, query_ctx: Option<QueryContextRef>, ) -> Result<Option<SendableRecordBatchStream>, BoxedError>

Executes a derivation plan under the caller’s context (inheriting its permissions, cancellation and deadline); context-less internal scans get a minimal default.

Trait Implementations

impl EntityGraphProvider for EntityGraphProviderImpl

fn scan_entities<'life0, 'life1, 'async_trait>( &'life0 self, catalog: &'life1 str, request: ScanRequest, query_ctx: Option<QueryContextRef>, ) -> Pin<Box<dyn Future<Output = Result<Option<SendableRecordBatchStream>, BoxedError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produces the entity registry (semantic_entities) rows for catalog. None means no source table declared an entity.

fn scan_relationships<'life0, 'life1, 'async_trait>( &'life0 self, catalog: &'life1 str, request: ScanRequest, query_ctx: Option<QueryContextRef>, ) -> Pin<Box<dyn Future<Output = Result<Option<SendableRecordBatchStream>, BoxedError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produces the relationship set (semantic_relationships) rows for catalog.

fn table_declarations( &self, table_info: &TableInfo, ) -> Vec<TableEntityDeclaration>

The entities table_info contributes to the graph: its explicit declarations merged with the ones the conventions derive. Metadata-only by contract — it runs per table on the table_semantics scan and must not touch the query engine.