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>

Frankly, even with the best tooling available, analytical query performance is an exceptionally complex topic. __In a few weeks, we’ll be hosting a webinar to demonstrate how Query History and other Cube Cloud features can be leveraged to help you analyze and optimize query performance. [Register today](https://cube.dev/events/analyzing-and-optimizing-query-performance-with-cube).__

## 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).

Igor Lukanin

Changelog

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/docs/releases/v0-31
[cube-docs-caching-lambda]: /caching/pre-aggregations/lambda-pre-aggregations
[cube-docs-conf-clickhouse]: /config/databases/clickhouse
[cube-docs-conf-mssql]: /config/databases/mssql
[cube-docs-conf-oracle]: /config/databases/oracle
[cube-docs-deploy-cloud]: /deployment/platforms/cube-cloud
[cube-docs-deploy-docker]: /deployment/platforms/docker
[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. We have
  [an upcoming webinar with Materialize](https://materialize.com/resources/community-meetup-cube-materialize/)
  where we’ll be talking a lot more about this.
- 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://www.notion.so/v0-30-f47322c94717437aad0f55df775f34ae)
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.

  ![image|610x262](upload://tnQlfBHYSQzxnalW3c9sxhsyd4s.png)

- 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

  ![image|690x381](upload://9fThKKqFoX0EqpZd14vixQj1CuM.png)

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

  ![image|690x288](upload://yPTZRJPoe7zrLiJmLV3z2B0nECX.png)

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.