Enterprise AI & Semantic Layer Glossary

The Semantic Compiler

Need to see these concepts in practice? Read our Architectural Overview.

• Semantic Execution Layer

  An infrastructure layer that compiles enterprise intent into governed, deterministic, dialect-perfect SQL. The category Colrows defines: a runtime - not a metric API or BI feature - that sits above the warehouse and below the prompt.

  Why it matters: A semantic layer that only defines meaning is advisory; an execution layer is the path every query must take, which is what makes governance and determinism structural.

  Deep dive: Semantic layer vs. semantic execution layer

• Intent

  The semantic content of a request. What a human or AI agent wants to know, independent of SQL. The Colrows compiler accepts intent as input and emits governed SQL as output.

  Why it matters: Intent is meaning. SQL is mechanics. Separating them enables determinism.

  Deep dive: How does a semantic layer work? The 7-step pipeline

• Context Resolution

  The step where every term in the request is resolved against the semantic graph using the requesting identity, role, persona, and scope. The same string ("revenue") resolves to different concepts depending on who is asking and from which scope.

  Why it matters: Multi-scope resolution enables legitimate variation without duplication across the enterprise.

  Deep dive: Multi-tenant semantic isolation

• Constrained Planning

  Query planning that searches only the typed semantic graph for valid join paths. Cannot fabricate joins or invent entities. Failed planning produces a structured error, never a guessed answer.

  Why it matters: Structural constraints eliminate the hallucinated joins and metric definitions that plague ungoverned text-to-SQL.

  Deep dive: The Text-to-SQL Accuracy Cliff

• Compile-Then-Execute Pipeline

  The Colrows runtime architecture. Intent is first compiled (resolved against the semantic graph, planned with proven joins, governance-injected) and only then executed against the warehouse. The opposite of retrieval-and-hope text-to-SQL.

  Why it matters: Compilation finds errors before they touch data. Execution never fails silently.

  Deep dive: Architecture in docs

• Join Path Proof

  A formal proof that a join path between two entities exists and is valid under the typed semantic graph's relationships. Required before SQL emission. Failed proofs abort compilation.

  Why it matters: Proven joins eliminate the fabricated relationships that break accuracy on real enterprise schemas.

  Deep dive: Deterministic vs. Probabilistic Text-to-SQL

• Dialect-Perfect SQL

  SQL emitted by the Colrows compiler that is specialized for the target engine's dialect (Snowflake, Databricks, BigQuery, Postgres). Syntactically correct, semantically faithful, optimized for that engine. Same intent produces different SQL for different warehouses.

  Why it matters: Dialect-perfect SQL eliminates the syntax errors and performance anti-patterns that plague generic text-to-SQL.

  Deep dive: SQL as a compiler target

• Semantic Graph

  The typed, versioned, multi-scope representation of business meaning that backs every Colrows query. Encodes entities, metrics, relationships, constraints, and governance in one place. The system of record for meaning, parallel to the warehouse as the system of record for data.

  Why it matters: A single source of truth for meaning prevents metric conflicts between agents and dashboards.

  Deep dive: Building the enterprise memory graph

• Multi-Vector Embeddings

  Three embedding vectors maintained per concept in the Colrows graph: definition (the formal description), usage (how the concept actually appears in queries and dashboards), and combined. Powers context-aware retrieval and disambiguation.

  Why it matters: Multiple vectors resolve ambiguity and catch renamed concepts that would break text-to-SQL.

  Deep dive: Core concepts in docs

• Consensus Layer

  The Colrows mechanism that resolves conflicts between sources of meaning (documentation, dbt definitions, observed usage, human input) to produce a single agreed-upon value for each concept in the semantic graph.

  Why it matters: Consensus eliminates the metric wars between different teams and tools.

  Deep dive: Core concepts in docs

Governance & Access Control

Need to see these concepts in practice? Read our AI Governance Guide.

• Compile-Time Governance

  Enforcement of RBAC, ABAC, and row/column-level predicates inside the compiler, before any SQL leaves the planner. Unauthorized queries fail compilation. The data is never read.

  Why it matters: Compile-time governance is structural, not advisory. Governance failures are loud, not silent.

  Deep dive: Data authorization problems and solution

• RBAC (Role-Based Access Control)

  An access-control model that grants permissions to roles and assigns roles to users. Simple and well-supported, but suffers from role explosion at enterprise scale. Typically combined with ABAC in modern deployments.

  Why it matters: RBAC alone doesn't scale. Combining RBAC with attribute-based policies handles enterprise complexity.

  Deep dive: Fine-grained data access control

• ABAC (Attribute-Based Access Control)

  An access-control model that grants or denies access based on attributes of the user, resource, action, and environment. Rather than only on assigned roles. The reference framework is NIST SP 800-162.

  Why it matters: Attribute-based rules handle cross-cutting concerns (time-based access, location, device) that roles cannot express.

  Deep dive: Data access control in docs

• Row/Column-Level Predicates

  Governance predicates that restrict access to specific rows or columns inside a table based on user identity or attributes. In Colrows, these predicates are injected at compile time as additional WHERE clauses or column projections in the generated SQL. Never as a post-query filter.

  Why it matters: Row/column predicates at compile time prevent data exfiltration at the SQL layer.

  Deep dive: Data access control in docs

• Audit Trail

  A record produced by Colrows for every query that captures the graph version, identity context, resolved entities, proven join paths, and compiled SQL. Enables point-in-time reproducibility. A historical query can be re-run with the exact definitions in force at that moment.

  Why it matters: Complete audit trails prove compliance to regulators and enable forensic analysis of data decisions.

  Deep dive: Auditable SQL for BFSI

• Point-in-Time Reproducible

  A property of Colrows audit trails. A historical query can be re-run with the exact graph version, definitions, and policies that were in force at the time, producing the same result. The basis for safe operation in regulated environments where audits arrive months after the query.

  Why it matters: Reproducibility is non-negotiable in BFSI and healthcare. It proves that past decisions were made under documented rules.

  Deep dive: Core concepts in docs

• Multi-Scope Semantics

  The property by which the same concept resolves to different definitions at different scopes (global, datastore, persona, user). Lets a single semantic graph encode legitimate per-tenant or per-team variation without duplication.

  Why it matters: Multi-scope semantics prevent metric conflicts between business units with different definitions of the same word.

  Deep dive: Multi-tenant semantic isolation

• Multi-Tenant Semantic Isolation

  The combination of scoped resolution, partitioned embeddings, and policy isolation that prevents one tenant's meaning from leaking into another's queries in a multi-tenant deployment. Even when the underlying agents and embeddings are shared.

  Why it matters: Semantic isolation is the data-layer equivalent of network isolation. Failures in one tenant never affect another.

  Deep dive: Multi-tenant semantic isolation

Autonomous Maintenance & Evolution

Need to see these concepts in practice? Read our Autonomous Maintenance Guide.

• Drift Detection

  The autonomous process of identifying when the underlying data estate (schemas, columns, foreign keys, business definitions) has drifted from the current semantic graph. Triggers proposed updates for human approval rather than silent breakage.

  Why it matters: Drift detection catches schema changes before they break queries. Loud warnings beat silent failures.

  Deep dive: Knowledge drift and semantic decay

• Knowledge Drift

  The gradual divergence between the documented meaning of business concepts and how they are actually used in queries, dashboards, and agents. The dual problem to schema drift. Addressed by drift detection and autonomous maintenance.

  Why it matters: Knowledge drift causes metric conflicts. Catching it early prevents widespread inconsistency.

  Deep dive: Knowledge drift and semantic decay

• Semantic Decay

  The slow loss of fidelity between business concepts and their representations as the data estate evolves. Renamed columns, drifting metric formulas, contradictory definitions. The technical-debt cousin of knowledge drift.

  Why it matters: Semantic decay is invisible until it breaks. Drift detection surfaces it early.

  Deep dive: Knowledge drift and semantic decay

• Autonomous Maintenance

  The continuous process by which agents detect schema or content drift, propose updates to the semantic graph, and route them for human approval. Keeping the graph current without a manual catalogue-update process.

  Why it matters: Autonomous maintenance scales. Manual catalogue updates do not.

  Deep dive: Agents that maintain your data systems

Reference documentation

Each glossary term above has a corresponding implementation surface in the Colrows SaaS documentation. The pages below are the engineering reference for what each concept does inside the platform.

• Architecture and core concepts. Architecture, core concepts, introduction.
• Connectors and ingestion. Datasource configuration, JDBC connectivity, getting started.
• Governance and access control. Data access control (RBAC, ABAC, row/column predicates), user management.
• Compile and execute surfaces. SQL editor, charts and dashboards, REST API reference, HTTP API.
• AI and authoring surfaces. Conversational AI Data Analyst, Semantiq Studio.