Skip to content

Erupt Cube Metrics Platform ​

Inspired by Google Looker's semantic layer concept, built as a professional-grade big data analytics solution for the Java ecosystem. Data engineers focus on model construction; data analysts complete visualizations self-service based on the semantic layer — no multi-party collaboration required. Define semantic models in YAML / JSON or Java annotations, build visualizations with drag-and-drop, ready to use out of the box.

Commercial Module

Includes: Full source code · All future version upgrades · Technical support · Priority Erupt-related support · Reasonable feature requests implemented for free · Continuous capability iteration License: No License restrictions · No project count limits · No commercial restrictions Limitation: Redistribution and secondary open-sourcing are prohibited

View Erupt Pro pricing and purchase process

Officially produced and maintained by the open-source Erupt framework team (GitHub 3k+ ★ · Gitee 5k+ ★). Avoids vendor lock-in and operational costs of solutions like Kylin / Looker.

Demo: https://demo.erupt.xyz   Username: cube Password: cube


What Problems Does the Semantic Model Solve? ​

Once data sources are connected, the semantic model (Cube) defines dimensions and measures in one place — every consumer shares the same semantics:

Semantic layer architecture
ProblemWithout Semantic ModelWith Semantic Model
Metric consistencyEveryone writes different SQLDefined once; changes propagate everywhere
Usage barrierMust know SQLDrag-and-drop ready
ReusabilityLogic scattered across reportsCentrally defined, reusable anywhere
MaintainabilityTable changes require updating all SQLOnly update the model layer

Three Ways to Model, One Semantic Layer ​

The same semantic model can be written three ways. The structure is identical; all three can coexist and join each other in one project, covering every role on the team:

WayTarget UserHighlightsUse Case
YAML / JSON files v2.4.0+Data engineers / analystsNo Java, no compiling; a JSON Schema gives IDE completion, and files are strictly validated at startupCore models versioned in git and code-reviewed; can be loaded from an external directory
Java annotations (most flexible)DevelopersIDE go-to / find usages / safe rename, SQL highlighting and checks for sql strings via language injection, class inheritance for shared dimensions and measures; share one class with an @Erupt entity and plug in Java extensions such as CubeProxy and custom functionsModels tightly bound to business code, or needing programmatic extension
Visual interfaceAnalysts / business usersConfigure SQL, dimensions and measures in the UIAd-hoc / exploratory modeling, quick iteration

Recommended workflow: define core models as files or annotations → business users explore through the visual interface → models that stabilize are committed as files and managed with code.

Three complementary modeling approaches

Charts inside the Model Page v2.4.0+ ​

Besides standalone dashboards and explores, cube charts can sit right in any Erupt model's view tabs: @Vis(type = Vis.Type.CUBE) declares a grid of charts in code, the list's search conditions are forwarded as cube filters, and the charts always describe the rows being filtered on screen.

CUBE view inside a model page

See Charts in Model Views.

Modeling Reference (API) ​

A semantic model = one YAML / JSON file or one @EruptCube class: it declares the base-table SQL and its exposed query views (Explores), plus dimensions and measures. Below is the same model written both ways (from xyz.erupt.project.cube.WorkItemStatsCube):

yaml
# yaml-language-server: $schema=https://docs.erupt.xyz/schema/erupt-cube.schema.json
name: Work Item Statistics
sql: |
  select wi.type         as type,
         wi.status       as status,
         u.name          as assignee_name,
         wi.story_points as story_points,
         wi.due_date     as due_date
  from e_project_work_item wi
           left join e_upms_user u on wi.assignee_id = u.id
dimensions:
  assignee_name: { title: Assignee }
  status:        { title: Status }
  due_date:      { title: Due Date, type: DATE }
measures:
  work_item_count: { title: Work Item Count, sql: count(*) }
  overdue_count:
    title: Overdue Count
    sql: sum(case when status <> 'DONE' and due_date < current_date then 1 else 0 end)
  story_points: { title: Story Points, sql: sum(story_points) }
java
@Getter
@Setter
@EruptCube(
        name = "Work Item Statistics",
        sql = """
                select wi.type         as type,
                       wi.status       as status,
                       u.name          as assignee_name,
                       wi.story_points as story_points,
                       wi.due_date     as due_date
                from e_project_work_item wi
                         left join e_upms_user u on wi.assignee_id = u.id
                """
)
public class WorkItemStatsCube {

    @Dimension(title = "Assignee", sql = "assignee_name")
    private String assigneeName;

    @Dimension(title = "Status", sql = "status")
    private String status;

    @Dimension(title = "Due Date", sql = "due_date")
    private LocalDate dueDate;

    @Measure(title = "Work Item Count", sql = "count(*)")
    private Long workItemCount;

    @Measure(title = "Overdue Count",
             sql = "sum(case when status <> 'DONE' and due_date < current_date then 1 else 0 end)")
    private Long overdueCount;

    @Measure(title = "Story Points", sql = "sum(story_points)")
    private Double storyPoints;
}

File keys are the annotation attribute names: class-level attributes at the top level, dimensions / measures / parameters in the dimensions / measures / parameters maps keyed by field name. See Semantic Modeling for the full rules.

@EruptCube (class level) ​

AttributeTypeDescription
nameStringModel name (required)
datasourceStringDatasource key; blank uses the primary datasource
descriptionStringModel description
sqlStringBase-table SQL, interpreted as a sub-query or table name per sqlType (supports VTL templates)
sqlTypeSqlTypeSUB_QUERY (default) / TABLE_NAME
exploresExplore[]Exposed query views; defaults to a single overview
promptStringPrompt supplied to the AI (markdown)
tagsString[]Tags
dataProxyClass<? extends CubeProxy>[]Before/after query hooks

@Dimension (field level · dimension) ​

AttributeTypeDescription
titleStringDimension display name (required)
typeFieldTypeAUTO (default, inferred from field type) / NUMBER / STRING / DATE
sqlStringGROUP BY column expression; defaults to the field name (supports VTL)
promptStringAI prompt
hiddenbooleanWhether hidden
tagsString[]Tags

@Measure (field level · metric) ​

AttributeTypeDescription
titleStringMetric display name (required)
typeFieldTypeSame as above
sqlStringAggregate SQL expression, e.g. sum(amount) (required)
drillFieldsString[]Detail dimension fields exposed when drilling down
drillFilterStringExtra filter applied when drilling down
promptStringAI prompt
hiddenbooleanWhether hidden
tagsString[]Tags

@Explore (query view) ​

Defines the query perspectives a cube exposes; each code maps to a set of available dimensions / metrics.

AttributeTypeDescription
codeStringUnique view code
nameStringView name
whereStringFixed filter for this view
dimensionsString[]Dimensions exposed by this view (blank = all)
measuresString[]Metrics exposed by this view (blank = all)
parametersExploreParameter[]Runtime parameters
joinsJoin[]Joins with other cubes
hiddenbooleanWhether hidden

CubeProxy (extension point) ​

Implement xyz.erupt.annotation.fun.CubeProxy and reference it via @EruptCube(dataProxy = ...) to hook in before the query expression is built and after results return (row-level permissions, tenant isolation, result post-processing):

java
public interface CubeProxy {

    // Dynamically process the query expression before it is built
    default String beforeQuery(String expr, Map<String, Object> context) {
        return expr;
    }

    // Post-process the query result after it returns
    default void afterQuery(List<CubeResultRow> result, Map<String, Object> context) {
    }
}

Why Not Use Looker / Metabase / Cube.dev / Build Your Own? ​

DimensionLooker (Google)MetabaseCube.devCustom SQL StitchingErupt Cube
Semantic Layer DefinitionLookML (proprietary DSL)Models (GUI configuration)YAML / JS SchemaNone (scattered in report SQL)YAML / JSON files + Java annotations + visual interface
Language EcosystemLookML (requires separate learning)Java / Clojure (closed-source core)Node.js / TypeScriptJavaJava (same stack as business project)
DeploymentSaaS (closed-source)Standalone service (Docker)Standalone serviceIntegrated with businessIntegrated with business project
Permission System IntegrationRequires re-integrationOwn user system requiring synchronizationNo permissions includedCustomReuses Erupt UPMS — zero cost
Vendor Lock-InHeavy (Google)No (but community edition is limited)NoNoNo (source code delivered)
Domestic Database SupportAlmost noneFairFairDepends on implementationDameng / KingbaseES / OceanBase, etc.
Price Range$5,000+/month startingOpen source + enterprise edition feesOpen source + Cloud fees0 (excluding labor)One-time purchase · View Pricing

Database Support ​

TypeProducts
Analytical Data Warehouses (OLAP)Apache Doris, StarRocks, ClickHouse, GreenPlum, Apache Hive, Presto, Trino, Impala, ADB
Relational Databases (OLTP)MySQL, PostgreSQL, Oracle, SQL Server, TiDB
Domestic DatabasesDameng (DM), KingbaseES, OceanBase
Cloud-Native Data WarehousesRedshift, Snowflake, BigQuery, Databricks, Alibaba Cloud MaxCompute, Huawei Cloud DWS

Relationship with Google Looker ​

Looker takes the semantic layer concept to the extreme with LookML: the core idea is that all metric logic is defined only once and all reports share the same semantic layer. Erupt Cube adds no new language: models are written in plain YAML / JSON (with JSON Schema completion and validation) or Java annotations, run embedded in the business project, and integrate deeply with Erupt's permission, menu, and tenant capabilities.

Who Is This For? ​

  • Mid-sized enterprise data teams (need BI but no dedicated data engineering headcount)
  • Consulting firms / data delivery vendors (need to deliver dozens of dashboards per project)
  • Traditional industry digital transformation teams (need OLAP but want to avoid Kylin / Looker pitfalls)
  • Teams already using open-source Erupt (seamless upgrade; permissions inherited naturally)

FAQ ​

Q1 · What is the difference from the open-source Erupt? Open-source Erupt provides basic CRUD, forms, and simple report capabilities. erupt-cube is a commercial module that introduces a complete semantic layer + multi-data-source + drag-and-drop analysis + dashboard capabilities — this is not included in the open-source version and will not be open-sourced in the future.

Q2 · What is the relationship between erupt-report and erupt-cube?

  • erupt-report: Configures charts directly with SQL; suitable for developers with SQL skills to quickly build fixed reports
  • erupt-cube: A semantic layer-based BI platform; suitable for data analysts doing self-service drag-and-drop analysis, covering more complex OLAP scenarios

Both can be used independently or together (chart serves developers, cube serves business analysts). If the team is large with dedicated data analysts, going straight to cube is recommended.

Q3 · How is it delivered? After payment, provide your GitHub username. The author will add you as a collaborator to the private repository erupts/erupt-cube. You can clone the source code directly, compile locally, reference as needed, and will receive an integration document.

Q4 · Do I need to pay again for future version upgrades? No. One-time purchase = you have access to the current and all future versions. The private repository's master branch is continuously updated; just git pull.

Q5 · What about project count / commercial use / reselling?

  • No project count limits: Deploy in as many internal or outsourced projects as you like
  • No commercial restrictions: Can be used in commercial products (including selling your finished product, but you may not sell the erupt-cube source code itself)
  • Reselling: Redistribution and secondary open-sourcing are prohibited; company name or entity changes can apply for license migration

Q6 · Trial / Refunds? The online demo has all features available (username cube / password cube). We recommend fully exploring it first. Once repository access is granted, delivery is considered complete and refunds are no longer supported.


For questions not listed above, visit the pricing & purchase page to contact the author.

Contributors

The avatar of contributor named as YuePeng YuePeng

Changelog

Released under the Apache-2.0 License.