Skip to main content

Glossary

For Everyone

This glossary defines the key terms and concepts used throughout Olytix Core documentation and the broader semantic layer ecosystem.

A​

Aggregation​

A calculation that combines multiple rows into a single value. Common aggregations include SUM, COUNT, AVG, MIN, and MAX. In Olytix Core, aggregations are defined as measures within cubes.

Apache Arrow​

A columnar in-memory data format used by Olytix Core for high-performance data transfer and processing. Arrow enables efficient data exchange between Olytix Core and client applications.

Apache DataFusion​

A query execution engine written in Rust that Olytix Core uses for SQL parsing, planning, and execution. DataFusion provides fast, memory-efficient query processing.

API (Application Programming Interface)​

A set of protocols and tools for building software applications. Olytix Core provides REST, GraphQL, and DAX APIs for accessing the semantic layer.

C​

Column-Level Lineage​

The tracking of data flow at the individual column level, from source tables through transformations to final metrics. Olytix Core provides end-to-end column-level lineage across all artifact types.

Compilation​

The process of converting Olytix Core project definitions (YAML and SQL files) into executable queries and metadata. Run with olytix-core compile.

Cube​

A semantic entity that defines how to analyze a dataset. A cube contains measures (aggregations), dimensions (attributes), and optionally joins to other cubes.

cubes:
  - name: orders
    sql: "SELECT * FROM {{ ref('fct_orders') }}"
    measures:
      - name: total_revenue
        type: sum
        sql: amount
    dimensions:
      - name: order_date
        type: time

D​

DAG (Directed Acyclic Graph)​

A graph structure where nodes are connected by directed edges with no cycles. Olytix Core uses a DAG to represent dependencies between sources, models, cubes, and metrics.

DAX (Data Analysis Expressions)​

A formula language used in Microsoft Power BI, Analysis Services, and Power Pivot. Olytix Core provides DAX support for Power BI compatibility.

Dependency Graph​

The DAG that tracks relationships between all Olytix Core artifacts. Dependencies flow from sources to models to cubes to metrics.

Derived Metric​

A metric calculated from other measures or metrics using an expression.

metrics:
  - name: average_order_value
    type: derived
    expression: "{orders.total_revenue} / {orders.count}"

Dimension​

An attribute used to filter, group, or slice data in queries. Dimensions categorize data for analysis.

TypeDescriptionExample
stringText valuesCountry, Status
numberNumeric valuesCustomer ID
timeDate/timestampOrder Date
booleanTrue/FalseIs Active
geoGeographicCoordinates

E​

Edge Type​

The classification of a lineage connection. Olytix Core uses edge types to describe how data flows:

  • DIRECT: Column passed through unchanged
  • RENAMED: Column name changed
  • DERIVED: Column transformed by expression
  • AGGREGATED: Column aggregated
  • JOINED: Column from join operation

Ephemeral Materialization​

A model that is not persisted to the database but instead inlined as a CTE (Common Table Expression) in downstream queries.

F​

Filter​

A condition that restricts query results. Filters can be applied to dimensions or segments.

{
  "filters": [
    {
      "dimension": "status",
      "operator": "equals",
      "value": "completed"
    }
  ]
}

Fiscal Calendar​

A custom calendar aligned to business reporting periods rather than the standard January-December calendar. Olytix Core supports custom fiscal calendar definitions.

G​

Granularity​

The level of time aggregation for a dimension or metric. Common granularities include day, week, month, quarter, and year.

dimensions:
  - name: order_date
    type: time
    granularities:
      - day
      - week
      - month

GraphQL​

A query language for APIs that allows clients to request exactly the data they need. Olytix Core provides a GraphQL endpoint for semantic queries.

H​

Headless Architecture​

An architecture pattern where the backend (Olytix Core) has no built-in user interface. Instead, it exposes APIs that any frontend or BI tool can consume.

I​

Impact Analysis​

The process of determining which downstream artifacts would be affected by a change to an upstream column or artifact.

Incremental Materialization​

A materialization strategy that only processes new or changed records rather than rebuilding the entire table.

{{ config(materialized='incremental', unique_key='id') }}

SELECT * FROM {{ source('raw', 'orders') }}
{% if is_incremental() %}
WHERE updated_at > (SELECT MAX(updated_at) FROM {{ this }})
{% endif %}

J​

Jinja​

A templating language used in Olytix Core models for dynamic SQL generation. Jinja enables the use of variables, control flow, and functions like ref() and source().

Join​

A relationship between two cubes that enables querying data across both entities.

joins:
  - name: customers
    relationship: many_to_one
    sql: "{orders}.customer_id = {customers}.customer_id"

Join Type​

The cardinality of a relationship between cubes:

  • one_to_one: Each row matches exactly one row
  • one_to_many: One row can match multiple rows
  • many_to_one: Multiple rows match one row
  • many_to_many: Multiple rows match multiple rows

K​

KPI (Key Performance Indicator)​

A measurable value that demonstrates how effectively an organization is achieving business objectives. KPIs are typically represented as metrics in Olytix Core.

L​

Lineage​

The tracking of data flow through a system, showing where data originates and how it transforms. Olytix Core provides column-level lineage.

LookML​

Looker's proprietary modeling language. When migrating from Looker, LookML views map to Olytix Core cubes.

M​

Manifest​

The compiled output of a Olytix Core project, stored as target/manifest.json. The manifest contains all resolved metadata about sources, models, cubes, and metrics.

Materialization​

The strategy for persisting a model's results. Options include view, table, incremental, and ephemeral.

Measure​

A numeric aggregation defined within a cube. Measures define how to calculate values when querying.

measures:
  - name: total_revenue
    type: sum
    sql: amount
    format: currency

Measure Type​

The aggregation function for a measure:

TypeDescription
countCount of rows
count_distinctCount of unique values
sumSum of values
avgAverage value
minMinimum value
maxMaximum value
numberCustom expression

Metric​

A business-level calculation built on cube measures. Metrics represent high-level KPIs.

metrics:
  - name: monthly_revenue
    type: simple
    expression: orders.total_revenue
    time_grain: month

Metric Type​

The category of a metric:

  • simple: Direct reference to a measure
  • derived: Calculated from other measures
  • ratio: Division of two measures (numerator/denominator)

Model​

A SQL transformation that creates a new table or view from sources or other models.

{{ config(materialized='table') }}

SELECT * FROM {{ source('raw', 'orders') }}
WHERE status = 'completed'

N​

Namespace​

A logical grouping for organizing artifacts. Cubes and metrics can be namespaced to avoid naming conflicts.

O​

OLAP (Online Analytical Processing)​

A category of software that enables analysis of data from multiple perspectives. Olytix Core provides OLAP-like capabilities through its semantic layer.

P​

Pre-Aggregation​

A materialized summary table that speeds up common queries by pre-computing aggregations.

pre_aggregations:
  - name: monthly_revenue
    measures: [total_revenue]
    dimensions: [country]
    time_dimension: order_date
    granularity: month

Primary Key​

A dimension that uniquely identifies each row in a cube. Primary keys are used for deduplication and join optimization.

dimensions:
  - name: order_id
    type: number
    sql: order_id
    primary_key: true

Project​

A collection of Olytix Core artifacts (sources, models, cubes, metrics) organized in a directory structure with a olytix-core_project.yml configuration file.

Q​

Query Planner​

The component that translates semantic queries into optimized SQL. The query planner handles join paths, aggregations, and pre-aggregation routing.

R​

Ratio Metric​

A metric that divides one measure by another.

metrics:
  - name: conversion_rate
    type: ratio
    numerator: orders.count
    denominator: sessions.count

ref() Function​

A Jinja function that references another model, creating a dependency relationship.

SELECT * FROM {{ ref('stg_orders') }}

Relationship​

See Join Type.

REST API​

A web service architecture using HTTP methods. Olytix Core's primary API is REST-based.

Row-Level Security (RLS)​

A security mechanism that restricts which rows a user can access based on policies.

security:
  row_level:
    - name: region_filter
      cube: orders
      condition: "{region} = {{user.region}}"

S​

Segment​

A reusable filter condition that can be applied to queries.

segments:
  - name: premium_customers
    sql: "{customers}.lifetime_value > 1000"

Semantic Layer​

An abstraction layer that provides consistent definitions for metrics, dimensions, and relationships. The semantic layer ensures all consumers use the same calculations.

Semantic Query​

A query expressed in terms of metrics and dimensions rather than raw SQL.

{
  "metrics": ["total_revenue"],
  "dimensions": ["order_date.month"]
}

Simple Metric​

A metric that directly references a single measure.

metrics:
  - name: revenue
    type: simple
    expression: orders.total_revenue

Source​

A definition of a raw data table in your data warehouse. Sources document existing tables without transformation.

sources:
  - name: raw
    tables:
      - name: orders
        description: Raw order data

source() Function​

A Jinja function that references a source table.

SELECT * FROM {{ source('raw', 'orders') }}

T​

Time Dimension​

A dimension of type time that enables time-based analysis with granularities and time intelligence functions.

Time Grain​

The default aggregation level for a metric (e.g., day, week, month).

Time Intelligence​

Built-in functions for time-based calculations such as YTD (Year-to-Date), MTD (Month-to-Date), prior period comparisons, and rolling windows.

Transformation​

The process of converting raw data into analytics-ready formats. Olytix Core models perform transformations using SQL.

U​

Olytix Core (Unified Analytics Modeling Platform)​

The analytics platform that unifies data transformation and semantic layer capabilities.

Unified Project​

A Olytix Core project containing all artifact types (sources, models, cubes, metrics) with unified dependency tracking and lineage.

Upstream​

The direction toward data sources in the lineage graph. Upstream lineage shows what feeds into a given artifact.

V​

View Materialization​

A model that creates a database view rather than a physical table. Views are recomputed on each query.

W​

Warehouse​

The data warehouse or database where Olytix Core reads source data and writes materialized models. Supported warehouses include PostgreSQL, Snowflake, BigQuery, and others.

X​

XMLA (XML for Analysis)​

A protocol for accessing analytical data. Olytix Core supports XMLA for Power BI connectivity.

Y​

YAML​

A human-readable data format used for Olytix Core configuration files (sources, cubes, metrics, project settings).

YTD (Year-to-Date)​

A time intelligence calculation that aggregates data from the beginning of the year to the current date.

See Also​