Cube Core version 1.2 is the [latest release](https://github.com/cube-js/cube/releases/tag/v1.2.0) to date. It includes features such as:
* [Data access policies](#data-access-policies) for access control. 
* [Hierarchies and folders](#hierarchies-and-folders) in the data model.
* [New features in Playground](#new-in-playground).
* Apache Pinot and Vertica as [supported data sources](#new-in-data-source-support).
* [Performance optimizations](#performance-optimizations) in Cube Store and APIs.

__This release has no breaking changes.__ You should be able to upgrade without any changes to your existing data models or configurations.

## Data access policies

With data access policies, you can define member-level and row-level access control rules in data model files and assign them to user roles, allowing for an organized and maintainable approach to security.

Here is an example of how a data access policy is defined in a cube:

```yaml
views:
  - name: orders
    # ...

    access_policy:
      - role: manager
        conditions:
          - if: "{ securityContext.is_EMEA_based }"
        member_level:
          includes:
            - created_at
            - status
            - count
        row_level:
          filters:
            - member: country
              operator: equals
              values: [ "{ securityContext.country }" ]
```

Watch this demo to see data access policies in action:

<div><div style={{position: 'relative', paddingTop: '75%'}}><iframe src="https://www.youtube.com/embed/yJfnYB27wSQ" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

Read more in the [announcement](https://cube.dev/blog/introducing-data-access-policies-ga-and-ldap-integration-in-cube-cloud) and check out the [documentation](https://cube.dev/docs/product/auth/data-access-policies).

## Hierarchies and folders

With hierarchies, you can organize related dimensions and assign them to certain levels of granularity. With folders, you can group members of a view into logical folders to make it easier to navigate and understand the data model.

These entities can be leveraged by visualization tools that support them. Except for Playground, these are currently Cube Cloud-only integrations with Tableau, Microsoft Excel, and Microsoft Power BI.

Example hierarchy definition:

```yaml
cubes:
  - name: customers
    # ...

    dimensions:
      # Dimension definitions skipped for brevity

    hierarchies:
      - name: location
        title: Customer Location
        levels:
          - country
          - state
          - city
          - zip_code
```

Example folder definition:

```yaml
views:
  - name: employee_details

    cubes:
      - join_path: employees
        includes:
          # List of members skipped for brevity

    folders:
      - name: Personally Identifiable Information
        includes:
          - first_name
          - last_name
          - location
```

Once you've defined hierarchies and (or) folders in your data model, you can use Playground to explore them visually:

<div><div style={{position: 'relative', paddingTop: '75%'}}><iframe src="https://www.youtube.com/embed/Y5E6DmH_Hz4" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

Read more in the [announcement](https://cube.dev/blog/introducing-hierarchies-and-folders-support). Check the documentation: [hierarchies](https://cube.dev/docs/reference/data-model/hierarchies), [folders](https://cube.dev/docs/reference/data-model/view#folders).

## New in Playground

Except for the support for hierarchies and folders, Playground has got the support for [custom time dimension granularities](https://cube.dev/blog/introducing-custom-time-dimension-granularities), [boolean logical filters](https://cube.dev/docs/product/apis-integrations/rest-api/query-format#boolean-logical-operators) composition, and options to set limit/offset or request the count of all rows in the result set as if there's no limit.

Take a quick look at the improvements to Playground:

<div><div style={{position: 'relative', paddingTop: '75%'}}><iframe src="https://www.youtube.com/embed/4epojUSQvOU" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

Oh, and you can now close all tabs at once!

## New in data source support

Cube has got the support for a couple of new data sources: [Apache Pinot](https://cube.dev/docs/product/configuration/data-sources/pinot) and [Vertica](https://cube.dev/docs/product/configuration/data-sources/vertica), both contributed by members of the Cube community.

We have also transitioned [ClickHouse](https://cube.dev/docs/product/configuration/data-sources/clickhouse) support to the official `@clickhouse/client` package, which brought a number of improvements and optimizations.

Finally, [DuckDB](https://cube.dev/docs/product/configuration/data-sources/duckdb) users can now specify extensions to be loaded via the `CUBEJS_DB_DUCKDB_EXTENSIONS` environment variable.

## New in configuration

The [`scheduled_refresh_time_zones` configuration option](https://cube.dev/docs/reference/configuration/config#scheduled_refresh_time_zones) can now be implemented as a function that accepts a security context as an argument:

```python
from cube import config

@config('scheduled_refresh_time_zones')
def scheduled_refresh_time_zones(ctx: dict) -> list[str]:
  time_zones = {
    'tenant_1': ['America/New_York'],
    'tenant_2': ['America/Chicago'],
    'tenant_3': ['America/Los_Angeles']
  }
  default_time_zones = ['UTC']
  tenant_id = ctx['securityContext']['tenant_id']
  return time_zones.get(tenant_id, default_time_zones)
```

In multitenancy scenarios, this allows you to build pre-aggregations for different tenants in their respective time zones only. This can substantially reduce the number of pre-aggregation partitions that need to be built.

## New in CLI

The [`deploy` command](https://cube.dev/docs/reference/cli#deploy) of the CLI tool now supports the `--replace-env` flag. If you [deploy with CLI](https://cube.dev/docs/product/deployment/cloud/continuous-deployment#deploy-with-cli), you can use this flag to _upload and replace_ environment variables every time.

```bash
npx cubejs-cli deploy --replace-env --directory PATH --token TOKEN
```

## New in the client library

The JavaScript client library now supports the `fillWithValue` [pivot configuration](https://cube.dev/docs/reference/frontend/cubejs-client-core#pivotconfig) option. It will use the provided value to fill the measure values for missing dates in the result set.

## Performance optimizations

When Cube Store executes queries against pre-aggregations, the results need to be transformed into the format that the SQL API or the REST API expect. We have optimized this process by moving the transformation logic to the native code, written in Rust, and performing the transformation asynchronously, so that the Node.js event loop is not blocked.

This brings a tangible performance improvement to Cube deployments running heavy queries that include dozens of dimensions and measures. On average, this speeds up the transformation process by 40-50% or by hundreds of milliseconds per query (if it has from 50 to 100 members).

Before the optimization:

![](https://ucarecdn.com/aea8c399-7855-4d36-94e3-980dce5b7db9/)

After the optimization:

![](https://ucarecdn.com/9ae8b133-864f-4127-8d13-fda9596005ee/)

## What's next?

As this is a release without breaking changes, we encourage you to upgrade and give it a try. You can also do that for free in [Cube Cloud](https://cubecloud.dev/auth/signup).

We can't wait to hear your feedback and thoughts in the [Slack community](https://slack.cube.dev), both about the updates above and the features from the [Cube Core public roadmap](https://github.com/cube-js/cube/issues/8492).

Enjoy the new features and happy Cube-ing!

Igor Lukanin

Changelog

Cube Core v1.2 — Data access policies, hierarchies & folders, updates to Playground

Recently, Cube Core version 0.36 was [released](https://github.com/cube-js/cube/releases). It includes long-awaited features and numerous enhancements to Cube Core, such as:
* [Playground 2.0 and Chart Prototyping](#playground-20-and-chart-prototyping). 
* [Custom granularities](#custom-time-dimension-granularities) for time dimensions.
* [Query pushdown](#query-pushdown) in the SQL API.
* [Streaming mode](#streaming-mode) in the SQL API.
* [Performance optimizations](#performance-optimizations) in Cube Store.

Also, some previously deprecated features were removed, so there are a few breaking changes to review before upgrading, such as:

* [Version upgrades](#version-upgrades) in Docker images.
* [Redis support for in-memory cache and queue](#using-redis-for-in-memory-cache-and-queue) removal.
* [`/v1/run-scheduled-refresh` endpoint](#v1run-scheduled-refresh-endpoint) removal.

Finally, the [documentation has notably expanded](#new-in-the-documentation) as well.

## New in the UI

### Playground 2.0 and Chart Prototyping

Releasing Playground 2.0 and Chart Prototyping is by far the biggest change to Cube Core ever, at least visually.

Playground now provides a refreshed BI-like experience and UI for running queries and validating the data model while you're building it. Chart Prototyping enables you to go from a query in Playground to a minimal yet complete application source code that you can download and modify to build an embedded analytics experience. These features were both part of our [public roadmap](https://github.com/cube-js/cube/issues/8492).

Here's how they work:

<div><div style={{position: 'relative', paddingTop: '56.25%'}}><iframe src="https://www.youtube.com/embed/5T7RfG_S7FY" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

And here's what some of Cube community members think about them:

![](https://ucarecdn.com/91d6dc0d-6979-4f43-a495-f9a8822ce3ad/)

Read more in the [blog post](https://cube.dev/blog/introducing-playground-2-0-and-chart-prototyping-in-cube-core) and check the documentation: [Playground](https://cube.dev/docs/product/workspace/playground), [Chart Prototyping](https://cube.dev/docs/product/workspace/vizard).

## New in data modeling

### Custom time dimension granularities

Now Cube Core provides the first-class support for calculations involving fiscal and custom time dimension granularities. With this feature,  you're able to define granularities such as a *fiscal year*, a *fiscal quarter*, or a *week starting on Sunday* for any time dimension, query them via all supported APIs, and have these queries accelerated by pre-aggregations. This feature was part of our [public roadmap](https://github.com/cube-js/cube/issues/8492).

Here's an example of data model with a few custom granularities:

```yaml
cubes:
  - name: custom_granularities
    sql: >
      SELECT '2024-01-15'::TIMESTAMP AS timestamp UNION ALL
      SELECT '2024-02-15'::TIMESTAMP AS timestamp UNION ALL
      SELECT '2024-03-15'::TIMESTAMP AS timestamp UNION ALL
      SELECT '2024-04-15'::TIMESTAMP AS timestamp UNION ALL
      SELECT '2024-05-15'::TIMESTAMP AS timestamp

    dimensions:
      - name: timestamp
        sql: timestamp
        type: time

        granularities:
          - name: sunday_week
            interval: 1 week
            offset: -1 day

          - name: fiscal_year
            interval: 1 year
            offset: -3 months

      - name: timestamp__sunday_week
        sql: "{timestamp.sunday_week}"
        type: time

      - name: timestamp__fiscal_year
        sql: "{timestamp.fiscal_year}"
        type: time
```

Read more in the [blog post](https://cube.dev/blog/introducing-custom-time-dimension-granularities) and check the documentation: [time dimension concept](https://cube.dev/docs/product/data-modeling/concepts#time-dimensions), [new `granularities` parameter](https://cube.dev/docs/reference/data-model/dimensions#granularities), [proxy dimensions with granularities](https://cube.dev/docs/product/data-modeling/concepts/calculated-members#time-dimension-granularity). Also, check the new recipe on [implementing custom time dimension granularities](https://cube.dev/docs/guides/recipes/data-modeling/custom-granularity).

### Improvements to the data model generation

Generating the data model based on the database schema is extremely useful for bootstrapping Cube Core applications, so we've made a few improvements to it.

Now Cube Core will do its best to [detect primary and foreign keys](https://github.com/cube-js/cube/pull/8115/files) in the database schema, [generate composite primary keys](https://github.com/cube-js/cube/pull/7929/files) in the data model as well as [detect boolean columns](https://github.com/cube-js/cube/pull/8637) and generate dimensions for them.

## New in the SQL API

### Query pushdown

We have introduced the query pushdown in the SQL API in Cube Core v0.35.40 and have been polishing it ever since. Query pushdown drastically improves the support for [various BI tools](https://cube.dev/docs/product/configuration/visualization-tools) and takes it to the next level.

With this feature, Cube now can seamlessly transpile an incoming SQL query, in Postgres dialect, generated by your BI tool, to the SQL dialect of a [supported upstream data source](https://cube.dev/docs/product/configuration/data-sources) (e.g., Snowflake, Databricks, BigQuery, or Redshift). Thanks to the e-graph technology, all possible execution branches are evaluated in parallel, so that Cube can choose the most optimal query plan:

![sql-api-diagram](https://ucarecdn.com/70646e5a-12bd-45a3-84ad-004de11ed536/-/quality/smart/-/format/auto/)

Query pushdown has long been in use by lots of Cube Core users and Cube Cloud customers, and it does wonders with regards to the BI support. You can hear from one of the early adopters:

<Quote authorName="Guy Dawson" authorAvatar="https://ucarecdn.com/b6e73d70-bb52-4f40-a0ee-cc0eeca2dd0c/" authorRole="Engineer at Permutive">
Query pushdown in the SQL API enabled us to create calculated dimensions and measures on the fly in Preset (using the custom SQL functionality). This enabled prototyping of new dashboards without first having to update the data model in Cube.
</Quote>

Read more in the [blog post](https://cube.dev/blog/query-push-down-in-cubes-semantic-layer) and check the documentation: [SQL API fundamentals](https://cube.dev/docs/product/apis-integrations/sql-api#fundamentals), [SQL API query format](https://cube.dev/docs/product/apis-integrations/sql-api/query-format#post-processing-and-pushdown), [SQL API reference](https://cube.dev/docs/reference/sql-api#sql-functions-and-operators).

### Streaming mode

SQL API can now leverage an optimization, also known as the *streaming mode*, that would stream the result set from the data source rather than load it in batches.

With this feature, the SQL API provides a way to override the maximum row limit in the result set, so that your SQL API query can potentially return an unlimited number of rows, e.g., a million rows.

Read more in the documentation: [streaming mode in the SQL API](https://cube.dev/docs/product/apis-integrations/sql-api#streaming), [default row limit](https://cube.dev/docs/product/apis-integrations/queries#row-limit), [`CUBEJS_DB_QUERY_LIMIT` environment variable](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_db_query_limit).

### Default ordering opt-in

By default, Cube applies an ordering to any query that does not set it explicitly, using a set of heuristics that work well for most data visualization purposes. However, this behavior can have performance implications.

Since Cube Core v0.36.0, this behavior does not apply to the SQL API queries without an `ORDER BY` clause; they do not get the default ordering. However, you can set the `CUBESQL_SQL_NO_IMPLICIT_ORDER` environment variable to `false` to opt back in for the default ordering for the SQL API queries.

Read more in the documentation: [default ordering](https://cube.dev/docs/product/apis-integrations/queries#order).

### Max session limit

Each concurrent connection to the SQL API consumes some resources and attempting to establish too many connections at once can lead to an out-of-memory crash.

Now you can use the `CUBEJS_MAX_SESSIONS` environment variable to adjust the [session limit](https://cube.dev/docs/product/apis-integrations/sql-api#session-limit). By default, it's set to 1024 connections.

## New in the REST API

### Default ordering opt-out

By default, Cube applies an ordering to any query that does not set it explicitly, using a set of heuristics that work well for most data visualization purposes. However, this behavior can have performance implications.

Now you can opt out from default ordering for the REST API queries by passing an empty array (`[]`) object as the `order` parameter of your query.

Read more in the documentation: [default ordering](https://cube.dev/docs/product/apis-integrations/queries#order).

## New in Cube Store

### Performance optimizations

Cube Store is the purpose-built query queue, in-memory cache, and pre-aggregation storage for Cube, and it is instrumental to the performance of Cube deployments.

The latest version of Cube Core implements a few substantial performance optimizations to Cube Store, including the usage of the [`jemalloc` allocator](https://jemalloc.net) for [RocksDB](https://rocksdb.org), an embeddable key-value storage used internally in Cube Store. As a result, Cube Store now has a visibly reduced memory consumption.

This has already been noted in the Cube community:

![](https://ucarecdn.com/f8b7d179-efab-4f11-b24e-6791381d1bb2/)

## New in data source support 

### Improvements to Databricks support

Databricks is widely used with Cube and it's important that it has the first-class support. A few recent improvements to it include:

* `count_distinct_approx` measures can be used with Databricks.
* [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) sketches can be loaded from Databricks to enable the usage of `count_distinct_approx` measures with pre-aggregations.
* Pre-aggregations can be built even if Cube only has *read-only* access to Databricks.

Read more in the documentation: [Databricks support](https://cube.dev/docs/product/configuration/data-sources/databricks-jdbc#pre-aggregation-feature-support), [`count_distinct_approx` measures](https://cube.dev/docs/reference/data-model/types-and-formats#count_distinct_approx).

### Improvements to ClickHouse support

ClickHouse is also widely used with Cube.

`count_distinct_approx` measures can now be used with ClickHouse as well, powered by the efficient `uniq` function.

Read more in the documentation: [ClickHouse support](https://cube.dev/docs/product/configuration/data-sources/clickhouse#pre-aggregation-feature-support), [`count_distinct_approx` measures](https://cube.dev/docs/reference/data-model/types-and-formats#count_distinct_approx).

### Support for RisingWave

Streaming data sources are among [many ones supported](https://cube.dev/docs/product/configuration/data-sources) by Cube, and we're always glad to expand that support.

Cube now works with RisingWave, an innovative distributed streaming database that enables processing and management of real-time data.

Read more in the [blog post](https://cube.dev/blog/announcing-support-for-risingwave-in-cube) and check the documentation: [RisingWave support](https://cube.dev/docs/product/configuration/data-sources/risingwave).

## BREAKING: Changes to Docker images

### Version upgrades

Even though Cube Core is distributed as [Docker images](https://hub.docker.com/r/cubejs/cube), Cube uses Python and Node.js internally as runtime environments for the code of its configuration, dynamic data models, and dependencies. So, it is important to make sure that your code and dependencies are compatible with the versions in the runtime:

* __Python has been upgraded to v3.11.__
* __Node.js has been upgraded to v20.17.__ Also, support for [Node.js v16](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#nodejs-16) has been removed; support for [Node.js v18](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#nodejs-18) has been deprecated.
* Java Development Kit, used by some database drivers, has been upgraded to v17.
* OpenSSL has been upgraded to v3.
* Finally, the operating system of the Docker images has been upgraded to Debian v12 (*bookworm*).

Also, some work has been done to reduce the size of Docker images.

## BREAKING: Removed features

### Using Redis for in-memory cache and queue

In previous versions, Redis has been used as the storage for in-memory cache and queue. However, it has been deprecated since Cube Core v0.32.

**Now, support for Redis has been [removed](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#using-redis-for-in-memory-cache-and-queue).** It is recommended to remove Redis from your deployments and use Cube Store since it's the purpose-built query queue, in-memory cache, and pre-aggregation storage for Cube.

Read more and follow the migration instructions in this [blog post](https://cube.dev/blog/how-you-win-by-using-cube-store-part-1).

### `/v1/run-scheduled-refresh` endpoint

In previous versions, Cube supported working in serverless environments. However, it has been deprecated since Cube Core v0.31.64. Also, the `/v1/run-scheduled-refresh` API endpoint, that was only useful for serverless deployments, has been deprecated since v0.35.

**Now, the `/v1/run-scheduled-refresh` endpoint has been [removed](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#v1run-scheduled-refresh-rest-api-endpoint).** It is recommended to use the Orchestration API and the `/v1/pre-aggregations/jobs` endpoint instead.

Learn more about the Orchestration API in the [blog post](https://cube.dev/blog/introducing-orchestration-api) and check the [documentation](https://cube.dev/docs/product/apis-integrations/orchestration-api).

### `USER_CONTEXT` context variable

You can use a number of [context variables](https://cube.dev/docs/reference/data-model/context-variables) when defining your data model. The `USER_CONTEXT` variable has been deprecated since v0.26. Note that its alias, the `SECURITY_CONTEXT` variable, has also been deprecated since v0.33.

**Now, the `USER_CONTEXT` variable has been [removed](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#user_context).** It is recommended to use the `COMPILE_CONTEXT` variable instead of `USER_CONTEXT` or `SECURITY_CONTEXT`.

Read more in the documentation: [`COMPILE_CONTEXT` variable](https://cube.dev/docs/reference/data-model/context-variables#compile_context).

### `checkAuthMiddleware` configuration option

Before Cube has started to be distributed as Docker images, the `checkAuthMiddleware` configuration option could be used to control the authentication process. However, it has been deprecated since Cube Core v0.26.

**Now, the `checkAuthMiddleware` configuration option has been [removed](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#checkauthmiddleware).** It is recommended to use the [`checkAuth` option](https://cube.dev/docs/config#options-reference-check-auth) instead.

## New in the documentation

With the evolution of Cube Core, its documentation evolves as well, so there are a few useful changes the documentation to know:

* __Configuration.__ List of [supported visualization tools](https://cube.dev/docs/product/configuration/visualization-tools) has greatly expanded and now includes Databricks Unity Catalog, Looker Studio, QuickSight, etc.
* __Data modeling.__ [Calculated members](https://cube.dev/docs/product/data-modeling/concepts/calculated-members) are now explained in depth, including the concepts of *calculated measures*, *proxy dimensions*, and *subquery dimensions*.
* __Data modeling.__ [Publicity](https://cube.dev/docs/product/data-modeling/concepts/publicity), which is the basis for *member-level security* in Cube, now has a dedicated page with best practice recommendations.
* __Pre-aggregations.__ The [matching algorithm](https://cube.dev/docs/product/caching/matching-pre-aggregations) now has a dedicated page with troubleshooting tips.
* __APIs & integrations.__ A new page that explains [querying all data APIs](https://cube.dev/docs/product/apis-integrations/queries) has been added. It covers query defaults (e.g., ordering and row limit) and provides an overview of supported query types. 
* __Recipes.__ List of self-contained examples of Cube configuration for popular use cases has expanded with recipes for [data model multitenancy](https://cube.dev/docs/guides/recipes/multitenancy/custom-data-model-per-tenant), [custom sorting](https://cube.dev/docs/guides/recipes/queries/sorting), [referencing environment variables](https://cube.dev/docs/guides/recipes/code-reusability/environment-variables), and [disabling pre-aggregations](https://cube.dev/docs/guides/recipes/query-acceleration/disabling-pre-aggregations).

Finally, links to community-maintained resources has been added:
* Helm charts for Cube Core deployments in Kubernetes: [`gadsme/charts`](https://github.com/gadsme/charts) and
[`OpstimizeIcarus/cubejs-helm-charts-kubernetes`](https://github.com/OpstimizeIcarus/cubejs-helm-charts-kubernetes/tree/release-v0.1).
* [Client library for Python](https://github.com/mharrisb1/cube-http-client).

## What's next?

We are sure that Cube Core v0.36 is the best Cube Core release ever, and we wholeheartedly encourage you to upgrade. You can also give it a try for free in [Cube Cloud](https://cubecloud.dev/auth/signup) where this release is available as fully-managed Cube deployments.

As always, please share your feedback and thoughts with us via the [Slack community](https://slack.cube.dev). It really helps us drive the Cube development further.

Cube Core v1.2 — data access policies, hierarchies & folders, performance, and nicer Playground

Today, live on the stage of our first user conference, [Cube Rollup](https://cube.dev/blog/introducing-next-gen-data-modeling-ai-powered-capabilities-and-enhanced), we have finally released the first major version of Cube Core: v1.0.

Apart from small fixes and improvements on top of Cube Core v0.36 (see [its changelog](https://cube.dev/blog/cube-core-v0-36-playground-2-0-custom-granularities-query-pushdown)), this release brings a single breaking change.

**Now, [query pushdown in the SQL API](https://cube.dev/blog/cube-core-v0-36-playground-2-0-custom-granularities-query-pushdown#new-in-the-sql-api) is on by default.** It is controlled by the `CUBESQL_SQL_PUSH_DOWN` environment variable. We do recommend to keep its default value so that you can get the best experience using the SQL API with BI tools.

We encourage you to upgrade and enjoy using this release. Also, we invite you to share your feedback and thoughts with us via the [Slack community](https://slack.cube.dev).

Major release of Cube Core with a single yet impactful breaking change

Cube Core v1.0 — Query pushdown in the SQL API by default

Substantial updates to the UI, SQL API, data modeling, and data source support

Cube Core v0.36 — Playground 2.0, custom granularities, query pushdown

[Cube Core](https://github.com/cube-js/cube) releases [v0.34.35 thru v0.35](https://github.com/cube-js/cube/releases) bring a few of enhancements to data modeling, improve the support for data sources, update a couple of default settings, and remove support for niche legacy features.

## Title and format for view members

As of 0.34.48, [view](https://cube.dev/docs/reference/data-model/view) members [inherit](https://github.com/cube-js/cube/pull/7617) [`title`](https://cube.dev/docs/reference/data-model/dimensions#title) and `format` parameters from respective cube members so you can access them via the [`/meta` REST API endpoint](https://cube.dev/docs/reference/rest-api#v1meta).

## `FILTER_GROUP` context variable

As of 0.34.56, the new [`FILTER_GROUP` context variable](https://cube.dev/docs/reference/data-model/context-variables#filter_group) was [introduced](https://github.com/cube-js/cube/pull/7766) for cases when multiple [`FILTER_PARAMS`](https://cube.dev/docs/reference/data-model/context-variables#filter_params) are used in SQL definitions of cubes or when filters with complex [boolean operators](https://cube.dev/docs/product/apis-integrations/rest-api/query-format#boolean-logical-operators) are used in Cube queries.

```yaml
cubes:
  - name: cube_name
    sql: >
      SELECT *
      FROM table
      WHERE {FILTER_GROUP(
        FILTER_PARAMS.cube_name.member_name.filter(sql_expression),
        FILTER_PARAMS.cube_name.another_member_name.filter(sql_expression)
      )}

    dimensions:
      - name: member_name
        # ...

      - name: another_member_name
        # ...
```

If you use `FILTER_PARAMS` in your data models, please familiarize yourself with new examples in the [documentation](https://cube.dev/docs/reference/data-model/context-variables#filter_group).

## Export bucket for ClickHouse

As of 0.34.61, you can [configure](https://github.com/cube-js/cube/pull/7849) an [export bucket](https://cube.dev/docs/product/configuration/data-sources/clickhouse#export-bucket) on AWS S3 and improve [pre-aggregation build performance](https://cube.dev/docs/product/caching/using-pre-aggregations#export-bucket) with large datasets in [ClickHouse](https://cube.dev/docs/product/configuration/data-sources/clickhouse).

## Local database path for DuckDB

As of 0.34.57, you can [use](https://github.com/cube-js/cube/pull/7799) the [`CUBEJS_DB_DUCKDB_DATABASE_PATH` environment variable](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_db_duckdb_database_path) to specify a local database path for [DuckDB](https://cube.dev/docs/product/configuration/data-sources/duckdb).

## AWS S3 configuration for DuckDB

As of 0.34.47, you can [use](https://github.com/cube-js/cube/pull/7544) the [`CUBEJS_DB_DUCKDB_S3_USE_SSL`](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_db_duckdb_s3_use_ssl), `CUBEJS_DB_DUCKDB_S3_URL_STYLE`, and `CUBEJS_DB_DUCKDB_S3_SESSION_TOKEN` environment variables to configure the access to data on AWS S3 buckets for [DuckDB](https://cube.dev/docs/product/configuration/data-sources/duckdb).

## Cluster option for Materialize

As of 0.34.58, you can [use](https://github.com/cube-js/cube/pull/7773) the [`CUBEJS_DB_MATERIALIZE_CLUSTER` environment variable](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_db_materialize_cluster) to configure the cluster name for [Materialize](https://cube.dev/docs/product/configuration/data-sources/materialize).

## Default data model path changed

As of 0.35, Cube assumes that the data model files are placed in the `model` folder (rather than the `schema` folder). It helps remove the confusion between the database schema and the semantic layer data model. So, the default value of the [`CUBEJS_SCHEMA_PATH` environment variable](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_schema_path) is [updated](https://github.com/cube-js/cube/commit/175c781790a71a164c6ac45f3e35f40a193d564e) to `model`.

![](https://ucarecdn.com/06ee4a46-87a5-42be-8601-3a84d451fa9a/)

## Default column fetch order changed

As of v0.33.57, a new [community-contributed](https://github.com/cube-js/cube/pull/6965) [`CUBEJS_DB_FETCH_COLUMNS_BY_ORDINAL_POSITION` environment variable](https://cube.dev/docs/reference/configuration/environment-variables#cubejs_db_fetch_columns_by_ordinal_position) was introduced to fix the unreliable behavior of Redshift when exporting pre-aggregations. In 0.35, this variable is set to `true` by default.

## `cubejs` renamed to `cube` in JavaScript SDK

In line with the [transition](https://cube.dev/blog/cube-js-is-now-cube) that was announced more than a year ago, we've [updated](https://github.com/cube-js/cube/commit/3f8f8071551285ba51522a98932a69334a56e16e) the public API of the JavaScript SDK to use `cube` instead of `cubejs`. Package names, e.g., `@cubejs-client/core` and `@cubejs-client/react`, stay intact. The reference [documentation](https://cube.dev/docs/reference/frontend/cubejs-client-core) has been updated accordingly.

```javascript
import cube from "@cubejs-client/core"

const apiUrl = "..."
const apiToken = "..."
const cubeApi = cube(apiToken, { apiUrl })

// ...
```

## Alpine-based Docker images removed

We've decided to [remove](https://github.com/cube-js/cube/commit/a64222dd8a55201808fede831d1ddb71bac608cc) Alpine Docker images from [Docker Hub](https://hub.docker.com/u/cubejs) to reduce the burder of maintaining [Python support](https://cube.dev/blog/cube-core-v0-34-34-python-and-powerful-updates#python-for-configuration-and-data-modeling) with these images.

## Legacy MySQL-based SQL API removed

Before the [introduction](https://cube.dev/blog/expanded-bi-support) of Postgres-compatible Cube's [SQL API](https://cube.dev/docs/product/apis-integrations/sql-api) a couple of years ago, we prototyped an early version of it that was based on MySQL protocol. Since it was only used by a few early adopters and is not maintained anymore, we've [removed](https://github.com/cube-js/cube/commit/97c242e6e8d8e893318a9c2b3c894da872848252) it alongside with the `CUBEJS_SQL_PORT` environment variable.

## Legacy serverless packages removed

With the [introduction](https://cube.dev/blog/cubejs-loves-docker) of Docker-based architecture more than three years ago, serverless NPM packages (i.e., `cubejs-serverless`, `cubejs-serverless-aws`, and `cubejs-serverless-google`) started to become increasingly less and less relevant. Now, we're removing them completely.

## Legacy `initApp` hook removed

In pre-Docker era, there was a way to run arbitrary code when Cube starts that is not relevant anymore. So, we've [removed](https://github.com/cube-js/cube/commit/014c9a582903eb140e0d964718aa5532e3a142cf) the `initApp` hook completely as well.

## Node.js 14 removed, Node.js 16 deprecated

Internally, Cube uses Node.js as runtime for a part of its code base. Since Node.js 14 and 16 reached their end of life on April 30, 2023 and September 11, 2023, respectively, we've removed the support for the former and deprecated the support for the latter. Most likely, this change applies to you if you're developing a custom [data source driver](https://cube.dev/docs/product/configuration/data-sources#third-party-drivers).

## What's next?

In addition to updates mentioned above, we have substantially improved the SQL API and the support for various BI tools. We will be announcing specific improvements as we reach our internal milestones.

**Please feel free to upgrade and try v0.35 today in Cube Core with our Docker distribution. It's also available on the latest release channel in [Cube Cloud](https://cubecloud.dev/auth/signup).**

As always, please don't hesitate to [get in touch](https://cube.dev/contact) with us and share your feedback in our [Slack community](https://slack.cube.dev) of more than 10,000 data practitioners.

FILTER_GROUP, updates for ClickHouse/DuckDB/Materialize, legacy removal

Cube Core v0.35 — Updates to data modeling and data sources

During the last few months, we have shipped a lot of impactful updates to Cube Cloud: from those ones that are fit for the use cases of larger enterprises to those that are essential for any Cube Cloud user, including ones on the free tier. Let's do a recap.

## Demo deployments

Demo deployments provide a convenient way to explore how Cube Cloud works by using a pre-configured data model and a demo dataset: a few CSV files hosted on S3 and queried via DuckDB integration. If you'd like to learn data modeling by example or you're not yet ready to connect your production dataset, demo deployments come in handy.

**Demo deployments are available to all Cube Cloud users,** including users on the free tier. See how they work:

<div><div style={{position: 'relative', paddingTop: '56.25%'}}><iframe src="https://www.youtube.com/embed/XeaZPUQRC8M" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

[Read more](https://cube.dev/blog/introducing-demo-deployments-in-cube-cloud) in the announcement, [check the docs](https://cube.dev/docs/product/deployment/cloud/deployments#demo-deployments), and feel free create a demo deployment in your Cube Cloud account today.

## Playground 2.0

We know that Cube users spend a lot of time in Playground while building and debugging their data models. Recently, we have completely rebuilt Playground to provide data engineers with familiar BI-like experience, improve the data modeling experience, and refresh the UI.

**Playground 2.0 is available to all Cube Cloud users,** including users on the free tier. Later, we'll be releasing Playground 2.0 as part of Cube Core. See how it works:

<div><div style={{position: 'relative', paddingTop: '56.25%'}}><iframe src="https://www.youtube.com/embed/oxRa6btpml0" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

[Read more](https://cube.dev/blog/introducing-playground-2) in the announcement and give Playground 2.0 a try today, if for some reason you still haven't. We're adding new features like displaying the SQL API query or the timezone selector weekly:

![](https://ucarecdn.com/43f52ce7-1c6d-4583-abbd-9c145b88fd99/)

## Deployment warm-up

Cube Cloud can improve your querying performance by executing time-consuming tasks after a deployment is spun up but before it's exposed to API requests.

[Pre-aggregation warm-up](https://cube.dev/docs/product/deployment/cloud/warm-up#pre-aggregation-warm-up) has already been part of Cube Cloud for a long time. Now, we've added the data model warm-up: it compiles the data model before a deployment is exposed to requests from users, making sure that their experience isn't affected by the initial data model compilation time.

**Deployment warm-up is available to Cube Cloud users on [Starter and above](https://cube.dev/pricing) tiers.** Read more about deployment warm-up in the [documentation](https://cube.dev/docs/product/deployment/cloud/warm-up).

## Pre-aggregation index suggestion

Now, Cube Cloud highlights queries that use pre-aggregations but don't have optimal [indexes](https://cube.dev/docs/product/caching/using-pre-aggregations#using-indexes) in [Query History](https://cube.dev/docs/product/workspace/query-history) and [Performance Insights](#performance-insights). Please pay attention to these hints if you'd like to get a performance boost for your queries:

![Pre-aggregation index suggestion](https://ucarecdn.com/519670c7-afa7-4ae0-a0b7-b57915521586/)

**Pre-aggregation index suggestion is available to Cube Cloud users on [Starter and above](https://cube.dev/pricing) tiers.** Read more about cache types and pre-aggregation performance in the [documentation](https://cube.dev/docs/product/caching#cache-type).

## Performance Insights

We've added the all-new Performance page in Cube Cloud that displays a selection of time-series charts focusing on all aspects of your deployment's performance: request duration, caching, data model compilation, and pre-aggregations.

**Performance Insights are available to Cube Cloud users on [Premium and above](https://cube.dev/pricing) tiers.** [Read more](https://cube.dev/blog/introducing-performance-insights) in the announcement and [check the docs](https://cube.dev/docs/product/workspace/performance) for detailed guidance on using each chart from Performance Insights.

![Performance Insights](https://ucarecdn.com/62a8746d-f22e-4607-91ba-0a471cfc7b3d/)

## Multi-cluster deployments

Cube Cloud offers three deployment types, tailored for different scalability requirements: development instances, production clusters, and production multi-clusters. Multi-cluster deployments are specifically designed for the most demanding workloads, high-scalability, high-availability, and massive multitenancy.

**Recently, we've made multi-cluster deployments available to Cube Cloud users on [Premium and above](https://cube.dev/pricing) tiers.** With them, you can route a stream of multi-tenant API requests over a number of production clusters:

```python
from cube import config

@config('context_to_app_id')
def route_requests(ctx: dict) -> str:
  return f"CLUSTER_{ctx['securityContext']['tenant_id']}"
```

[Read more](https://cube.dev/docs/product/deployment/cloud/deployment-types#production-multi-cluster) about this type of deployment in the documentation.

## Power BI support

We're continuing to work on [Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync), and we have recently added the support for probably the most popular BI tool in the world. Now, you can connect Cube Cloud to Power BI and instantly start building data visualizations for your end users.

**Semantic Layer Sync with Power BI is available to Cube Cloud users on [Enterprise and above](https://cube.dev/pricing) tiers.** See how Cube Cloud works with Power BI in action and check the [documentation](https://cube.dev/docs/product/workspace/semantic-layer-sync/power-bi) to learn more:

<div><div style={{position: 'relative', paddingTop: '56.25%'}}><iframe src="https://www.youtube.com/embed/HKRlZXrTB4A" style={{position: 'absolute', top: 0, left: 0, width: '100%', height: '100%'}} frameBorder="0" allowFullScreen></iframe></div></div>

Also, in case you use Semantic Layer Sync with other BI tools, please note that we've added an option to [remove synced assets](https://cube.dev/docs/product/workspace/semantic-layer-sync#cleaning-up); it might be convenient if you ever sync from a development mode.

## Microsoft Fabric support

A few days ago, we have announced that Cube supports multiple products within the Microsoft data and analytics ecosystem: Azure (including Virtual Network, Virtual Machines, Blob Storage, Database, and Monitor), Entra ID, and, of course, Microsoft Fabric. If you use its Synapse Data Warehouse as a data store, you can now connect it to Cube Cloud.

![cube and microsoft](https://ucarecdn.com/274466a0-3bb5-4b06-9f00-4027ccbb45b9/-/preview/1000x691/)

[Read more](https://cube.dev/blog/cube-supports-microsoft-data-and-analytics) in the announcement, [check the docs](https://cube.dev/docs/product/configuration/data-sources/ms-fabric), and [watch on-demand](https://cube.dev/events/cube-cloud-and-microsoft-ecosystem-webinar) the webinar on Cube Cloud & Microsoft ecosystem.

## What’s next in Cube Cloud

While we're working very hard on the next batch of Cube Cloud updates, please try these ones and share your feedback. You can [get in touch](https://cube.dev/contact) directly or post in our [Slack community](https://slack.cube.dev) of more than 9,000 data practitioners; either way works!

A spring pack of essential and enterprise features

Cube Cloud update — Power BI, Playground 2.0, performance, and demo deployments

[Cube Core](https://github.com/cube-js/cube) releases v0.34.0 thru v0.34.34 bring the support for Python and a plethora of updates to data modeling, APIs, and SDKs. It also delivers a fix to a recently discovered and fixed security issue.

## Fixed: Denial of service attack on API instances

We've recently published a [security advisory](https://github.com/cube-js/cube/security/advisories/GHSA-9759-3276-g2pm) that discloses a vulnerability that allowed to make an API instance unavailable by submitting a specially crafted request. This issue was reported by [y0d3n](https://github.com/y0d3n) in our [community Slack](https://slack.cube.dev) and promptly patched in Cube Core v0.34.34.

__It's recommended that all users exposing Cube API instances to the public internet upgrade to the latest version to prevent service disruption.__

## Python for configuration and data modeling

In October, we've announced what looks like one of the most impactful updates to Cube in 2023. Finally, Cube has got support for Python that you can use for [configuration](https://cube.dev/blog/introducing-python-for-configuration) and [data modeling](https://cube.dev/blog/introducing-python-and-jinja-for-data-modeling). Needless to say, you can install and use Python packages, including the all-new `cube_dbt` package that enables the [dbt integration](https://cube.dev/blog/introducing-dbt-integration-with-cube) with Cube.

<video width="100%" controls><source src="https://ucarecdn.com/e7fb3a6d-9705-4a1b-ab87-c2af9ee93815/jinjapythondemo.mp4" type="video/mp4"/></video>

Please feel free to watch these recent webinar recordings to accelerate your start:
* [Dynamic data modeling in Cube with Python and Jinja](https://cube.dev/events/dynamic-data-modeling-workshop)
* [Trust your insights with Cube and dbt](https://cube.dev/events/trust-your-insights-with-cube-and-dbt)

## Top-level `meta` in cubes and views

Recently, we've fixed an [issue](https://github.com/cube-js/cube/issues/7100) that prevented `excludes` in views from working correctly in certain cases and an [issue](https://github.com/cube-js/cube/issues/7099) that prevented views from matching pre-aggregations in certain cases.

We're also thankful to [Michael Harris](https://github.com/mharrisb1) for contributing the support for top-level `meta` parameters in [cubes](https://cube.dev/docs/reference/data-model/cube#meta) and [views](https://cube.dev/docs/reference/data-model/view#meta), complementing the support for `meta` parameters in [dimensions](https://cube.dev/docs/reference/data-model/dimensions#meta) and [measures](https://cube.dev/docs/reference/data-model/measures#meta).

```yaml
views:
  - name: active_users
    meta:
      any: value
```

With these, now you can expose arbitrary metadata about your cubes and views to applications consuming Cube's REST API and its [`/meta` endpoint](https://cube.dev/docs/reference/rest-api#v1meta).

## Pass-through authentication in SQL API

We've extended the contract of the [`check_sql_auth` configuration option](https://cube.dev/docs/reference/configuration/config#check_sql_auth) so that it now accepts both a user name and a password, providing the flexibility of authentication checks and enabling the support for pass-through authentication in the SQL API.

<iframe width="560" height="420" src="https://www.youtube.com/embed/vGF7n4WWriA?si=WEwfaxxocSUtGTnH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

Please check this [recipe](https://cube.dev/docs/guides/recipes/auth/sql-api-ldap) for an example of using `check_sql_auth` to verify the credentials for the SQL API using a LDAP catalog, e.g., Google Workspace.

## `castNumerics` in front-end SDKs

We've provided an option to automatically convert all values of dimensions and measures with [numeric types](https://cube.dev/docs/reference/data-model/types-and-formats) to JavaScript Number type when using the JavaScript SDK.

By default, the REST API returns numeric values as strings because numbers more than [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) or less than `Number.MIN_SAFE_INTEGER` can't be represented as JavaScript Number. So, you have to flexibility to decide how to parse numeric values without the loss of precision. Now, you can opt-in for a potentially unsafe conversion to shave off a few lines of front-end code and let Cube convert numeric values for you.

Please see the [documentation](https://cube.dev/docs/reference/frontend/cubejs-client-core#loadmethodoptions) for details.

## Ivy support in Angular SDK

We've also updated the Angular SDK to support [Ivy](https://docs.angular.lat/guide/ivy), Angular's next-generation compilation and rendering pipeline. This enables the Angular SDK to be used with the most recent versions of Angular.

## Wrapping up

Thanks for tuning in as well as contributing to these updates. We're looking forward to bringing even more exciting updates to Cube Core in 2024.

**Please upgrade and try v0.34.34 today in Cube Core with our Docker distribution. It's also available on the latest and stable release channels in [Cube Cloud](https://cubecloud.dev/auth/signup).**

As always, please don't hesitate to [get in touch](https://cube.dev/contact) with us and share your feedback in our [Slack community](https://slack.cube.dev) of more than 9,000 data practitioners.

Security fix; Python for everything; updates to data modeling, APIs, and SDKs

Cube Core v0.34.34 — Python & powerful updates

Over the last few weeks, we've announced updates to a few [Cube Cloud](https://cube.dev/product/why-cube-cloud) features that we've launched [earlier in June 2023](https://cube.dev/blog/cube-cloud-update-semantic-layer-sync-data-graph-saml). *Semantic Layer Sync* has expanded its suite of supported BIs with [Tableau](https://www.tableau.com) and *Data Graph* now visualizes [views](https://cube.dev/docs/product/data-modeling/reference/view) alongside [cubes](https://cube.dev/docs/product/data-modeling/reference/cube) to help you get a human-friendly overview of the data model within your semantic layer.

Additionally, we've released *Budgets* to help Cube Cloud customers with [annual plans](https://cube.dev/pricing) stay on top of your Cube Cloud usage.

## Tableau support in Semantic Layer Sync

[Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync) makes using Cube with BI tools as easy as possible. With the [latest update](https://app.contentful.com/spaces/6v81z8q9p5kl/entries/qEUh67oCvTTSqPAgB1lVv), Cube Cloud automatically populates and updates data sources within Tableau so you can start building workbooks and dashboards right away.

See how that works:

<video width="100%" controls><source src="https://ucarecdn.com/16a984fa-b3a2-411d-872d-184bc476f46a/video.mp4" type="video/mp4"/></video>

[Check the docs](https://cube.dev/docs/semantic-layer-sync) for details and try it today with your Tableau instance. Semantic Layer Sync with Tableau is available in Cube Cloud on [Premium and above tiers](https://cube.dev/pricing).

## Views support in Data Graph

[Data Graph](https://cube.dev/blog/introducing-data-graph) provides a human-friendly, visual way to explore contents of the semantic layer. It represents the data model as an entity relationship diagram and uses the crow’s-foot notation to mark join relationships between cubes. Data Graph is the best way to familiarize for you and your team to take a bird’s-eye view of the data model.

![](https://ucarecdn.com/bfc3e04a-b690-40bc-a6f8-14a9175fb4fd/)

With the [latest update](https://cube.dev/blog/complementing-data-graph-with-views), Data Graph is capable of visualizing not only [cubes](https://cube.dev/docs/schema/reference/cube) and [join](https://cube.dev/docs/schema/fundamentals/joins) between them, but also [views](https://cube.dev/docs/schema/reference/view) that incapsulate cubes and joins and serve as the front, public-facing layer of your data model.

See Data Graph with views in action and [check the docs](https://cube.dev/docs/cloud/workspace/cube-ide#data-graph) for details:

<video width="100%" controls><source src="https://ucarecdn.com/f4b0f37c-4a46-49fb-865f-7da96a093544/datagraphviews.mp4" type="video/mp4"/></video>

A quick reminder: Data Graph is available to Cube Cloud users on all tiers, so please feel free to check it out.

## Budgets

[Budgets](https://cube.dev/docs/product/workspace/budgets) help you stay on top of your Cube Cloud usage.

With Budgets, you can set up monthly or daily budgets for the Cube Cloud usage and get email notifications when certain thresholds of these budgets are exceeded.

For example, if you have an annual contract worth $12,000, you can set up a monthly budget of $1,000 with thresholds of 70%, 100%, and 120%. Later, you'll get email notifications when any of these thresholds are hit. You can also set up a daily budget to protect against Black Friday-like usage spikes.

<video width="100%" controls><source src="https://ucarecdn.com/038cb7bf-babc-4592-9692-9c3a1ee05449/video.mp4" type="video/mp4"/></video>

Budgets are available to Cube Cloud users on Premium, Enterprise, and Enterprise Premier plans.

## What’s next in Cube Cloud

While we're working on the next batch of Cube Cloud features, let me remind you that we're always happy to hear your feedback. Please don't hesitate to [get in touch](https://cube.dev/contact) or reach out in our [Slack community](https://slack.cube.dev) of more than 9,000 data practitioners.

Updates to the newest features and tools to control your Cube Cloud usage

Cube Cloud update — Tableau in Semantic Layer Sync, Views in Data Graph, and Budgets

[Cube Core](https://github.com/cube-js/cube) releases v0.33.0 thru v0.33.43 bring a few important integrations: *DuckDB*, one of the most performant and definitely the most hyped OLAP database, and *LangChain*, the toolkit of choice for many developers of AI applications.

Additionally, we deprecate the `running_total` measure type in favor of a more generic and powerful `rolling_window` option.

## LangChain integration

Cube presents the integration with LangChain, the most popular toolset for building AI-based applications. It comes as the [document loader](https://python.langchain.com/docs/integrations/document_loaders/cube_semantic) that is intended to be used to populate a vector database with embeddings derived from the data model of the semantic layer. Later, this vector database can be queried to find best-matching entities of the semantic layer. This is useful to match free-form input, e.g., queries in a natural language, with the views and their members in the data model.

![diagram](https://ucarecdn.com/32e98c8b-a920-4620-a8d2-05d57618db8e/)

With this integration, builders of AI experiences can have a user-friendly, error-prone, and [hallucination-free](https://cube.dev/blog/semantic-layer-the-backbone-of-ai-powered-data-experiences) access to data. See the video for an example of experience one can build with this integration:

<video width="100%" controls><source src="https://ucarecdn.com/5500be7a-ab78-4de8-abc9-02df575ad3e0/video.mp4" type="video/mp4"/></video>

[Read more](https://cube.dev/blog/introducing-the-langchain-integration) in the announcement and [check the documentation](https://cube.dev/docs/product/configuration/visualization-tools/langchain) for details.

## DuckDB support

Cube expands the list of supported [query engines](https://cube.dev/docs/product/configuration/data-sources#query-engines) with [DuckDB](https://duckdb.org), an extremely performant in-process SQL OLAP database management system, and [MotherDuck](https://motherduck.com), a cloud service providing hybrid execution for DuckDB. With this integration, Cube can query data stored as Parquet, CSV, or JSON files at S3-compatible object storage servers, i.e., AWS S3, Google Cloud Storage, and Cloudflare R2.

![](https://ucarecdn.com/4fbb7247-379c-48a3-b298-0d87922e2531/)

You can easily go from local ad-hoc data exploration with DuckDB to building code-first data models and consistent metrics usable by everyone in an organization with Cube:

<video width="100%" controls><source src="https://ucarecdn.com/27491295-18eb-4d79-9b12-2db055a1b43f/video.mp4" type="video/mp4"/></video>

[Read more](https://cube.dev/blog/introducing-duckdb-and-motherduck-integrations) in the announcement and [check the documentation](https://cube.dev/docs/product/configuration/data-sources/duckdb) for details.

## `running_total` deprecation

As of v0.33.39, the use of the `running_total` measure type is [deprecated](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#running_total-measure-type) in favor of the [`rolling_window` option](https://cube.dev/docs/product/data-modeling/reference/measures#rolling_window) that is more flexible and general-purpose. The semantics of `running_total` can be achieved by using `rolling_window` with the `trailing` option set to `unbounded`.

See the code example:

```yml
cubes:
  - name: example
    # ...

    measures:
      # Deprecated
      - name: total_amount
        sql: amount
        type: running_total

      # Recommended
      - name: total_amount
        sql: amount
        type: sum
        rolling_window:
          trailing: unbounded
```

## What’s next in Cube Core

We're just a few weeks away from Cube Core v0.34 with the support for snake_case in the configuration as well as writing the configuration entirely in Python in a `cube.py` file. Moreover, the v0.34 release will bring dynamic data models in YAML with Jinja and Python.

You can try Cube Core v0.33.43 today in Cube Core with our Docker distribution. It's also available on the latest release channel in [Cube Cloud](https://cubecloud.dev/auth/signup).

As always, please don't hesitate to [get in touch](https://cube.dev/contact) with us and share your feedback in our [Slack community](https://slack.cube.dev) of more than 8,500 data practitioners.

Integrations with two most popular tools of 2023 so far

Cube Core v0.33.43 — DuckDB support, LangChain integration

During this week [launch week](https://cube.dev/blog/semantic-layer-across-the-data-verse), we've announced a number of [Cube Cloud](https://cube.dev/product/why-cube-cloud) that improve integration with other tools (*Semantic Layer Sync*) and simplify understanding complex data models (*Data Graph*). These features are available for Cube Cloud users on [all tiers](https://cube.dev/pricing), including free development instances.

Additionally, we'd like to present a couple of features for Cube Cloud users on the [Enterprise](https://cube.dev/pricing) tier: *Single Sign-On with SAML 2.0* and *Monitoring Integrations*. On top of that, we're making *Custom Domains* available on the [Premium](https://cube.dev/pricing) tier.

## Semantic Layer Sync

[Semantic Layer Sync](https://cube.dev/blog/introducing-semantic-layer-sync) makes using Cube with BI tools as easy as possible. It automatically synchronizes the data model in the semantic layer with thin data models in BI tools and enables instantaneous, zero-friction self-serve analytics.

![](https://ucarecdn.com/f598f41c-36ec-4ed9-960f-7c902a77ed74/)

Currently, you can set up synchronization with [Apache Superset](https://superset.apache.org) (self-hosted), [Preset](https://preset.io) (managed), and [Metabase](https://www.metabase.com) (self-hosted and managed). We’re also working with design partners on synchronization with Power BI, Tableau, and other BI tools.

See Semantic Layer Sync in action and [check the docs](https://cube.dev/docs/semantic-layer-sync) for details:

<video width="100%" controls><source src="https://ucarecdn.com/bb1ed393-c546-449d-a47a-ddcc20ad9f56/video.mp4" type="video/mp4"/></video>

We're releasing Semantic Layer Sync in preview, and it's available to Cube Cloud users on all tiers.

## Data Graph

[Data Graph](https://cube.dev/blog/introducing-data-graph) provides a human-friendly, visual way to explore contents of the semantic layer. It represents the data model as an entity relationship diagram and uses the crow’s-foot notation to mark join relationships between cubes. Data Graph is the best way to familiarize for you and your team to take a bird’s-eye view of the data model.

![](https://ucarecdn.com/30b7fa8c-fb9f-43fb-af1d-4ef98aae2829/)

Currently, Data Graph only shows [cubes](https://cube.dev/docs/schema/reference/cube) and [join](https://cube.dev/docs/schema/fundamentals/joins) relationships between them. We’re working on introducing support for visualizing [views](https://cube.dev/docs/schema/reference/view).

See Data Graph in action and [check the docs](https://cube.dev/docs/cloud/workspace/cube-ide#data-graph) for details:

<video width="100%" controls><source src="https://ucarecdn.com/2cc26fee-f94e-4328-bc46-297bfdd6e726/video.mp4" type="video/mp4"/></video>

We’re releasing Data Graph in preview, and it's available to Cube Cloud users on all tiers.

## Single Sign-On with SAML 2.0

Cube Cloud supports logging in with a login and password pair. It also supports logging in with a GitHub or Google account via the OAuth protocol. 

Now, Cube Cloud also supports the industry-proven SAML 2.0 protocol which enables [single sign-on (SSO)](https://cube.dev/docs/product/workspace/sso) via identity provides like Okta, Google Workspace, Azure AD, etc. 

![](https://ucarecdn.com/e3b3bce2-117e-4cbc-b516-c71b51b98888/)

SSO with SAML 2.0 is available to Cube Cloud users on the Enterprise tier.

## Monitoring Integrations

Now, Cube Cloud Supports exporting logs and performance metrics (e.g., CPU usage) of deployment infrastructure to [external monitoring tools](https://cube.dev/docs/monitoring/integrations). This way, you can leverage your existing monitoring stack and retain logs and metrics for the long term.

![](https://ucarecdn.com/17dbc263-2be4-4b7d-9f34-270cd66e878b/)

Under the hood, Cube Cloud uses [Vector](https://vector.dev), an open-source tool for collecting and delivering monitoring data that supports tons of destinations, including AWS S3, AWS Cloudwatch, Datadog, Grafana, and Prometheus.

![](https://ucarecdn.com/1f6dafd9-5122-4153-a733-adb31351bc9d/)

Monitoring Integrations are available to Cube Cloud users on the Enterprise tier.

## Custom Domains

By default, API endpoints of Cube Cloud deployments use auto-generated anonymized domain names, e.g., `electrical-maida.gcp-us-central1.cubecloudapp.dev`. However, you can also assign a [custom domain](https://cube.dev/docs/cloud/configuration/custom-domains) to your deployment and make it look pretty.

Prevously, Custom Domains were an Entrprise Premier feature. Now, it's available to a broader part of Cube Cloud users on the Premium tier and above.

## What’s next in Cube Cloud

While we're working on the next batch of Cube Cloud features, let me remind you that we're always happy to hear your feedback. Please don't hesitate to [get in touch](https://cube.dev/contact) or reach out in our [Slack community](https://slack.cube.dev) of more than 8,500 data practitioners.

Better integration with BI tools and human-friendly data model view

Cube Cloud update — Semantic Layer Sync, Data Graph, and SAML 2.0

In the recent update to [Cube Cloud](https://cube.dev/product/why-cube-cloud), we focused on the workspace and introduced or updated the tools for building data models and optimizing query performance: *Query History* and *SQL Runner*. On top of that, we added a few visual touches to make the time you spend in the Cube Cloud workspace more enjoyable.

All features in this update are available in Cube Cloud for users on [all tiers](https://cube.dev/pricing), including free development instances.

## SQL Runner

In Cube Cloud, we strive to provide a complete set of tools for building and operating semantic layers. We also know that authoring data models is a [thorough](https://cube.dev/blog/cube-core-v0-33-data-modeling-update) and iterative process: exploring the data, defining a metric, reviewing the result, and repeating until ready. Now, with [SQL Runner](https://cube.dev/docs/cloud/sql-runner), you can perform all these steps within the Cube Cloud workspace.

Available from the side menu, SQL Runner allows running arbitrary SQL queries against any of configured [data sources](https://cube.dev/docs/config/databases). You can explore the database schema and preview raw data in SQL Runner, author the data model in [Cube IDE](https://cube.dev/docs/cloud/workspace/cube-ide), and run queries in [Playground](https://cube.dev/docs/dev-tools/dev-playground) to validate the result. If needed, copy the generated SQL query from Playground to SQL Runner or find the query in Query History and click <Btn>Open in SQL Runner</Btn>. Of course, you’re still free to use your favorite Worksheets in Snowflake or SQL Workspace in BigQuery; however, SQL Runner might be a great alternative when working in the Cube Cloud workspace.

Here’s how SQL Runner works:

<video width="100%" controls><source src="https://ucarecdn.com/8cbdd639-e86b-4190-bbaa-37122c39bc01/video.mp4" type="video/mp4"/></video>

Sometimes, data source configuration is dynamic and depends on the incoming query and its [security context](https://cube.dev/docs/security/context); for instance, when [multitenancy](https://cube.dev/docs/config/multitenancy) is used. SQL Runner will recognize [pre-configured security contexts](https://cube.dev/docs/config#options-reference-scheduled-refresh-contexts) and also let you provide a custom one. Conveniently, Cube Store is available for querying as yet another data source, so you can inspect the contents of pre-aggregations.

## Query History

With Cube, you can build fast and responsive data experiences for end users. To support that, we’ve released the updated [Query History](https://cube.dev/docs/cloud/inspecting-queries) in Cube Cloud, available from the side menu and formerly known as *Queries*. Every query is analyzed and visualized in Query History with charts, performance metrics, and specialized representations like [flame graphs](https://www.datadoghq.com/knowledge-center/distributed-tracing/flame-graph/) to help you with the following tasks:
Getting a high-level understanding if your queries run fast enough.
Finding those ones that require optimization and fine-tuning.
Understanding the root cause and performing optimization.

Query History provides visibility both into incoming queries (e.g., from BI tools or data applications) and queries that Cube subsequently runs against data sources. You can watch queries live or review the last 72 hours of historical data; analyze the high-level picture or drill down into a particular query.

See Query History in action:

<video width="100%" controls>
  <source src="https://ucarecdn.com/ceba0bdc-298b-44e6-8491-2b0e39985465/video.mp4" type="video/mp4"/>
</video>

## Renaming tabs in Playground

If you’ve ever run queries in Cube Cloud, you probably noticed that Playground preserves open [query tabs](https://cube.dev/docs/dev-tools/dev-playground#query-tabs) so you can resume your work when needed. However, it’s not very evident that you can also double-click a query tab to give it a meaningful name instead of something like “Query 2.”

<video width="100%" controls><source src="https://ucarecdn.com/9e3d7651-4dca-4cd3-9fc9-541c3182effd/video.mp4" type="video/mp4"/></video>

This way, queries to your semantic layer will be even more semantic 😜

## Dark mode

This feature would make the Cube Cloud workspace more enjoyable for some of you—and make no difference for the rest. Now, you can enjoy the dark theme that can be [configured](https://cube.dev/docs/workspace/preferences) to match system settings or be always on.

<video width="100%" controls><source src="https://ucarecdn.com/b7ded0d1-fc4a-469c-8c38-59b3136b18f7/video.mp4" type="video/mp4"/></video>

However, we’re not leaving you in the dark 🙃 

## What’s next in Cube Cloud

We’re focused on making the Cube Cloud workspace even more powerful. So, please stay tuned for the upcoming updates that we’ll be publishing in the [Changelog](https://cube.dev/blog/category/changelog).

You can try Query History, SQL Runner, Playground, and the dark mode today. Sign up for [Cube Cloud](https://cubecloud.dev/auth/signup) for free and see them in action.

We’re always happy to hear your feedback. Please don't hesitate to [get in touch](https://cube.dev/contact) or reach out in our [Slack community](https://slack.cube.dev) of more than 8,000 data practitioners.

There’s one more thing. **We’re running a survey to better understand how you do data engineering and use Cube Cloud.** 5 minutes spent by you filling this survey will mean a world to us; please take a moment to [share with us what you think](https://forms.gle/b7iQHpocAXfpNfeR7).

Better workspace tools for optimizing query performance and building data models

Cube Cloud update — Query History, SQL Runner

In the recent v0.33 release of [Cube Core](https://github.com/cube-js/cube), we focused on improving the data modeling experience and conventions in Cube. We've been receiving consistent requests for additional conventions and a more pronounced *Cube way of data modeling*.

Based on feedback and observations of data modeling patterns across various use cases, we've made changes to Cube's data modeling. These revisions promote best practices to enhance consistency across different Cube projects, and establish a foundation for future conventions.

In addition, we're introducing a [Cube style guide](https://cube.dev/docs/style-guide) that we'll use across documentation, examples, learning materials, and customer engagements. This will help make our materials consistent and easier to maintain. We are making our style guide public and recommend that the Cube community follows it.

There are no breaking or backward-incompatible changes in the v0.33 release.

## Snake case naming convention

Six month ago, we [introduced YAML syntax](https://cube.dev/blog/introducing-cube-support-for-yaml-data-modeling) for data modeling in Cube; its adoption has been growing rapidly. YAML syntax provides a way to write concise data model files without too many quotes, backticks, and braces. 

The problem was, the [`camelCase`](https://en.wikipedia.org/wiki/Camel_case) name convention—which has been used in Cube since the very beginning—didn’t play nice with YAML. Considering that, we’ve decided to go with [`snake_case`](https://en.wikipedia.org/wiki/Snake_case) as a default naming convention across both JavaScript and YAML models.

We know that some of you may prefer to keep using `camelCase`, and that’s why we're going to support all definitions in both `snake_case` and `camelCase`. However, for the documentation, examples, and data model generation, we’ll use the `snake_case` moving forward.

```yaml
cubes:
  - name: line_items
    sql_table: public.line_items

    joins:
      - name: orders
        sql: "{CUBE}.order_id = {orders.id}"
        relationship: many_to_one

    measures:
      - name: count
        type: count

      - name: total_amount
        sql: price
        type: sum

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

      - name: created_date
        sql: created_at
        type: time
 ```

 ## Schema is now called data model

We've been using the terms "data model" and "schema" interchangeably for quite some time. Moving forward, we will use the term "data model" instead of "schema" to ensure clarity and consistency. The term "schema" could be confused with a database schema—hence the change in terminology.

With that change, we're also introducing a [conventional folder structure](https://cube.dev/docs/data-modeling/syntax) for Cube projects. Views are becoming a crucial component of Cube's data modeling, serving as data marts to expose slices of your data graph to BI tools and data applications via APIs. Therefore, they need to have their own designated folder within the project structure.

```tree
model
├── cubes
│   ├── base_orders.yml
│   └── base_customers.yml
└── views
    └── orders.yml
```

Cube will now automatically generate a `model` folder with `views` and `cubes` subfolders inside. If you're using a `schema` folder to keep your data model, it will continue to work.

## Conventional names for join relationships

In the v0.33 release, we are renaming [join relationships](https://cube.dev/docs/schema/reference/joins#parameters-relationship) to use widely adopted terminology: `one_to_many`, `many_to_one`, and `one_to_one`. As with all changes in this release, it's not a breaking change, and the previous names can still be used.

As a reminder, Cube always uses `LEFT JOIN`, and join relationships are used to avoid fanouts when generating SQL to query upstream data sources.

## Syntactic sugar for cube definitions

Often, cubes are backed by entire tables in upstream data sources and defined with fairly typical `SELECT *` one-liners. And so, we're introducing the [`sql_table` parameter](https://cube.dev/docs/schema/reference/cube#parameters-sql-table) to help define such cubes in a more concise way.

```yaml
cubes:
  - name: orders
    sql: SELECT * FROM my_schema.orders

# Now this can be written as:

cubes:
  - name: orders
    sql_table: schema.orders
```

## Update to views

Views are used to expose slices of your data graph and act as data marts. You control which measures and dimensions are exposed to BI or data apps and the direction of joins between exposed cubes.

![](https://ucarecdn.com/bfc3e04a-b690-40bc-a6f8-14a9175fb4fd/)

In the v0.33 release, we're introducing the `cubes` parameter in views to include exposed cubes in bulk. You can build your view by combining multiple joined cubes together and specifying the path by which they should be joined for that particular view. You can learn more about views [in the documentation](https://cube.dev/docs/schema/reference/view).

```yaml
views:
  - name: pages

    cubes:
      - join_path: web_pages
        includes: *
        excludes:
          - session_id

      - join_path: web_pages.web_sessions
        alias: sessions
        prefix: true
        includes:
          - start_date
          - duration
          - exit_path
          - is_first

      - join_path: web_pages.web_sessions.web_users
        alias: users
        prefix: true
        includes:
          - city
          - company
          - age
          - name: ltv
            alias: life_time_value
```

## Unified visibility control

We've unified visibility management across cubes, views, measures, dimensions, and segments with the [`public` parameter](https://cube.dev/docs/schema/reference/cube#parameters-public). The default value is `true`, meaning that all these elements are public, available through APIs, and visible to data consumers by default. However, you can hide some of them by setting this parameter to `false`.

```yaml
cubes:
  - name: orders
    sql_table: schema.orders
    public: false
```

You can also use `COMPILE_CONTEXT` for dynamic visibility if necessary.

```yaml
views:
  - name: arr
    description: Annual Recurring Revenue
    public: COMPILE_CONTEXT.security_context.has_finance_role

    includes:
      - customers.plan
      - revenue.arr
      - revenue.date
```

Private cubes and their members are now available in [Playground](https://cube.dev/docs/dev-tools/dev-playground). They will have a lock icon to indicate that they are private and not accessible via APIs.

![](https://ucarecdn.com/c666ea6b-627b-465b-987b-5863ff2534ee/)

As usual, the detailed changelog is [available on GitHub](https://github.com/cube-js/cube/blob/master/CHANGELOG.md).

## What’s next in Cube Core

You may have noticed that the Cube configuration file is still only in camelCase. In version 0.34, we will support snake_case in the configuration file, and we will also introduce initial Python support for configuration. Consequently, it will be possible to write the configuration entirely in Python in a `cube.py` file. Moreover, this release will bring dynamic data models in YAML with Jinja and Python.

You can try the new v0.33 release today in Cube Core with our Docker distribution. It's also available on the latest release channel in [Cube Cloud](https://cubecloud.dev/auth/signup).

As always, please don't hesitate to [get in touch](https://cube.dev/contact) with us and share your feedback in our [Slack community](https://slack.cube.dev) of more than 8,000 data practitioners.

Artyom Keydunov

Better data modeling experience for building maintainable semantic layers

Cube Core v0.33 — Data Modeling Update 

Cube Core v0.32 release brings the GraphQL API into general availability, adds a number of quality-of-life improvements to Cube SQL and adds significant performance boosts to Cube Store.

## Breaking changes and deprecations

This release, we have 2 deprecations and 5 breaking changes:

Please check the [deprecation document](https://github.com/cube-js/cube/blob/master/DEPRECATION.md) for more details.

### Breaking changes

- Cube Store is now the default cache and queue engine, replacing Redis. We've talked previously about how [Cube Store will be replacing Redis][cube-blog-redis-deprecation], and this release makes it official.

- Support for Node.js v12 and v15 has been dropped due to [them reaching
  end-of-life][nodejs-eol]. We strongly recommend upgrading to Node.js v16.

- Absolute imports for the following packages have been removed. We now provide a public API from the package directly:

  - `@cubejs-backend/query-orchestrator`
  - `@cubejs-backend/schema-compiler`
  - `@cubejs-backend/server-core`

### Deprecations

- Support for Node.js v14 has been marked as deprecated due to [it reaching
  end-of-life][nodejs-eol] in April 2023. We strongly recommend upgrading to
  Node.js v16.

- Using Cube with the Serverless Framework and the `@cubejs-backend/serverless` packages is now deprecated, we strongly recommend using [Docker-based deployments][cube-docs-deploy-docker] or [Cube Cloud][cube-docs-deploy-cloud] instead.

[nodejs-eol]: https://github.com/nodejs/Release#end-of-life-releases

## Pre-aggregations

Following on from the [Lambda pre-aggregation][cube-docs-caching-lambda] support introduced in our [last release][cube-docs-0-31], Cube now supports multiple rollups from the same cube in a `rollupLambda` definition.

## CLI

The Cube CLI now lets you validate your models on your local machine - simply
run `npx cubejs-cli validate` to check the models in your project for errors:

```bash{outputLines: 2-20}
npx cubejs-cli validate
❌ Cube Schema validation failed

Cube Error ---------------------------------------

Orders cube: "dimensions.id" does not match any of the allowed types
Possible reasons (one of):
  * (dimensions.id.case) is required
  * (dimensions.id.latitude) is required
  * (dimensions.id.sql) is required
LineItems cube: Cube Orders doesn't exist

Need some help? -------------------------------------

  Ask this question in Cube Slack: https://slack.cube.dev
  Post an issue: https://github.com/cube-js/cube/issues
```

## Drivers

We've enabled `readOnly: true` as the default for the
[Clickhouse][cube-docs-conf-clickhouse], [MSSQL][cube-docs-conf-mssql] and
[Oracle][cube-docs-conf-oracle] drivers which lets Cube build pre-aggregations
without creating temporary tables in those databases.

## GraphQL API

We're extremely excited to announce general availability of the GraphQL API in
Cube. With this, the GraphQL API now fully supports variables, a much-requested
(and much-needed) improvement:

```javascript
import { gql } from '@apollo/client';

const getOrdersQuery = gql`
  query CubeQuery($orderBy: OrdersOrderByInput) {
    cube {
      orders(orderBy: $orderBy) {
        count
        status
      }
    }
  }
`;

const variables = {
  orderBy: {
    count: 'desc',
  },
};

client
  .query({
    query: getOrdersQuery,
    variables,
  })
  .then((result) => console.log(result));
```

## SQL API

Cube SQL continues to see quality-of-life improvements as well as enhanced
support for even more SQL functions as selections and projections. Some examples
of what we've improved this release include:

- Support for `CASE` statements in Cube projections
- Support for expressions like `NOT(LOWER() IN)`
- Allow using `CAST` in `HAVING` clauses
- Support for `LEFT` and `RIGHT` functions in projections
- Support for `NULLIF` in projections
- Allow using `TO_DATE()` in `DATE_DIFF()` expressions
- Allow using `DATE_TRUNC()` in `WHERE` clauses

We hope that you find these helpful in your work with Cube SQL; please let us know if you have any feedback or suggestions by [opening
issues][cube-gh-issue-new] on our GitHub repository.

[cube-blog-redis-deprecation]:
  https://cube.dev/blog/replacing-redis-with-cube-store
[cube-docs-0-31]: https://cube.dev/blog/cube-core-v0-31-yaml-views-and-lambda
[cube-docs-caching-lambda]: https://cube.dev/docs/product/caching/lambda-pre-aggregations
[cube-docs-conf-clickhouse]: /docs/product/configuration/data-sources/clickhouse
[cube-docs-conf-mssql]: /docs/product/configuration/data-sources/ms-sql
[cube-docs-conf-oracle]: /docs/product/configuration/data-sources/oracle
[cube-docs-deploy-cloud]: /docs/product/deployment/cloud
[cube-docs-deploy-docker]: /docs/product/deployment/core
[cube-gh-issue-new]: https://github.com/cube-js/cube/issues/new/choose


Hassan Khan

Cube Core v0.32 — Bye, Redis!

Cube Core v0.31 release brings a number of major new features such as:

- Support for YAML syntax for data modeling
- Support for ksqlDB as the data source
- Lambda pre-aggregations
- Views

## Breaking changes and deprecations

Two breaking changes and one deprecation in this release:

- **BREAKING CHANGE**: Foreign cube references must now reference a cube member
- **BREAKING CHANGE**: The `shown` property now hides cubes/views from the
  `/meta` endpoint when set to `false`
- **DEPRECATION**: The `driverFactory` property should return a `DriverConfig`
  object or a Promise that returns a `DriverConfig` object

Please check the [Deprecation document](https://github.com/cube-js/cube/blob/master/DEPRECATION.md) for more details on the above.

## Multiple Data Sources

Cube has had support for multiple data sources for quite some time now, but
we’ve made it even easier to configure them now with environment variables.
[Read the documentation](https://cube.dev/docs/config/multiple-data-sources) to
see how it works.

## Modeling in YAML

We’ve often heard users they want the ability to author data models in languages
other than JavaScript - specifically YAML and Python. Today, we’re excited to
release a public preview for YAML data modeling in Cube. Check out the
[introductory blog post](https://cube.dev/blog/introducing-cube-support-for-yaml-data-modeling),
or dive straight into
[the documentation](https://cube.dev/docs/schema/getting-started/yaml).

## Views

Designed as a layer over cubes, views act as a façade of your whole data model.
They are a great tool for to defining metrics, managing governance and data
access, and controlling ambiguous join paths. Learn more about them in the
[introductory blog post](https://cube.dev/blog/introducing-views), read more
about them [in the documentation](https://cube.dev/docs/schema/reference/view)
or watch our in-depth
[webinar on the topic](https://cube.dev/events/using-cube-views-for-metrics-management).

## Lambda pre-aggregations

Lambda pre-aggregations allow combining batched/processed data with fresh data
at query time, this is super useful for real-time data applications. You can
even take it a step further and combine batched data from a data warehouse with
streaming data from ksqlDB; find more information
[in the documentation](https://cube.dev/docs/caching/pre-aggregations/lambda-pre-aggregations).

## Drivers

We’re really excited to present two new drivers,
[Firebolt](https://cube.dev/docs/config/databases/firebolt) and Trino. And to
top it off, we’ve also added a brand-new driver for
[ksqlDB](https://cube.dev/docs/config/databases/ksqldb).

## SQL API

The Cube SQL API now speaks the Postgres protocol instead of MySQL; the Postgres
protocol is better supported and allows us to extend supports to dozens of
downstream tools. We’ve also made a number of improvements relating syntax and
operator support, and we’ve documented
[any difference in behaviour](https://cube.dev/docs/backend/sql/reference/functions-operators)
from regular SQL.

## Downstream tools

We’ve been busy since the last release adding support for downstream tools. Cube now connects to:

- [Appsmith](https://cube.dev/docs/config/downstream/appsmith)
- [Tableau](https://cube.dev/docs/config/downstream/tableau/)
- [Microsoft PowerBI](https://cube.dev/docs/config/downstream/powerbi/)
- Thoughtspot
- Amazon QuickSight

Let us know if there’s a tool that you’d like supported by opening an issue on GitHub.

Cube Core v0.31 — YAML, Views, and Lambda

Cube Core v0.30 release brings major new features, such as:

- Support for using [dbt](https://www.getdbt.com/) metrics with Cube. Check out
  [this blog post](https://cube.dev/blog/dbt-metrics-meet-cube) to learn more.
- Support for [Databricks](https://databricks.com/), including the export bucket
  feature for enhanced pre-aggregation support.
- Support for [Materialize](https://materialize.com/) databases. 
- Support for [QuestDB](https://questdb.io/) databases. To learn more about how
  to get started with QuestDB and Cube, check out
  [our recent blog post](https://cube.dev/blog/time-series-data-analytics-with-questdb)
  on the topic.

Cube Store has also seen a massive number of improvements in both its stability
and performance, and the Cube SQL API has
[been vastly improved](https://cube.dev/docs/product/apis-integrations/sql-api)
since its' launch in [v0.29](https://forum.cube.dev/t/v0-29-release-notes/380).
We've improved the existing support for
[Apache Superset](https://superset.apache.org/) and added support for
[Jupyter](https://jupyter.org/), [Streamlit](https://streamlit.io/) and
[Hex](https://hex.tech/) notebooks. We've also done a lot of work in preparation
for extending support to other visualization tools, so stay tuned.

The Developer Playground has also seen a number of quality-of-life improvements,
and we hope you’ll find them useful.

## Breaking changes and deprecations

This release we have two breaking changes that should only affect older users.
We’re deprecating the `CUBEJS_EXTERNAL_DEFAULT` and
`CUBEJS_SCHEDULED_REFRESH_DEFAULT` environment variables. These were introduced
to smooth the migration to Cube Store; we doubt most users will be affected but
please ensure nothing depends on the above.

## Cube Store

- **Added:** Support Docker images for ARM64 platform
  ([#3841](https://github.com/cube-js/cube/pull/3841))
- **Added:** Split batching upload of pre-aggregations into multiple files to
  enhance performance and avoid load balancer
- **Added:** Support `quarter` granularity in `date_trunc`
  ([#4011](https://github.com/cube-js/cube/pull/4011))
- **Added:** Decimal partition pruning
  ([#4089](https://github.com/cube-js/cube/pull/4089))
- **Added:** Unwinds select worker panics to provide descriptive error messages
  ([#4097](https://github.com/cube-js/cube/pull/4097))
- **Added:** Introduce `CUBESTORE_EVENT_LOOP_WORKER_THREADS` to allow setting
  Tokio worker threads and processes explicitly
- **Added:** Repartition single chunks instead of partition as a whole to speed
  up ingestion of big tables
  ([#4125](https://github.com/cube-js/cube/pull/4125))
- **Added:** Add `CUBEJS_GH_API_TOKEN` environment variable to download script
  ([#4282](https://github.com/cube-js/cube/pull/4282))
- **Added:** Add `EXPLAIN` implementation
  ([#4303](https://github.com/cube-js/cube/pull/4303))
- **Added:** `IN` operator support for decimal type
  ([#4306](https://github.com/cube-js/cube/pull/4306))
- **Added:** Support space-separated binary strings for HyperLogLog fields in
  CSV, resolves issue with `countDistinctApprox` in AWS Athena
  ([#4383](https://github.com/cube-js/cube/pull/4383))
- **Fixed:** Reduce excessive startup memory usage
- **Fixed:** Re-parent chunks on compaction instead of repartitioning
- **Fixed:** Silence errors for not uploaded chunks scheduled for removal
- **Fixed:** Respect pending chunks for compaction
- **Fixed:** Do not fail scheduler loop on lagged broadcast receive
- **Fixed:** Provide better messages for CSV parsing error
- **Fixed:** Decimals without integral parts are now respecting sign
- **Fixed:** Schema type mismatch when in memory chunks are queried
  ([#4024](https://github.com/cube-js/cube/pull/4024))
- **Fixed:** Ensure file size matches during downloads to localize any remote
  filesystem consistency issues
  ([#4054](https://github.com/cube-js/cube/pull/4054))
- **Fixed:** Deactivate tables on data corruption to allow refresh worker to
  reconcile failing partitions
  ([#4092](https://github.com/cube-js/cube/pull/4092))
- **Fixed:** Add list file size validation after file upload to check upload
  consistency ([#4093](https://github.com/cube-js/cube/pull/4093))
- **Fixed:** Postpone deletion of partitions and chunks after metastore log
  commits to avoid missing files on sudden metastore loss
  ([#4094](https://github.com/cube-js/cube/pull/4094))
- **Fixed:** Do not spawn select workers for router nodes
- **Fixed:** Jobs are fetched only once every 5 seconds if there's a queue
- **Fixed:** Do not warmup chunks on table creation to avoid stuck on warmup of
  unpartitioned chunks situation
- **Fixed:** Leading decimal zeros are truncated during formatting
- **Fixed:** Empty tables in Cube Store if index is being used
  ([#4170](https://github.com/cube-js/cube/pull/4170))
- **Fixed:** Add compaction and chunk writing guards to cleanup uploads folder
  on any failures to minimize storage bloating
- **Fixed:** Filters are now included in index choosing
- **Fixed:** Empty `CUBESTORE_S3_SUB_PATH` leads to can't list file error
  ([#4324](https://github.com/cube-js/cube/pull/4324))
- **Fixed:** Inactive partition compaction: replace error with warn
  ([#4337](https://github.com/cube-js/cube/pull/4337))

## Cube SQL

- **Added:** Support for `SUBSTRING()`
- **Added:** Support `UCASE()`
- **Added:** Support `LOCATE()`
- **Added:** Support `DATE()` , `DATE_ADD()` , `NOW()` functions & `INTERVAL` s
- **Added:** Introduce `information_schema` for MySQL compatibility
- **Added:** Improved selection finder for `ORDER BY`
- **Added:** Ignore `KILL` statement without error
- **Added:** Improved error messages
  ([#3829](https://github.com/cube-js/cube/pull/3829))
- **Added:** Support for ARM64 Linux
  ([#3865](https://github.com/cube-js/cube/pull/3865))
- **Added:** Support `USE 'db'`
- **Added:** Support `SHOW COLUMNS`
  ([#3995](https://github.com/cube-js/cube/pull/3995))
- **Added:** Support `SHOW TABLES`
  ([#4001](https://github.com/cube-js/cube/pull/4001))
- **Added:** Support `COUNT(1)`
  ([#4004](https://github.com/cube-js/cube/pull/4004))
- **Added:** Support prepared statements
  ([#4005](https://github.com/cube-js/cube/pull/4005))
- **Added:** Support binary expression for measures
  ([#4009](https://github.com/cube-js/cube/pull/4009))
- **Added:** Support `SHOW COLLATION`
  ([#4025](https://github.com/cube-js/cube/pull/4025))
- **Added:** Query execution now uses DataFusion-based Query Engine
- **Added:** Support `SHOW processlist`
- **Added:** Split variables for session and server
  ([#4255](https://github.com/cube-js/cube/pull/4255))
- **Added:** Support `pg_catalog.*` tables
- **Added:** Support `SET` variables
  ([#4266](https://github.com/cube-js/cube/pull/4266))
- Added: Improved error messages
  ([#4515](https://github.com/cube-js/cube/pull/4515))
- **Fixed:** `LIKE '%(%)%'` comparators
- **Fixed:** Support for `IF()`
- **Fixed:** `SUBSTRING()` with negative count now returns an empty string
- **Fixed:** Return Cube errors to the SQL client
- **Fixed:** Fixed an alias binding problem with escapes
- **Fixed:** Ignore case-sensitive search for usage of identifiers
- **Fixed:** Unique filtering for measures/dimensions/segments in Request
- **Fixed:** Allow using a measure as an argument in `COUNT()`
  ([#4063](https://github.com/cube-js/cube/pull/4063))
- **Fixed:** Add `numeric_scale` field for `information_schema.columns`
- **Fixed:** Table columns should take precedence over projection to mimic
  database behavior
- **Fixed:** Allow quoted variables with `SHOW <variable>` syntax
  ([#4313](https://github.com/cube-js/cube/pull/4313))
- **Fixed:** Correct MySQL types in response headers
  ([#4362](https://github.com/cube-js/cube/pull/4362))
- **Fixed:** Support `boolean` column type

## AWS Athena

- **Added:** Batching and export support
  ([#4039](https://github.com/cube-js/cube/pull/4039))
- **Fixed:** Fixes export bucket location and column order
  ([#4183](https://github.com/cube-js/cube/pull/4183))
- **Fixed:** Support plain bucket (instead of a path) for
  `CUBEJS_DB_EXPORT_BUCKET`
  ([#4390](https://github.com/cube-js/cube/pull/4390))

## BigQuery

- **Fixed:** Cancel queries on polling timeout so they aren't dangling around
  indefinitely

## Databricks

- **Added:** Export bucket support on S3/Azure
  ([#4430](https://github.com/cube-js/cube/pull/4430))

## JDBC

- **Fixed:** Handle Maven error for empty Java dependencies
  ([#4307](https://github.com/cube-js/cube/pull/4307))

## Materialize

- **Added:** New driver for Materialize
  ([#4320](https://github.com/cube-js/cube/pull/4320))

## MS SQL

- **Fixed:** Add `uniqueidentifier` type support
  ([#4386](https://github.com/cube-js/cube/pull/4386))

## Postgres

- **Added:** Enums now supported in pre-aggregations
  ([#3957](https://github.com/cube-js/cube/pull/3957))

## QuestDB

- **Added:** New driver for QuestDB
  ([#4096](https://github.com/cube-js/cube/pull/4096))

## Snowflake

- **Added:** New environment variable `CUBEJS_DB_SNOWFLAKE_PRIVATE_KEY` for
  setting private keys
- **Fixed:** Fixed
  `OperationFailedError: SQL compilation error: invalid value [?] for parameter 'STATEMENT_TIMEOUT_IN_SECONDS'`

## Playground

- **Added:** A message now displays when using non-additive measures
  ([#4236](https://github.com/cube-js/cube/pull/4236))
- **Added:** A message now displays when using count distinct
  ([#4309](https://github.com/cube-js/cube/pull/4309))
- **Added:** Display error stack traces
  ([#4438](https://github.com/cube-js/cube/pull/4438))
- **Fixed:** Filter groups now correctly display the full field name
  ([#3816](https://github.com/cube-js/cube/pull/3816))
- **Fixed:** Adjust chart to fill the window
  ([#4042](https://github.com/cube-js/cube/pull/4042))
- **Fixed:** Use security context in GraphQL sandbox
- **Fixed:** Fixed an issue rollup designer undefined key
- **Fixed:** Tab close button styles
  ([#4047](https://github.com/cube-js/cube/pull/4047))
- **Fixed:** Fixed an issue that caused parameters to shift around when removing
  filters

## Server

- **Added:** New environment variable
  `CUBEJS_ALLOW_UNGROUPED_WITHOUT_PRIMARY_KEY`
  ([#2941](https://github.com/cube-js/cube/pull/2941))
- **Added:** Allow configuring `allowNodeRequire` for `DataSchemaCompiler`
  ([#4235](https://github.com/cube-js/cube/pull/4235))
- **Fixed:** Timestamp for `quarter` range in time series has incorrect ending
  period of `23:59:99` ([#4162](https://github.com/cube-js/cube/pull/4162))
- **Fixed:** `TypeError` when requesting `/cubejs-api/v1/run-scheduled-refresh`
  without auth params
- **Fixed:** Validate `contextToAppId()` is in place when `COMPILE_CONTEXT` is
  used
- **Fixed:** Improved defaults in `RefreshScheduler`

## API gateway

- **Added:** Compact JSON array-based response data format support
  ([#4046](https://github.com/cube-js/cube/pull/4046))
- **Added:** A new property `total` is available in the JSON query. If `true` ,
  the query also returns the total number of rows for that query
  ([#4134](https://github.com/cube-js/cube/pull/4134))
- **Fixed:** Fix a type issue where queries did not properly support logical
  `and` / `or` operators ([#4016](https://github.com/cube-js/cube/pull/4016))
- **Fixed:** Skip GraphQL types generation for empty cubes
- **Fixed:** GraphQL cannot read property `findIndex` of `undefined`
- **Fixed:** Allow HTTP POST requests for `/sql` endpoint
  ([#4180](https://github.com/cube-js/cube/pull/4180))

## Query orchestrator

- **Added:** New environment variable to control database timeouts:
  `CUBEJS_DB_QUERY_TIMEOUT`
  ([#3864](https://github.com/cube-js/cube/pull/3864))
- **Fixed:** Refresh process for `useOriginalSqlPreAggregations`
  ([#3826](https://github.com/cube-js/cube/pull/3826))
- **Fixed:** Table cache incorrectly invalidated in multitenant configurations
  ([#3828](https://github.com/cube-js/cube/pull/3828))
- **Fixed:** Cannot read property `last_updated_at` of `undefined`
  ([#3980](https://github.com/cube-js/cube/pull/3980))
- **Fixed:** Improve error message on missing partitions
- **Fixed:** Remove orphaned tables on error while pre-aggregation creation
  ([#3996](https://github.com/cube-js/cube/pull/3996))
- **Fixed:** An out-of-memory error when an empty table was used to build
  partitioned pre-aggregations
  ([#4021](https://github.com/cube-js/cube/pull/4021))

## Schema compiler

- **Added:** Allow filtering with `or` / `and` in `FILTER_PARAMS`
  ([#4253](https://github.com/cube-js/cube/pull/4253))
- **Added:** Support for compound primary keys
  ([#4370](https://github.com/cube-js/cube/pull/4370))
- **Fixed:** Handle `null` values in security context
  ([#3868](https://github.com/cube-js/cube/pull/3868))
- **Fixed:** An error when using `subQuery` for a `rollingWindow` measure
- **Fixed:** Do not instantiate `SqlParser` if `rewriteQueries` is `false` to
  save cache memory
- **Fixed:** `refreshKey` is evaluated ten times more frequently if `sql` and
  `every` are simultaneously defined
  ([#3873](https://github.com/cube-js/cube/pull/3873))
- **Fixed:** Use prototype name matching instead of classes to allow exact
  version mismatches for `AbstractExtension`
- **Fixed:** Use a cube's alias when generating join aliases
  ([#4010](https://github.com/cube-js/cube/pull/4010))
- **Fixed:** Add strictness to booleans
  ([#4157](https://github.com/cube-js/cube/pull/4157))

## Client libraries

### Angular

- **Fixed:** `cubejs.watch()` is now producing errors
  ([#3974](https://github.com/cube-js/cube/pull/3974))

### Core

- **Added:** Support for compact response data format
  ([#4046](https://github.com/cube-js/cube/pull/4046))
- **Added:** Accept immutable queries
  ([#4366](https://github.com/cube-js/cube/pull/4366))
- **Added:** Add HTTP status code to `RequestError`
  ([#4412](https://github.com/cube-js/cube/pull/4412))
- **Fixed:** Add `meta` field to TypeScript `TCubeMember` type
  ([#3815](https://github.com/cube-js/cube/pull/3815))
- **Fixed:** Allow any filter types in `and` / `or`
  ([#4343](https://github.com/cube-js/cube/pull/4343))
- **Fixed:** HTTP poll not working if Cube API stops and recovers
  ([#3506](https://github.com/cube-js/cube/pull/3506))

### Vue

- **Added:** Boolean filters support
  ([#4314](https://github.com/cube-js/cube/pull/4314))
- **Fixed:** Fix error when deleting a member in `QueryBuilder`
  ([#3806](https://github.com/cube-js/cube/pull/3806))

## Documentation & examples

- **Fixed:** Frontend Integration API Reference generation
- **Fixed:** CodeSandbox examples in documentation
- **Fixed:** Kubernetes examples

Cube Core v0.30 — dbt, Databricks, Materialize

Cube Core v0.29 release includes tons of goodies for developers in the form of Playground, not to mention incredible improvements to Cube Store and reliability
improvements to our database drivers.

What we're really excited to announce is two new capabilities:

- [SQL API](https://cube.dev/docs/backend/sql)
- [GraphQL API](https://cube.dev/docs/backend/graphql)

## Breaking changes and deprecations

- Remove Node.js 10.x support
- Remove Node.js 15.x support
- Deprecate Node.js 12.x
- The Docker images for Cube now use Node.js 14.x
- The Angular frontend integration now only supports Angular 12.x

## Server

- Cube Store now correctly shuts down when the Cube server exits
- Fixes an issue where a pre-aggregation may not be found after it was created
  by a Refresh Worker
- Add ability to pass through `generic-pool` options for Redis

### Cube SQL API

- Query your cubes with our new MySQL-compatible SQL API. This means you can now
  connect Cube to third-party BI tools. It launches with support for Superset;
  we're adding support for Metabase, Tableau, PowerBI and even Microsoft Excel.

### Query format

- You can now specify date ranges such as `tomorrow` and `next 2 month` for a
  `dateRange`.

### Schema

- `refreshKey` now supports an `every` property
- A new `quarter` granularity is now available
- Support multi-value filtering on same column through `FILTER_PARAMS`
- Improve error messages on schema validation failure

### Drivers

- AWS Athena: The driver now uses AWS SDK v3, this reduces bundle sizes
  significantly for deployments using the Serverless Framework.
- AWS Athena: Use `getWorkGroup()` instead of `SELECT 1` to test connection
  health.
- AWS Athena: Allow configuring the workgroup via `CUBEJS_AWS_ATHENA_WORKGROUP`.
- BigQuery: Datasets that cannot be accessed with the current permissions are
  ignored.
- BigQuery: Improved type detection in read-only mode
- Oracle: You can now specify the port number with `CUBEJS_DB_PORT`.
- Oracle: Move `oracledb` to `optionalDependencies` to unblock developers using
  ARM64.
- MySQL: Handle data of type `utf8mb4_bin` as `string`.
- Postgres: Add support for pre-aggregating `countDistinctApprox` measures
- Postgres: Improved type detection in read-only mode
- PrestoDB: Support connections over SSL
- Snowflake: Fix error `ReferenceError: host is not defined`
- Snowflake: Do not trigger cluster start on test connection

### Pre-aggregations

- All pre-aggregations now have a default `refreshKey` of 1 hour.
- Measures with a rolling window, including `countDistinctApprox` can now be
  pre-aggregated

## Frontend integrations

### Core

- Data blending queries can now be made without a `dateRange`
- Time dimensions are now included under `dimensions` for cube metadata
- Prevent redundant authentication checks
- Preserve order of elements when calling `ResultSet.tableColumns()`
- Measures that return nullish (`undefined` or `null`) values are now converted
  to `0`

### Angular

- Angular 12 support
- Async client generation support in Angular
  ([Find an example here](https://github.com/cube-js/cube/tree/master/examples/dynamic-angular-dashboard))
- `FilterMember.replace()` no longer updates all filters with replacement

### React

- Introduce new `useCubeMeta()` hook

### Vue

- Correctly handle `dryRun` errors on component mount
- New `wrapWithQueryRenderer` prop to allow using the `QueryBuilder` component
  without the `QueryRenderer`

## Cube Store

Cube Store has seen a huge number of stability fixes and quality improvements;
far too many to mention here, but here's a summary:

- Improved Cube Store installation process
- Improved error handling for incorrect configuration
- Added support for `date_add` and `date_sub` SQL functions
- Added equality comparison between `bool` and `int` types
- We now build non-avx versions of Cube Store so you can use them on ARM64
  platforms
- `ILIKE` is now supported
- Added `CUBESTORE_META_BIND_ADDR` and `CUBESTORE_WORKER_BIND_ADDR` to allow for
  IPv6 binds
- Fix issue when using decimal types
- MinIO is now supported as a storage backend

## Playground

- Rollup designer
- Now supports the new `quarter` granularity
- Support drilldowns in charts made with React ChartJS
- Boolean values are now correctly displayed as `true` or `false`

## Documentation

- A deployment guide for Kubernetes
- A ton of [new recipes](https://cube.dev/docs/recipes) to help you level up
  quickly

Cube Core v0.29 — SQL and GraphQL APIs

Cube Core v0.28 release includes tons of goodies for developers in the form of Playground, not to mention incredible improvements to Cube Store and a
raft of reliability improvements to our database drivers.

## Breaking changes and deprecations

Only one deprecation this release:

- Redis configuration variables are all now prefixed with `CUBEJS_`. This is
  part of an ongoing process to cleanly separate and mark environment variables used by Cube.

> Be sure to check the
> [Deprecation document](https://github.com/cube-js/cube/blob/master/DEPRECATION.md)
> for more details on the above.

## Server

- The `queryTransformer` property in the `cube.js` configuration file is
  replaced by `queryRewrite`

- A new environment variable `CUBEJS_REFRESH_WORKER` is introduced, which
  replaces `CUBEJS_SCHEDULED_REFRESH_TIMER`

- A new environment variable `CUBEJS_ROLLUP_ONLY` is introduced, which ensures
  all requests only target pre-aggregations of type `rollup` and that your
  database is not invoked

- Partition evaluation responsibilities have been moved from the schema compiler
  to the query orchestrator. This allows all time queries for partitioned
  rollups and fixes querying issues beyond a rollup's build range. This is also
  the first step towards rolling window rollups being supported 🎉

- Run timer refresh keys in Cube Store instead of your source database. This
  means the source database is now free of those pesky refresh SQL queries
  spamming the query log 😎
- The database connection wizard works in both Node and Docker-based installs

### Schema

- The default type for pre-aggregations is now
  [`rollup`](https://cube.dev/docs/pre-aggregations#rollup). This _can still_ be
  overridden by explicitly specifying the `type` property, but we strongly
  recommend using rollups instead of `originalSql` for most workloads.

- Pre-aggregation definitions now set the following as defaults:
  `external: true` and `scheduledRefresh: true`

- `refreshRangeStart`/`refreshRangeEnd` to be replaced by
  `buildRangeStart`/`buildRangeEnd`

- You can write
  `measureReferences`/`dimensionReferences`/`timeDimensionReference` as
  `measures`/`dimensions`/`timeDimension`.

### Drivers

We're working our way through the supported drivers so that Cube.js doesn't talk
to your database any more than is necessary. To this end, the following drivers
now default to
[`readOnly: true`](https://cube.dev/docs/caching/using-pre-aggregations#read-only-data-source)
automatically:

- ElasticSearch
- MySQL
- Postgres

### Pre-aggregations

We've been cranking out improvements to pre-aggregations too, here are the
highlights:

- Cube Store is now the **default** storage for external pre-aggregations in new
  projects
- [Batching](https://cube.dev/docs/caching/using-pre-aggregations#optimizing-pre-aggregation-build-times-batching)
  is now also supported for
  - BigQuery
  - Clickhouse
  - MongoDB
  - MySQL (now in `readOnly: true` as well)
- [Export bucket](https://cube.dev/docs/caching/using-pre-aggregations#optimizing-pre-aggregation-build-times-export-bucket)
  is now also supported for
  - Redshift (on S3)
  - Snowflake (now on GCS as well as S3)

## Cube Store

- [Snowflake's HyperLogLog format](https://docs.snowflake.com/en/user-guide/querying-approximate-cardinality.html)
  is now supported, which enables using
  [`countDistinctApprox`-type measures](https://cube.dev/docs/types-and-formats#measures-types-count-distinct-approx)
  in pre-aggregations
- Improved CSV ingestion time through distributed processing
- Now supports
  - `DATE_ADD`
  - `CONCAT`
  - `HAVING`
  - `COALESCE`
  - Decimal/float values

## Playground

We have so many improvements here that we're really excited to share with you
all:

- You can now search for dimensions and measures. The members are also grouped
  by cube, which makes it easy-as-pie to pick out the ones you want.

- A long-requested item on our agenda has been Vue 3 support, which is now
  available.
- You can now have multiple tabs with their own queries in the Developer
  Playground - super useful when you want to keep queries at-hand without
  needing a separate instance of the Playground open

- The brand new Rollup Designer makes creating pre-aggregations an absolute
  treat.


Cube Core v0.28 — Batching and export buckets

Cube Core v0.27 release is feature-rich, backwards-compatible, and non-breaking; it includes tons of improvements to security, authentication, caching, client libraries, and Playground as well as some bug fixes.

## Breaking changes and deprecations

None. Nada. Nothing. Natch 🙅 You can just update the dependency versions in
your project (either via Docker image or Node package version) and everything
will just work. That said, there is
[_one_ deprecation this release relating to Redis configuration options](https://github.com/cube-js/cube/blob/master/DEPRECATION.md#prefix-redis-environment-variables-with-cubejs_);
check the Deprecation document for more details.

## Authentication & authorization

We've added support for JWK-based identity providers, allowing you to use
[Auth0](https://auth0.com/) and [AWS Cognito](https://aws.amazon.com/cognito/)
with a tiny bit of configuration.

We've also added two new pages to our documentation detailing the above, and a
brand new in-depth guide to setting up
[Multi-Tenant Analytics with Auth0 and Cube.js](https://multi-tenant-analytics.cube.dev/).
If you'd like to see it in action, please watch the recording of our
[March Community Call](https://youtu.be/SycFPE4LRHo?t=2192).

## Cube Store is generally available

Cube Store is now shipped with Cube.js and now there's an
[official Docker image](https://hub.docker.com/r/cubejs/cubestore) for Cube
Store on Docker Hub. This is a huge milestone for us, and we're really excited
😀 To get started, you'll need to install the Cube Store driver and set your
external database to `cubestore`. If you prefer to see this feature in action,
check out
[March's Community Call on YouTube](https://youtu.be/SycFPE4LRHo?t=1980).

## Vue Integration

The Vue integration for Cube.js now supports the `QueryBuilder` and
`QueryRenderer` components that effectively allows you to build your own Cube.js
[Developer Playground](https://cube.dev/docs/dev-tools/dev-playground) or
provide a similar experience to your users. This also brings our Vue integration
to parity with Angular and React, and we think it will be really helpful for
improving Cube.js adoption in the Vue community.

## Playground

The Developer Playground has had a round of quality-of-life improvements; the
most notable being:

- The Security Context for queries can now be modified before making requests.
  This was a source of frustration for users who had security-context dependent
  schemas; prior to this there was no easy way to test these schemas in
  development mode.
- Invalid dimensions/measures are now clearly marked as such. This was often a
  minor pain point when developing schemas; invalid or out-of-date members would
  hang around and it wasn't often straightforward to tell whether they still
  existed or not.
- Queries are now prevented from automatically running, and now require you to
  click a button. This prevents sending any intermediate requests as a query is
  being built up, which in turn, reduces the load on the Cube.js API.
- Initial database configuration can now be done within the Developer
  Playground. Start a Cube.js project without any database configuration and
  upon first-boot, the Developer Playground will launch a connection wizard.
- Vue code snippets can now be generated, bringing it to parity with Angular and
  React.
- Vue-based charts can now be added to the Dynamic Dashboard, just like Angular
  and React.