# Releases Materialize release notes > For the complete documentation index, see [llms.txt](https://preview.materialize.com/materialize/40269/llms.txt). > **Note:** Starting with the v26.1.0 release, Materialize releases on a weekly schedule for > both Cloud and Self-Managed. See [Release schedule](https://preview.materialize.com/materialize/40269/markdown-docs/releases/schedule/index.md) for details. ## v26.47.1 *Released to Materialize Cloud: 2026-10-29*
*Released to Materialize Self-Managed: 2026-10-30*
### Bug Fixes - Fixed `DISTINCT ON` and per-group `LIMIT 1` queries returning no rows when an equality filter on a non-key column is applied on top of them, a regression present since v26.34.0. ## v26.47.0 *Released to Materialize Cloud: 2026-10-22*
*Released to Materialize Self-Managed: 2026-10-23*
### Turn cast errors into `NULL`s with `TRY_CAST` `TRY_CAST( AS )` evaluates an expression once and attempts to cast it to the target type. It produces `NULL` instead of an error when the value cannot be converted. This means that bad values in an ingest pipeline don't cause errors which block reads. ```mzsql CREATE TABLE raw_orders (id int, amount text); INSERT INTO raw_orders VALUES (1, '19.99'), (2, 'N/A'), (3, '250'); CREATE MATERIALIZED VIEW orders AS SELECT id, TRY_CAST(amount AS numeric(10, 2)) AS amount FROM raw_orders; SELECT * FROM orders ORDER BY id; ``` ```nofmt id | amount ----+-------- 1 | 19.99 2 | 3 | 250 ``` In the example above, using `TRY_CAST` makes the materialized view `orders` gracefully handle errors, so that reads succeed. If you used just `CAST`, every read of `orders` would fail with `invalid input syntax for type numeric: "N/A"`. Note that casts between a few Materialize-internal types, such as `regclass` and `mz_aclitem`, are not supported. For more details, see [`CAST` and `TRY_CAST`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/functions/cast/index.md#try_cast). ### View memory and disk usage on the new cluster details page The Console's redesigned cluster details page charts each replica's CPU, memory, and disk use against its limits, marks when a replica was hydrating or ran out of memory, and ranks the objects using the most memory. It is available today on Materialize Cloud, and will be available on Self-Managed next week. To try it, open a cluster and select **Show the new cluster details page** in the breadcrumb bar. ![Metrics tab of the new cluster details page, showing CPU and memory and disk usage against their limits, replica status with out-of-memory events, and the top 10 objects by memory](https://preview.materialize.com/materialize/40269/images/releases/v2647_cluster_details.png) ### Safely drop upstream `NOT NULL` constraints in your Postgres sources Materialize now allows you to `EXCLUDE ALL NOT NULL CONSTRAINTS` when creating a table from a Postgres source. Every column is ingested as nullable, so you can drop `NOT NULL` constraints upstream without causing your table to error. `PRIMARY KEY` and `UNIQUE` constraints are still recorded, and primary key columns remain `NOT NULL`. ```mzsql CREATE TABLE orders FROM SOURCE pg_source (REFERENCE public.orders) WITH (EXCLUDE ALL NOT NULL CONSTRAINTS); ``` For more details, see [`CREATE TABLE ... FROM SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/postgres/index.md) for PostgreSQL and the guide on [handling upstream constraint drops](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/source-versioning/index.md#handle-upstream-constraint-drop). ### Better freshness when adding tables to PostgreSQL sources When you add a table to a PostgreSQL source, with `CREATE TABLE ... FROM SOURCE`, Materialize can now snapshot the new table while reading the replication stream. This means that existing tables continue making progress during the snapshot. Previously, if you added a new table, progress on existing tables would be halted until the new table's snapshot finished. Note that adding a table still briefly restarts the source dataflow, and if the dataflow restarts again before the snapshot finishes (for example, after a replica resize or another table change), the other tables pause until Materialize catches back up on the replication stream. The cluster also uses additional memory while the new table hydrates. The snapshot and the replication stream now run at the same time on the same replica. On a single-worker replica (`25cc` or `50cc`), existing tables still fall behind during the snapshot. Before adding a table, use a source cluster size of `100cc` or larger, or temporarily resize it up for the snapshot. ### Improvements - **Zero-downtime upgrades wait less before promoting**: A rollout no longer applies a full stability wait to replicas created during that rollout, and no longer waits on collections or replicas that the outgoing deployment has not hydrated either. - **Lower connection balancer memory per connection**: Idle connections through the connection balancer now use about a third less memory, so a self-managed deployment with the 256 MiB default is no longer killed for running out of memory at roughly 3,800 connections. - **`min` and `max` over arrays and lists**: `min` and `max` now accept arrays and lists, and lists gain the `<>`, `<`, `<=`, `>`, and `>=` operators. Arrays with the same elements in differently shaped dimensions now sort as they do in PostgreSQL, which changes `<`, `ORDER BY`, `greatest`, and `least` for those arrays. ### Guides - [Understand the query lifecycle](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/query-lifecycle/index.md) - [Optimize point lookups with long `IN` lists](https://preview.materialize.com/materialize/40269/markdown-docs/transform-data/optimization/index.md#long-in-lists) ### Bug Fixes - Fixed the liveness probe restarting `environmentd` during a slow startup once client connections had filled its external SQL port, which could cause a restart loop. The operator now probes `environmentd`'s internal SQL port, except in deployments using password, SASL, or OIDC authentication. - Fixed `GRANT`, `REVOKE`, `ALTER ... OWNER`, and `ALTER CONNECTION` on a connection crashing Materialize, or rerunning a sink from its old definition, when a sink using that connection had been changed with `ALTER SINK ... SET FROM`. - Fixed `environmentd` crashing when a query passes a non-constant first argument to `regexp_extract`; it now returns an error. - Fixed Iceberg sinks over relations with nested columns, such as arrays, stalling with a schema mismatch error after a Materialize restart. - Fixed a zero-downtime upgrade never becoming ready to promote when resuming an environment that had been stopped for more than two hours. - Fixed freshness stalling after an automatic hydration burst ended, by keeping the burst replicas until a steady replica has caught up. - Fixed up to 40 ms of added latency per parameterized query for clients that send each protocol message separately, such as node-postgres before 8.14.1. - Fixed `mz_uptime()` returning a different value for each occurrence in a query, which made queries combining it with `INTERSECT` fail or return wrong results. - Fixed a crash when a query that emits timestamp notices ran concurrently with a `DROP INDEX` on an index it reads. - Fixed SQL Server sources failing to decode an update to a table with a `NOT NULL` large object column when the update did not change that column. - Fixed the committed offset for a PostgreSQL source jumping backwards after a restart when a new table had been added to the source. - Fixed `mz_cluster_replica_metrics_history` recording `NULL` CPU and memory for the second and later processes of multi-process replicas. - Fixed the connection balancer dropping a query that a client sent in the same write as its password. ## v26.46.1 *Released to Materialize Cloud: 2026-10-20*
*Released to Materialize Self-Managed: 2026-10-20*
### Bug Fixes - Fixed Iceberg sinks over a relation with a nested column, such as an array, stalling with `Iceberg table '...' schema does not match expected schema` when resuming against a table the catalog created, which happens after a Materialize restart; Materialize no longer requires the catalog's field IDs to match its own, and assigns field IDs to nested types in the breadth-first order most catalogs use. - Fixed reduced persist read throughput in Self-Managed deployments that use Google Cloud Storage, which since v26.45.0 have sent all concurrent persist reads over a single HTTP/2 connection. To spread these reads across multiple connections, run `ALTER SYSTEM SET persist_blob_http_pool = 'gcs';` as the `mz_system` user, or add the setting to your [system parameters ConfigMap](https://materialize.com/docs/self-managed-deployments/configuration-system-parameters/); it takes effect without a restart. ## v26.46.0 *Released to Materialize Cloud: 2026-10-15*
*Released to Materialize Self-Managed: 2026-10-16*
### Kafka sink message attribution Kafka sinks can now attach a `materialize-sink-id` header carrying the sink's ID to every message they produce, so a consumer of a topic that several sinks write to can tell which sink produced each message. For more information, see [`CREATE SINK`: Headers](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/kafka/index.md#headers). ### Exclude upstream constraints from MySQL source tables > **Public Preview:** This feature is in public preview. `CREATE TABLE ... FROM SOURCE` now accepts `EXCLUDE CONSTRAINTS` and `EXCLUDE ALL CONSTRAINTS` for MySQL sources, as it already did for PostgreSQL sources. This lets you drop a `PRIMARY KEY`, `UNIQUE`, or `NOT NULL` constraint upstream without stalling ingestion: - `EXCLUDE CONSTRAINTS` excludes the `PRIMARY KEY` and `UNIQUE` constraints you name. - `EXCLUDE ALL CONSTRAINTS` excludes every constraint, including `NOT NULL`, so the table has no keys and every column is nullable. For more information, see [Handle upstream constraint drop](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/source-versioning/index.md#handle-upstream-constraint-drop). ### Advisory - **Self-Managed: Potential performance regression for upsert sources**: This release may regress the performance of [upsert sources](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/index.md#upsert-sources), such as Kafka sources that use `ENVELOPE UPSERT`, in Materialize Self-Managed deployments. **Upgrade impact**: If you run Materialize Self-Managed with upsert sources, hold off on upgrading to v26.46.0. Self-Managed deployments without upsert sources require no action. ### Improvements - **Replication-factor changes during a cluster reconfiguration**: `ALTER CLUSTER ... SET (REPLICATION FACTOR ...)` is now accepted while a graceful reconfiguration is in flight, preserving the dimensions and the deadline you did not name, so you can scale a stuck reconfiguration down to zero or cancel it by restoring the original configuration instead of waiting it out. - **Zero-downtime deployment readiness follows replica hydration**: Zero-downtime deployments no longer restart their stability period when the new deployment restarts to pick up DDL changes, and now wait for every replica of a cluster to hydrate before cutting over. - **Read-then-write statements no longer take a table write lock**: `DELETE`, `UPDATE`, and `INSERT` statements that read before writing no longer hold a per-table write lock between the read and the write. - **Lower memory when ingesting wide schemas**: Sources with wide schemas now need less memory to write their data. - **Kafka broker addresses are checked against private IP ranges**: In Materialize Cloud, Kafka connections that reach brokers directly (not through PrivateLink or an SSH tunnel) now fail with `Broker address resolved to a private IP` if a broker resolves to a private address. Existing sources and sinks using such brokers stall the next time they reconnect. - **Creating and altering network policies is disabled by default in Self-Managed**: The operator Helm chart now disables `CREATE NETWORK POLICY` and `ALTER NETWORK POLICY`, because self-managed access paths such as port-forwards don't preserve the client IP. Existing policies are still enforced. To manage network policies, set `operator.args.enableDatabaseNetworkPolicies: true`. - **Lower `mz_catalog_server` load from open cluster pages**: Open cluster detail pages in the Console put much less load on the `mz_catalog_server` cluster. ### Bug Fixes - Fixed casts from `"char"` to numbers and other non-string types, which panicked the optimizer during constant folding or crashed the replica running an operator over a `"char"` column; `"char"` to `int4` now yields the byte value, and every other target goes through the text representation. - Fixed `EXPLAIN ANALYZE CPU` and `EXPLAIN ANALYZE CLUSTER CPU` counting operators nested inside regions more than once, which reported 1.5x to 3x the real CPU time for joins, reduces, and `TopK`. - Fixed `offset_committed` in `mz_source_statistics` reporting the progress of a source's slowest export for every one of its exports, so a subsource or table that is still snapshotting no longer inflates the ingestion lag reported for the others. - Fixed `COPY FROM` a URL decoding the response body into the target table when the server answered with a 4xx or 5xx status, which now fails with `server returned HTTP `. - Fixed the MCP server returning an HTTP 422 error for a `tools/call` request without the optional `arguments` field. - Fixed the MCP server returning an HTTP 422 error, rather than a JSON-RPC "method not found" error, for unsupported methods that include `params`. ## v26.45.1 *Released to Materialize Cloud: 2026-10-08*
*Released to Materialize Self-Managed: 2026-10-09*
### Alerting for Self-Managed *Materialize Self-Managed only* Starting with v16.0.0 of the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules), the monitoring stack ships with ready-made alerts, so you hear about a problem before your users do: - **Ready-made alert rules**: 34 alerts are on by default, covering Materialize and the Kubernetes platform under it. They include `environmentd` going down, clusters stuck hydrating, replicas nearing their memory limit or being OOM-killed, and panics in Materialize's logs. - **Route each alert to whoever acts on it**: Every alert carries a severity and an audience, `platform` for the team operating the deployment and `workload` for the teams that own the clusters, so you can send each to the right people. - **Notify the tools your team already uses**: Configure PagerDuty, Slack, Microsoft Teams, email, or webhook receivers from Terraform. A default install configures no receiver, so alerts notify nobody until you add one. For more information, see [Alerting](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/alerting/index.md) and [Customize alerting](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/customize-alerting/index.md). ### Improvements - **External dependency monitoring for Self-Managed**: Starting with v15.0.0 of the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules), new **Materialize Persist (Storage)** and **Materialize Consensus (Metadata)** dashboards show the object storage and metadata database that Materialize depends on, so you can tell quickly whether a problem is in Materialize or in one of its dependencies. - **`sum` and `avg` over `interval`**: `sum(interval)` and `avg(interval)` now work and return `interval`, matching PostgreSQL. - **Improved compatibility with PostgreSQL ODBC clients**: Queries that psqlODBC generates with `OPERATOR(pg_catalog.=)` syntax now parse instead of failing. - **Lower memory for `MIN` and `MAX`**: A materialized view or index computing a single `MIN` or `MAX` over an input that receives updates or deletes no longer keeps an extra copy of its input in memory. - **Lower `SUBSCRIBE` and query latency**: Introspection logging now processes its events in bounded chunks instead of all at once, so it no longer holds up `SUBSCRIBE` results and indexed queries on the same replica. - **Kubernetes API server certificates need a subject alternative name (Self-Managed)**: The Materialize operator, `environmentd`, and `mz-debug` now reject a Kubernetes API server certificate that names its host only in its common name. EKS, GKE, AKS, and kind are unaffected; if you use hand-issued API server certificates, check them before upgrading. - **Schema registry and `COPY FROM` server certificates need a subject alternative name**: Confluent Schema Registry connections, `COPY FROM` URLs, and the OIDC issuer fetch now reject a server certificate that names its host only in its common name, so reissue any such certificate with a matching subject alternative name before upgrading. A schema registry certificate that is byte-for-byte identical to the connection's `SSL CERTIFICATE AUTHORITY` is still trusted. - **Kubernetes events from the Materialize operator**: The operator now publishes Kubernetes events when it fails to reconcile a `Materialize`, `Balancer`, or `Console` resource and at each `Materialize` rollout phase, so `kubectl describe` shows why a resource is not progressing. ### Agent Skills - **`mz-demo-data`**: A new skill that creates continuously updating synthetic data inside Materialize using views over `mz_now()`, with no Kafka or external load generator, in a `materialize_demo` schema that one `DROP SCHEMA` removes. ### Bug Fixes - Fixed zero-downtime deployment cut-overs that could stall for hours on environments with a large catalog audit log. - Fixed `DISCARD ALL` not reporting the parameters it resets, which caused connection poolers such as pgbouncer to lose track of values like `application_name`. - Fixed the Console showing different cluster utilization on different pages, and reporting memory and CPU per process rather than combined for multi-process replicas. ## v26.44.1 *Released to Materialize Cloud: 2026-10-01*
*Released to Materialize Self-Managed: 2026-10-02*
### Advanced SSO (OIDC, SAML and SCIM) for Self-Managed *Materialize Self-Managed only* > **Public Preview:** This feature is in public preview. Self-Managed deployments can now use advanced single sign-on (SSO). Users sign in to Materialize with your identity provider (IdP), such as Okta, instead of a separate Materialize password: - **Sign in with [SAML](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/identity-providers/index.md#saml-via-polis) or [OIDC](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/identity-providers/index.md#direct-oidc)**, whichever protocol your IdP already uses. - **Provision users and groups with [SCIM](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/identity-providers/index.md#scim-via-polis)**, so users are created and deactivated in Materialize as they change in your IdP. - **[Map IdP groups to Materialize roles](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/role-mapping/index.md)**: roles follow a user's IdP groups every time they sign in, with no manual `GRANT` or `REVOKE` statements required. Advanced SSO is deployed with the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules) and requires a license key with the advanced SSO entitlement (see [Prerequisites](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/prerequisites/index.md)). You can deploy it as part of a new installation on [AWS](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/install-on-aws/index.md), [GCP](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/install-on-gcp/index.md), or [Azure](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/install-on-azure/index.md), or [add it to an existing installation](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/existing-installation/index.md). For more information, see [Advanced SSO (OIDC, SAML and SCIM)](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/sso/advanced/index.md). ### SCIM group-to-role mapping is generally available on Materialize Cloud *Materialize Cloud only* Syncing identity provider groups to Materialize via SCIM is now generally available, graduating from private preview. You can manage who has access to what in Materialize directly from your identity provider (IdP): - **Map IdP groups to custom organization roles**, so members of a group automatically receive the right level of access to your Materialize organization. - **Sync group membership to database roles**: when a user reconnects, they are granted membership in database roles with names matching their IdP groups, with no manual `GRANT` or `REVOKE` statements required. As team members join, leave, or change teams, updating their group membership in your IdP keeps their access in Materialize aligned. Set it up in the [Materialize Console](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/console/index.md) or with Terraform. For more information, see [Sync IdP groups](https://preview.materialize.com/materialize/40269/markdown-docs/security/cloud/users-service-accounts/sync-idp-groups/index.md). ### Improved query latency under load We've changed how Materialize serves indexed queries under heavy load. In our tests, the client-side p99 latency of single-key lookups running next to heavy scans dropped from 3.64s to 37ms. Excluding the network round trip, the server-side p99 latency dropped from 3.61s to 3ms. ![Client-side latency of single-key lookups running next to heavy scans, with offload disabled (2 to 4 seconds) and enabled (about 30 ms)](https://preview.materialize.com/materialize/40269/images/releases/v2644_query_latency.png) We've done this by offloading heavy `SELECT` queries onto separate threads. Previously, heavy `SELECT` queries (such as a filter on a key that matches millions of rows) caused head-of-line blocking. Now, these queries run on separate threads, allowing smaller lookups to keep running in parallel. Concurrent heavy scans also finish faster, because they run side by side instead of queuing on one worker. Queries that read little data are unaffected. ### Operational dashboards for Self-Managed *Materialize Self-Managed only* Starting with v13.1.2 of the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules), the monitoring stack installs new Grafana dashboards for operating Materialize day to day: - **Environment dashboards**: Follow an upgrade as it rolls out with **Materialize Upgrade**, which shows Kubernetes events, blue/green generation progress, and the operator's reconciliation loop. It requires Materialize v26.41.0 or later for full coverage. View logs and Kubernetes events from your Materialize workloads with **Materialize Logs and Events**. - **Infrastructure dashboards**: View logs and events from the monitoring stack, Kubernetes system components, and the node journal with **Infrastructure Logs and Events**. Inspect a single node's CPU, memory, network, storage, pods, and conditions with **Infrastructure Node Detail**. ![Materialize Upgrade dashboard during a blue/green upgrade, showing the old and new generations' hydration progress, worst-case lag, pods, and versions](https://preview.materialize.com/materialize/40269/images/releases/v2644_upgrade_dashboard.png) For more information, see [Grafana](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/grafana/index.md) and the [list of available dashboards ⧉](https://materializeinc.github.io/materialize-monitoring/dashboards/all/). ### Improvements - **Improved freshness, by addressing slow object storage reads**: A single hung read from object storage, such as one on a connection that died without closing, could hold back every dataflow that depends on it. Materialize now retries a read that is still outstanding after 2 seconds on a second, independent connection and uses whichever response arrives first. In Materialize Cloud, this cut reads slower than 4 seconds by about 70%. - **Dynamic balancerd configuration for Self-Managed**: Pointing `spec.balancerdConfigmapName` on a `Materialize` resource, or `spec.configmapName` on a standalone `Balancer`, at a ConfigMap you own containing `config.json` lets you change balancerd settings such as `balancerd_max_connections` without restarting balancer pods, with balancerd rereading the file about once a second after Kubernetes propagates an update. - **Connection limits in balancerd count connections from accept**: `balancerd_max_connections` now counts every connection from the moment it is accepted rather than only those that completed the startup sequence, so a connection over the limit is closed rather than answered with an error, and the new `balancerd_pre_resolved_timeout` (default 60 seconds, `0` disables) closes a connection that has not finished TLS negotiation, startup, and authentication within it. - **Lower balancerd memory use per connection**: `balancerd` now builds the TLS connector for its upstream `environmentd` connections once at startup instead of once per connection, which takes certificate parsing out of connection setup and cuts memory held per proxied TLS connection by roughly a factor of ten in local measurement, leaving more headroom under `balancerd_max_connections` for a given memory limit. - **`uuid` columns in Iceberg sinks**: An Iceberg sink now creates `uuid` columns as Iceberg `string`, in the lowercase hyphenated form, rather than `fixed[16]`, so a sink can target a catalog with no fixed-width binary type such as Unity Catalog; a table already created with a `fixed[16]` column stays writable. - **Longer retention for replica hydration history**: `mz_internal.mz_replica_hydration_history` now keeps completed hydration episodes for 120 days on its own retention setting, while `mz_internal.mz_object_hydration_history` stays at 30 days, so a longer window of replica history is available for capacity planning. - **PostgreSQL sources are identifiable upstream**: Connections a PostgreSQL source opens to the upstream database, including its replication connection, now set `application_name` to `materialize`, so you can pick them out in `pg_stat_activity`. ### Agent Skills - **`mz-` skill names**: The Materialize agent skills are renamed to the `mz-` prefix — `materialize-dbt` is now `mz-dbt`, `materialize-docs` is now `mz-docs`, and `mcp-developer-analysis` is now `mz-health-check`, for example — so if you installed them with `npx skills`, remove the old copies so each skill appears only once. - **`mz-health-check`**: The health check now reports materialized views on clusters with no replicas, which stop advancing and hold back compaction of every input they read, so their storage keeps growing. ### Guides - [Protect sensitive columns](https://preview.materialize.com/materialize/40269/markdown-docs/security/patterns/protect-sensitive-columns/index.md) - [PostgreSQL: Troubleshoot a stuck snapshot](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/stuck-snapshot/index.md) - [MySQL: Supported database operations](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/index.md#supported-database-operations) - [Troubleshoot slow queries](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/troubleshooting/slow-queries/index.md) - [Troubleshoot unresponsive queries](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/troubleshooting/unresponsive-queries/index.md) - [Troubleshoot expensive queries](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/troubleshooting/expensive-queries/index.md) - [Troubleshoot hydration failures](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/troubleshoot-clusters/hydration-failures/index.md) ### Bug Fixes - Fixed a panic in PostgreSQL sources when the replication stream carried messages committed before Materialize read a table's schema, which may have described an incompatible shape; each table now records the upstream LSN its schema was read at and ignores replication messages from before it. - Fixed a security vulnerability in the `postgres-protocol` dependency (GHSA-5x78-73v4-xg6w), where a malicious PostgreSQL server could exhaust client CPU by supplying an unbounded SCRAM iteration count during authentication; iteration counts above 2,000,000 are now rejected. - Fixed a security vulnerability in the `imbl` dependency (RUSTSEC-2026-0292), a double free or use-after-free in the chunk and inline-array removal paths when an element's `Drop` panics. - Fixed `dbt-materialize` running unit tests on the session's default cluster instead of the cluster configured in the dbt profile. ## v26.43.0 *Released to Materialize Cloud: 2026-09-24*
*Released to Materialize Self-Managed: 2026-09-25*
### Iceberg support for Databricks on Azure > **Public Preview:** This feature is in public preview. Iceberg sinks can now write to Apache Iceberg tables registered in [Databricks Unity Catalog](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-databricks/index.md) on Azure, where catalogs store their data in Azure Data Lake Storage Gen2. Set `STORAGE PROVIDER = 'adls'` on the Iceberg catalog connection alongside `ACCESS DELEGATION = 'vended-credentials'`, and Materialize writes to Azure Data Lake Storage with temporary, table-scoped credentials that Unity Catalog vends. Materialize refreshes both the OAuth2 token and the vended credentials while the sink runs, so the sink needs no Azure credentials of its own. ```mzsql CREATE SECRET databricks_oauth AS ':'; CREATE CONNECTION iceberg_catalog_connection TO ICEBERG CATALOG ( CATALOG TYPE = 'rest', URL = 'https://adb-..azuredatabricks.net/api/2.1/unity-catalog/iceberg-rest', WAREHOUSE = '', CREDENTIAL = SECRET databricks_oauth, OAUTH2 SERVER URL = 'https://adb-..azuredatabricks.net/oidc/v1/token', SCOPE = 'all-apis', ACCESS DELEGATION = 'vended-credentials', STORAGE PROVIDER = 'adls' ); CREATE SINK IN CLUSTER FROM INTO ICEBERG CATALOG CONNECTION iceberg_catalog_connection ( NAMESPACE = '', TABLE = '' ) MODE APPEND WITH (COMMIT INTERVAL = ''); ``` For more information, see: - [Guide: Databricks Unity Catalog](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-databricks/index.md) - [`CREATE CONNECTION`: Iceberg catalog](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#iceberg-catalog), including [storage access delegation](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#iceberg-catalog-access-delegation) - [`CREATE SINK`: Iceberg](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md), including [append mode](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md#append-mode) ### Claude Code and Codex plugins for Materialize The [Materialize agent skills](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md) are now available as a plugin for Claude Code and Codex. The plugin installs all the skills at once, and helps you keep them up to date automatically. In Claude Code: ``` /plugin marketplace add MaterializeInc/agent-skills /plugin install materialize@materialize ``` In Codex: ```bash codex plugin marketplace add MaterializeInc/agent-skills codex plugin add materialize@materialize ``` If you installed the skills with `npx skills`, remove them before you install the plugin, so each skill appears only once. For more information, see [Agent Skills](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md#install-as-a-plugin). ### Improvements - **Graceful cluster resizes wait for replacements to catch up**: A graceful resize now retires the outgoing replicas only once the new replicas have hydrated and caught up to the replicas they replace, so cut-overs no longer stall query progress. A resize that cannot catch up in time follows its `ON TIMEOUT` policy, which defaults to `ROLLBACK`. - **Swap usage in replica metrics**: `mz_internal.mz_cluster_replica_metrics` and `mz_cluster_replica_metrics_history` now report `swap_bytes` for each replica process, and `mz_internal.mz_cluster_replica_utilization` and `mz_cluster_replica_utilization_history` expose `swap_percent` as a share of the replica's heap allocation, so you can see how much of a replica's memory has spilled to swap. - **Per-process peaks in replica hydration history**: `mz_internal.mz_replica_hydration_history` now records one row per replica process, carrying that process's own memory and disk peaks, so resource skew across the processes of a multi-process replica is visible. ### Guides - [Understand the lifecycle of a sink](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/lifecycle-of-a-sink/index.md) - [PostgreSQL: Supported database operations](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/index.md#supported-database-operations) - [SQL Server: Supported database operations](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/sql-server/index.md#supported-database-operations) ### Bug Fixes - Fixed `DEALLOCATE`, `CLOSE`, `EXECUTE`, and `FETCH` failing with a "does not exist" error and aborting the surrounding transaction when the prepared statement or cursor name was given in double quotes; a name created over the extended wire protocol is stored exactly as it arrives, but these statements re-quoted it before looking it up, so drivers such as psqlODBC that prepare statements over the protocol and later deallocate them by quoted name could not release them. - Fixed an abort that dropped every session in the environment when a cursor declared over a `CLOSE` statement naming that same cursor was fetched from. - Fixed Iceberg sinks applying a commit's changes on top of newer table state when retrying, which could duplicate written data if an earlier attempt had in fact succeeded or another writer had taken over; the sink now inspects the catalog's table state before applying the commit. - Fixed `object_count` in `mz_internal.mz_replica_hydration_history` counting a replica's built-in introspection dataflows, which made it disagree with the rows recorded in `mz_internal.mz_object_hydration_history` for the same episode; introspection-only episodes are still recorded, with `object_count = 0`. ## v26.42.0 *Released to Materialize Self-Managed: 2026-09-18*
### Safely drop upstream constraints in your Postgres sources Materialize now allows you to `EXCLUDE CONSTRAINTS` when creating a table from a Postgres source. You can use this workflow to safely drop an upstream constraint, without causing your source to stall. Today, the Postgres source incorporates `PRIMARY KEY`, `UNIQUE` and `NOT NULL` constraints. ```mzsql CREATE TABLE orders FROM SOURCE pg_source (REFERENCE public.orders) WITH (EXCLUDE CONSTRAINTS ('orders_customer_email_key')); ``` If you want to exclude all constraints, you can do that too: ```mzsql CREATE TABLE orders FROM SOURCE pg_source (REFERENCE public.orders) WITH (EXCLUDE ALL CONSTRAINTS); ``` For more details, see [`CREATE TABLE ... FROM SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/postgres/index.md) for PostgreSQL and the guide on [handling upstream schema changes](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/source-versioning/index.md). ### Size clusters using hydration history You can now track how long a cluster took to hydrate, and what resources it needed. Every completed hydration is now recorded in two new introspection tables: - [`mz_internal.mz_replica_hydration_history`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/system-catalog/mz_internal/index.md#mz_replica_hydration_history) to track hydration metrics per replica - [`mz_internal.mz_object_hydration_history`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/system-catalog/mz_internal/index.md#mz_object_hydration_history) to track hydration metrics per object Use these tables to determine your hydration requirements, and right-size your clusters accordingly. ```mzsql SELECT rh.replica_name AS replica, rh.size, h.started_at, h.finished_at - h.started_at AS hydration_time, h.object_count, pg_size_pretty(h.peak_memory_bytes + coalesce(h.peak_disk_bytes, 0)) AS peak_heap, pg_size_pretty(s.memory_bytes + coalesce(s.disk_bytes, 0)) AS heap_limit FROM mz_internal.mz_replica_hydration_history AS h JOIN mz_internal.mz_cluster_replica_history AS rh ON rh.replica_id = h.replica_id JOIN mz_catalog.mz_clusters AS c ON c.id = rh.cluster_id JOIN mz_catalog.mz_cluster_replica_sizes AS s ON s.size = rh.size WHERE c.name = 'analytics' ORDER BY h.started_at DESC; ``` ```none replica | size | started_at | hydration_time | object_count | peak_heap | heap_limit ---------+-------+-------------------------------+----------------+--------------+-----------+------------ r1 | 400cc | 2026-09-08 09:12:04.117841+00 | 00:04:11.83 | 41 | 13 GB | 152 GB (1 row) ``` Compare `peak_heap` (the memory plus disk a replica process used) with `heap_limit` (the memory plus disk its size provides) to find the size that fits your workload. This lets you create a cluster at a generous size, hydrate once, and then size down with confidence. The new [cluster sizing guide](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/sizing/index.md) walks through that workflow, and [Optimize hydration requirements](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/optimize-hydration-requirements/index.md) covers what to do when a single object accounts for most of the peak. ### Improvements - **Vended credentials for Iceberg sink to GCP BigLake**: `CREATE CONNECTION ... TO ICEBERG CATALOG` now accepts a storage provider option, and `ACCESS DELEGATION` is allowed on GCP BigLake catalog connections, so an Iceberg catalog backed by Google Cloud Storage can authenticate with credentials the catalog vends. For more information, see [GCP BigLake](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-gcp/index.md). - **IANA time zone data updated to 2026c**: Time zone rules now follow IANA tzdata 2026c, covering Morocco's move to permanent +00 on 2026-09-20, Alberta's permanent -06, British Columbia's permanent -07, and Moldova's EU transition instants since 2022. - **Pod priority classes in Self-Managed deployments**: Operators can set `environmentd.priorityClassName` and `clusterd.priorityClassName` in the Helm chart, so a higher-priority pod scheduled onto a full node no longer evicts Materialize ahead of other workloads. - **Composite types in `mz-deploy` projects**: `mz-deploy` records the full catalog type for composite types such as records in `types.lock`, so views that read a dependency's record-typed column type check offline instead of resolving to a pseudo type. ### Guides - [Size clusters for hydration](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/sizing/index.md) - [Optimize hydration requirements](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/optimize-hydration-requirements/index.md) - [Autoscaling for hydration](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/autoscaling/index.md) - [Troubleshoot anomalies in memory usage](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/troubleshoot-clusters/memory-spike/index.md) - [Troubleshoot anomalies in CPU usage](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/troubleshoot-clusters/cpu-troubleshooting/index.md) ### Bug Fixes - Fixed `CREATE TABLE ... FROM SOURCE` and `ALTER SOURCE` connecting to a source's upstream system before checking the caller's privileges on that source, which let a role holding no privilege on the source read upstream schema, table, and column names out of the resulting purification errors; `CREATE TABLE ... FROM SOURCE` now requires `SELECT` on the source plus schema `USAGE`, and `ALTER SOURCE` requires ownership. - Fixed `ALTER CLUSTER` resource-limit enforcement during graceful reconfiguration, which predicted a reshape's peak replica overlap instead of checking the replica set actually being created; a target that does not fit now leaves the existing replicas serving and reports `INSUFFICIENT_RESOURCES` with a hint. - Fixed `ALTER CLUSTER ... WITH (WAIT UNTIL READY (..., ON TIMEOUT = 'COMMIT'))` needing room for the old and new replica sets at once when its deadline passed; the cut-over is now a single transaction that creates the target and retires the previous replicas together, so only the net change has to fit. - Fixed cluster- and replica-scoped configuration not reaching the replacement replicas the cluster controller creates during a reconfiguration, so those replicas now apply the overrides before their first render. - Fixed `mz_object_dependencies` omitting a sink's dependency on a user-defined type that the sink references through a `DOC ON TYPE` or `DOC ON COLUMN` option. - Fixed `mz-deploy compile` rejecting valid SQL with `precision for type numeric must be between 1 and 39` when a view aggregated a `bigint` or `uint8` column with `sum()` and another view in the project read it, and fixed declared `numeric(p, s)` columns being stubbed with the scale in the precision position. ## v26.41.0 *Released to Materialize Cloud: 2026-09-10*
*Released to Materialize Self-Managed: 2026-09-11*
### Improvements - **Improved Clusters Page on console**: The Clusters Page now shows you per-replica usage, including CPU, memory, disk, and heap usage. Use the filters on the page to quickly identify unhealthy clusters. We've also sped up the page; page-loads which previously took ~600ms now take 25-50ms on environments with 2,000 objects. - **MySQL snapshot parallelism enabled by default**: In v26.39, we launched [parallelized snapshots](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/snapshot-parallelism/index.md) for [MySQL sources](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/index.md) on tables which have a `CHAR` or `VARCHAR` primary key using the `utf8mb4` character set with the `utf8mb4_bin` collation. In our tests, we saw snapshot speedups of up to 80%. This behavior is now enabled by default. - **Pre-flight reference checks in `mz-deploy`**: `mz-deploy apply`, `apply tables`, and their `--dry-run` forms now check every `CREATE TABLE ... FROM SOURCE` reference against what the source can actually expose before creating anything, and report the mismatches grouped by source with close-name suggestions instead of failing partway through the batch with a raw server error. ### Guides - **Reorganized documentation**: The docs are now grouped by what you are trying to do, with [Fundamentals](https://preview.materialize.com/materialize/40269/markdown-docs/fundamentals/index.md), [Clusters](https://preview.materialize.com/materialize/40269/markdown-docs/clusters/index.md), [Developer tools](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/index.md), and [Export data](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/index.md). Every moved page redirects from its previous URL. - [Export data to Snowflake on AWS, using the Iceberg Sink to AWS S3 Tables](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-aws-snowflake/index.md) - [Query History for Self-Managed](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/query-history/index.md) - [ADBC (Arrow Database Connectivity)](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/adbc/index.md) - [Understand the lifecycle of a source](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/lifecycle-of-a-source/index.md) - [Upgrade the major version of your PostgreSQL source](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/major-version-upgrade/index.md) ### Bug Fixes - Fixed `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT` run while a zero-downtime upgrade was in progress leaving the upgraded environment on the view's previous definition, which either put `environmentd` into a crash loop that restarting could not clear or left the view silently computing and serving the replaced definition. - Fixed `EXPLAIN TIMESTAMP AS DOT` aborting `environmentd`, which let any role that can run SQL take an environment down with a single statement; the statement now returns an unsupported-format error. - Fixed `environmentd` entering a crash loop that restarting could not clear, after an `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT` was followed by dropping the old definition's dependencies. - Fixed a coordinator panic during `ALTER TABLE ... ADD COLUMN` when the schema change committed but its response was lost, so the retry now recognizes the evolution as already applied instead of reporting a mismatch. - Fixed Iceberg sinks panicking during Parquet writes when the sink's schema no longer matched that of an existing table, which could recur on every sink restart or zero-downtime upgrade; the sink now reports the mismatch instead. - Fixed MCP clients built on the official SDK failing the handshake, because Materialize answered `notifications/initialized` with `200` rather than the `202` the Streamable HTTP transport requires for a message that carries no reply. - `ALTER CLUSTER ... WITH (WAIT FOR ...)` now rolls back when its timeout is processed while the target replicas are still unhydrated, matching `WAIT UNTIL READY`'s safe default instead of forcing a cut-over that can cause downtime; request the previous behavior explicitly with `WAIT UNTIL READY (..., ON TIMEOUT = 'COMMIT')`. - Fixed the Console showing the previous region's clusters and Object Explorer contents after a region switch, until a full page refresh. ## v26.40.2 *Released to Materialize Cloud: 2026-09-07*
*Released to Materialize Self-Managed: 2026-09-08*
### Bug Fixes - Fixed `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT` run while a zero-downtime upgrade was in progress leaving the upgraded environment on the view's previous definition, which either put `environmentd` into a crash loop that restarting could not clear or left the view silently computing and serving the replaced definition. ## v26.40.0 *Released to Materialize Cloud: 2026-09-03*
*Released to Materialize Self-Managed: 2026-09-04*
### Iceberg support for Databricks on AWS > **Public Preview:** This feature is in public preview. Iceberg sinks can now write to Apache Iceberg tables registered in [Databricks Unity Catalog](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-databricks/index.md) on AWS, reached through Unity Catalog's Iceberg REST catalog endpoint. Two new Iceberg catalog connection options make this work: `OAUTH2 SERVER URL`, which names a token endpoint that does not sit under the catalog URI, and `ACCESS DELEGATION = 'vended-credentials'`, which asks the catalog for temporary, table-scoped storage credentials instead of static keys. Materialize refreshes both the OAuth2 token and the vended credentials while the sink runs, so a sink that outlives one credential lifetime keeps writing. ```mzsql CREATE SECRET databricks_oauth AS ':'; CREATE CONNECTION iceberg_catalog_connection TO ICEBERG CATALOG ( CATALOG TYPE = 'rest', URL = 'https://.cloud.databricks.com/api/2.1/unity-catalog/iceberg-rest', WAREHOUSE = '', CREDENTIAL = SECRET databricks_oauth, OAUTH2 SERVER URL = 'https://.cloud.databricks.com/oidc/v1/token', SCOPE = 'all-apis', ACCESS DELEGATION = 'vended-credentials' ); CREATE SINK IN CLUSTER FROM INTO ICEBERG CATALOG CONNECTION iceberg_catalog_connection ( NAMESPACE = '', TABLE = '' ) MODE APPEND WITH (COMMIT INTERVAL = ''); ``` For more information, see: - [Guide: Databricks on AWS](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg-databricks/index.md) - [`CREATE CONNECTION`: Iceberg catalog](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#iceberg-catalog), including [storage access delegation](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#iceberg-catalog-access-delegation) - [`CREATE SINK`: Iceberg](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md), including [append mode](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md#append-mode) ### Improvements - **Query History for Self-Managed**: Self-Managed deployments can now use the Console's Query History view to debug latency and performance. - **Bounded staleness isolation is generally available**: The [`bounded staleness `](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#bounded-staleness) transaction [isolation level](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md) is out of public preview and is now a supported part of the [`transaction_isolation`](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#setting-isolation-level) surface. See [when to use bounded staleness](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#when-to-use-bounded-staleness) and its [restrictions](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#restrictions). - **Replica resource usage introspection**: A new `mz_introspection.mz_cluster_replica_resource_usage` relation reports each replica process's own memory, swap, and disk observations at a higher cadence than the roughly once-a-minute orchestrator samples, so a spike between two samples is no longer invisible. - **Self-Managed: Automatic rollouts on GKE node pool upgrades**: The Materialize operator can now detect GKE node pool upgrades and automatically trigger rollouts to move workloads onto the new nodes, preventing outages from automatic node evictions. Deployments that use the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules) (v9.0.0 and later) get this configured for them, with no action needed; for all other deployments, see [GKE node pool upgrades](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/deployment-guidelines/gke-node-pool-upgrades/index.md) for the setup steps. ### Agent Skills - **mz-optimize-memory**: A new skill that works top-down from a cluster's largest arrangements to a table of memory-reducing fixes — index changes, outer-join and subquery rewrites, window-function patterns, and arrangement size hints — with rules for estimating each saving before making the change and verifying it afterwards. ### Bug Fixes - Fixed the MCP servers rejecting `tools/list`, `ping`, and `notifications/initialized` requests that carry any `params` — including the `_meta` field MCP clients are allowed to attach — with a non-JSON-RPC HTTP 422 that clients read as the server being unavailable. - Fixed `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT` leaving a stale cached query plan behind, which put `environmentd` into a crash loop on every subsequent restart once a dependency of the replaced definition was dropped, and could otherwise leave the view computing its old definition. - `CREATE TABLE ... FROM SOURCE` now requires `SELECT` on the source and `USAGE` on its schema, closing a case where `CREATE` on any schema a role controlled was enough to read a source that role had been denied; deployments where a platform team owns sources and application teams attach tables into their own schemas will need those `SELECT` grants added. - Fixed `ALTER CONNECTION` letting a connection owner keep secrets and connections they lack `USAGE` privileges on, and read those secrets during content checks or connection validation. - Fixed `ANY`/`ALL` over a `NULL` array or list returning the empty-set answer instead of `NULL`, and `array_position` failing to find `NULL` elements, both now matching PostgreSQL. - Fixed `round(numeric, scale)` erroring on a scale that reaches past the value's fractional digits, such as `round(123::numeric, 38)`, which could also let filter pushdown discard data a query matched. - Fixed identity-provider group sync silently finding nothing when `oidc_group_claim` names a claim the token declares directly, such as `roles`, so group-to-role mapping now works without a custom claim or JWT prehook. - Fixed Arrow ADBC clients failing to connect by adding the missing `pg_type.typsend` column, and fixed `typreceive` rendering as a numeric OID rather than the function name, so those clients resolve every column to its real type. - Fixed Iceberg sinks ignoring a table's `write.data.path` property and always writing data files to the default location. - Fixed sources on the Console's Objects page being described in replica-hydration terms, which could show a healthy source as `Not Hydrated`, leave a webhook source with no status, and hold a completed snapshot at 99%. - Fixed several `dbt-materialize` error paths reporting confusing failures instead of the intended messages, covering the index config parser, renaming a view, dropping an unsupported relation type, connection option parsing, and the version check against a server that is not Materialize. - Fixed the `mz` CLI failing on read-only commands such as `mz sql` when `mz.toml` sits on a read-only mount. ## v26.39.0 *Released to Materialize Cloud: 2026-08-27*
*Released to Materialize Self-Managed: 2026-08-28*
### Improvements - **Improved connect modal in the console**: We've updated the UI to make it easier to connect coding agents to our MCP servers, and connect applications to Materialize. - **Faster MySQL table snapshots** (private preview): Initial snapshots for MySQL tables are now parallelized. We saw speedups of up to 80%. When we tested a snapshot of a 2bn row table (2.45TB), previously the snapshot completed in 220 minutes. With the new parallelization, the snapshot completed in 43 minutes. Tables are eligible for parallel snapshots when they have a single-column `CHAR` or `VARCHAR` primary key using the `utf8mb4` character set with the `utf8mb4_bin` collation. For more information, see [MySQL snapshot parallelism](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/snapshot-parallelism/index.md). - **App password expiration** (*Materialize Cloud only*): When creating an app password in the [Materialize Console](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/console/index.md), you can now set an optional expiration, after which the app password is no longer valid. ### Agent Skills - **mz-ontology-design**: A new skill that structures a Materialize SQL code base as a canonical ontology — a shared `raw` database, a shared `core` database, and one database per use case — with rules for semantic object grain and identity, temporal semantics, and a machine-readable relationship registry. - **materialize-debug-freshness**: A new skill that diagnoses why an object is behind wall-clock time, sweeping source and sink status, attributing lag hop by hop, and ranking the dataflows and operators responsible. ### Bug Fixes - Fixed zero-downtime upgrades cutting over before built-in materialized views rebuilt by the upgrade had hydrated, which made them all hydrate at once at cut-over, spiking `mz_catalog_server` CPU and slowing catalog queries. - Fixed crashes and coordinator stalls when planning queries with long `JOIN` chains or long chains of CTEs. - Fixed a `column "table_func_0" does not exist` error when a table function in the `SELECT` list is combined with `GROUP BY`, aggregates, or `HAVING`. - Fixed out-of-memory crashes caused by large `SELECT` results over the HTTP and WebSocket APIs and by slow-reading `SUBSCRIBE` clients, with results now streaming incrementally over the WebSocket API, the result size limit now enforced on the HTTP API, and an error returned when a `SUBSCRIBE` client falls too far behind. - Fixed hangs where a `SUBSCRIBE` over a query the optimizer folds to a constant would never end, and stopped dataflows from retaining source collections none of their outputs read. - Fixed filter pushdown skipping data that matched a query, which could return too few rows, and fixed replica crashes when reading data with legacy or malformed statistics. - Fixed SQL Server sources reporting inflated ingestion lag during the initial snapshot. - `CREATE CONNECTION`, `ALTER CONNECTION`, and `VALIDATE CONNECTION` for AWS PrivateLink now reject a `SERVICE NAME` that is not an AWS VPC endpoint service name, such as a DNS hostname, instead of failing later with a misleading missing-availability-zones error. ## v26.38.2 *Released to Materialize Cloud: 2026-08-20*
*Released to Materialize Self-Managed: 2026-08-25*
### Dictionary compression > **Public Preview:** This feature is in public preview. Dictionary compression reduces the memory that [arrangements](https://preview.materialize.com/materialize/40269/markdown-docs/fundamentals/concepts/arrangements/index.md#arrangements) use when a column holds the same values repeatedly. Instead of storing a repeated column value each time it appears, Materialize stores that value once and has each row reference it. This can reduce steady state memory requirements after [hydration](https://preview.materialize.com/materialize/40269/markdown-docs/fundamentals/concepts/hydration/index.md) has completed. Dictionary compression is off by default. You opt in per cluster with the `EXPERIMENTAL ARRANGEMENT COMPRESSION` option: ```mzsql -- Turn compression on for a new cluster CREATE CLUSTER my_cluster ( SIZE = '100cc', EXPERIMENTAL ARRANGEMENT COMPRESSION = true ); -- Or turn it on for an existing cluster ALTER CLUSTER my_cluster SET (EXPERIMENTAL ARRANGEMENT COMPRESSION = true); ``` For more information, see: - [Guide: Dictionary compression](https://preview.materialize.com/materialize/40269/markdown-docs/transform-data/dictionary-compression/index.md), including [when it helps and when it does not](https://preview.materialize.com/materialize/40269/markdown-docs/transform-data/dictionary-compression/index.md#the-tradeoff) - [`CREATE CLUSTER`: Dictionary compression](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-cluster/index.md#dictionary-compression) - [`ALTER CLUSTER`: Dictionary compression](https://preview.materialize.com/materialize/40269/markdown-docs/sql/alter-cluster/index.md#dictionary-compression) ### Integrate with your observability stack *Materialize Self-Managed only* Materialize Self-Managed now integrates with the observability tools you already run. You can export metrics, and optionally logs, from Materialize to Datadog, Honeycomb, Google Cloud Monitoring, Prometheus remote write, or any monitoring backend with an Open Telemetry (OTLP) endpoint. Template dashboards and alerts are provided to help you get started. Follow the instructions for your destination: - [Datadog](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/datadog/index.md) - [Honeycomb](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/honeycomb/index.md) - [Google Cloud Monitoring](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/google-cloud-monitoring/index.md) - [Prometheus remote write](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/prometheus-remote-write/index.md), for Mimir, Amazon Managed Prometheus, or Grafana Cloud - [OpenTelemetry](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/opentelemetry/index.md), for any other OTLP endpoint, including your own collector If you don't have an observability stack set up, the [Materialize Terraform modules](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md#install-using-terraform-modules) can deploy one alongside Materialize. It collects metrics from Materialize and from your Kubernetes cluster, collects Materialize's container logs and Kubernetes events, stores both in your own object storage, and ships [Grafana](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/grafana/index.md) dashboards and Alertmanager alert rules to query them. The stack is controlled by the `enable_observability` variable, which defaults to `true` starting with v11.0.0 of the modules. For more information, see: - [Monitoring Self-Managed Materialize](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/index.md) - [How logs and metrics are stored and delivered](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/storage/index.md) - [Alerting](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/alerting/index.md) ### Improvements - **Notice for single-replica sources on multi-replica clusters**: Materialize now warns when a command leaves a cluster holding more than one replica alongside PostgreSQL, MySQL, or SQL Server sources, which always run on a single replica, since the extra replicas make those sources neither more fault tolerant nor faster to ingest. - **Self-Managed: Graceful resizing of system clusters**: `ALTER CLUSTER ... SET (SIZE ...)` on a system cluster such as `mz_catalog_server` or `mz_system` now runs as a background graceful reconfiguration, with a 24-hour default deadline and a rollback on timeout, instead of recreating the whole replica set at once, so `SHOW CLUSTERS` settles on the new configuration rather than flipping to it. ### Agent Skills - **materialize-debug-freshness**: New agent skill for diagnosing why an object is behind wall-clock time, whether that surfaces as a stale materialized view, index, or sink, or as a freshness alert. Running on the read-only tools of the Materialize developer MCP server, it ranks what is lagging, attributes the lag to a single hop, then rules out in-progress hydration, a replica dominated by one dataflow, and per-worker skew before naming the culprit operator and the SQL responsible for the expensive work. - **mz-deploy**: New agent skill covering the `mz-deploy` CLI — project layout, the compile/test/apply/stage/promote workflow, deploy IDs and staging suffixes, schema-granularity conflict detection, stable API schemas, profile resolution, and the `EXECUTE UNIT TEST` grammar. - **mz-sql-lsp**: New Claude Code plugin, installable from the `agent-skills` repository's new `materialize` plugin marketplace, that registers the `mz-deploy` language server for `.sql` files so agents can use go-to-definition, hover, and workspace symbols in an mz-deploy project instead of text search. ### Bug Fixes - Fixed an `INSERT` that ran concurrently with an `ALTER TABLE ... ADD COLUMN` crashing the server; the insert now fails with a retryable serialization error instead. - Fixed an environment restarting every few seconds and never becoming reachable when it held a sealed collection whose dependency had no readable history left; such a collection no longer blocks startup, so an operator can drop and recreate the affected object. - Fixed filter pushdown discarding data that matched the query when a float column contained negative `NaN` values, so the query returned too few rows. - Fixed a `TIMESTAMPTZ` literal near the end of the representable range, and rounding such a value to a lower precision, aborting the server. - Fixed several date/time and range text-format bugs: a sub-second value that rounded up to a full second rendered about a second early, a `TIME` string naming no time field was accepted instead of erroring, a quoted range bound kept its quotes so a `tsrange` could not survive a `::text::tsrange` round trip, and a BC date was not quoted inside a composite value. - Fixed a regular expression exhausting server memory before erroring — a pattern under the documented 1 MiB limit could allocate several gigabytes while being translated — by also rejecting patterns with more than 2000 character classes, counting each Unicode, Perl, or POSIX class such as `\p{L}`, `\d`, or `[[:alpha:]]`, and each range such as `a-z`. - Fixed a webhook source's `CHECK` expression having no bound on the memory it may allocate, which let concurrent requests to a source with an amplifying check exhaust server memory; a check that exceeds the budget, 20 MiB per request by default, is now refused with a `400` response. - Fixed the enforced connection limit picking up an `ALTER SYSTEM SET max_connections` from a transaction that was then rolled back, so the limit clients were held to could differ from the committed value. - Fixed `dbt-materialize`'s `deploy_init` failing when `CI_TAG` is set, the setup the blue/green deployment documentation prescribes, and made it quote the deployment schema consistently so a schema name that is not a bare lowercase identifier is handled correctly throughout the operation. - Fixed the comment `dbt-materialize`'s `deploy_promote` puts on each promoted schema ending without a timestamp. ## v26.37.0 *Released to Materialize Cloud: 2026-08-13*
*Released to Materialize Self-Managed: 2026-08-14*
### Improvements - **Self-Managed: Highly available operator**: The Materialize operator now runs two replicas by default, so rolling out an operator update no longer interrupts the CRD conversion webhook. Installations that manage their own RBAC must grant the operator `get`, `create`, and `update` on `leases` in `coordination.k8s.io`, because the two replicas coordinate through lease-based leader election. - **`IF NOT EXISTS` for clusters and replicas**: `CREATE CLUSTER` and `CREATE CLUSTER REPLICA` now accept an `IF NOT EXISTS` clause, so an existing cluster returns an `already exists, skipping` notice instead of an error. Provisioning scripts can now run idempotently, without a pre-flight existence check. ### Bug Fixes - Fixed a prepared statement with a parameterized `LIMIT` failing with `Top-level LIMIT must be a constant expression` whenever the bound parameter's type was not `bigint`. - Fixed `ALTER CLUSTER ... SET (REPLICATION FACTOR ...)` on a built-in cluster such as `mz_system` or `mz_support` being undone on the next restart, which could also wedge later replication-factor changes. - Fixed session parameter changes that an implicit transaction reverts not being announced to the client, so drivers that cache `ParameterStatus` such as pgjdbc and psycopg kept reporting a value the server had already discarded. - Fixed extended-protocol `Parse` and `Bind` messages carrying more than 32767 parameters, parameter types, or format codes being misdecoded, which left the rest of the message misaligned. - Fixed Avro object container file decoding reading a previous block's bytes into values, and bounded a block's declared object count so that a malformed file of a few dozen bytes can no longer cost minutes of decoding work. - Fixed a bare `map` in an option value failing to parse, which broke statements such as a Kafka sink with `TOPIC = "map"` and a materialized view's `PARTITION BY`. - Fixed the binary wire format accepting `Infinity` and `-Infinity` as a `numeric` parameter, a value no SQL literal can name. - Fixed a stalled catalog snapshot in the MCP server hanging a request indefinitely instead of failing it at the configured request timeout. - Fixed `balancerd` panicking at startup when the target `environmentd` service's DNS name was not yet resolvable, which could happen during an upgrade; startup now retries with backoff for a configurable 30 seconds. - Fixed Iceberg sinks counting every row twice in `messages_staged`, which drew the Console's Staged line at double the committed rate, and fixed the Console's sink statistics charts rendering a failed subscribe as an empty chart pinned at 0. - Fixed `ALTER NETWORK POLICY`, `GRANT`/`REVOKE USAGE ON NETWORK POLICY`, and `ALTER NETWORK POLICY ... OWNER TO` failing to resolve a quoted identifier such as `"hyphenated-name"`. - Fixed a query with a very large `LIMIT` crashing a cluster replica in a loop, which any user able to query an indexed relation could trigger with a single statement. - Fixed a persist command that retried for minutes committing a stale lease heartbeat, which could cost a read handle its lease. - Fixed Self-Managed deployments defaulting to an alternative materialized view sink implementation that could block cluster worker threads and cost readers their leases; it is now off by default, matching Materialize Cloud. ## v26.36.0 *Released to Materialize Cloud: 2026-08-07 on as-needs basis*
*Released to Materialize Self-Managed: 2026-08-07*
### Improvements - **`dbt-materialize`: `AUTO SCALING STRATEGY` support**: The dbt adapter now supports the `AUTO SCALING STRATEGY` cluster option, so you can speed up cluster hydration from your dbt workflows. You can set, reset, and disable it on a cluster, and `deploy_init` will automatically copy strategy configuration during blue/green deploys. - **Updated timezone data**: The IANA timezone database has been updated from 2022g to 2025b, correcting timezone rules for Egypt, Kazakhstan, Paraguay, and Greenland that changed since 2023. Numeric timezone abbreviations (e.g., `+05`) now render correctly in `pg_timezone_names`. ### Bug Fixes - Fixed a coordinator panic when a client abandoned a connection attempt that had already failed, such as an HTTP request that disconnects or times out. - Fixed `EXTRACT(YEAR ...)` and `make_timestamp` returning incorrect results for BC dates, where year numbering was off by one. - Fixed interval range qualifiers incorrectly dropping fields above the range's high end, causing expressions like `INTERVAL '1 2:03' HOUR TO MINUTE` to lose the day component. - Fixed date parsing to honor the `DateStyle` MDY convention, so `date '01/02/03'` now correctly parses as `2003-01-02` instead of `0001-02-03`. - Fixed array and list text output not quoting elements matching `NULL` case-insensitively, causing values like `'null'` to round-trip incorrectly as `NULL`. - Fixed interval text output spelling the months field as `month(s)` instead of `mon(s)`, which caused psycopg to silently drop all components after the months field. - Fixed `CREATE VIEW` and `CREATE MATERIALIZED VIEW` silently accepting a column name list shorter than the number of output columns. - Fixed binary-protocol time parameters outside the valid range being accepted instead of rejected with an error. - Fixed `INTERSECT` queries with many branches exhausting environmentd memory during query planning. - Fixed `DISCARD ALL` not resetting session variables to their defaults when using the extended query protocol. - Fixed `SET extra_float_digits` being accepted but having no effect on query output. Zero and negative values now limit float precision as in PostgreSQL. - Fixed out-of-range `REFRESH AT` or `ALIGNED TO` times causing a coordinator panic that dropped all client connections. - Fixed queries larger than 2 MiB terminating the client's connection instead of returning a recoverable error. - Fixed `SHOW CLUSTER REPLICAS` and `SHOW OBJECTS` returning incorrect results or missing rows when a cluster replica and a catalog item shared the same internal ID. - Fixed `UNION ALL` of record types failing with an internal error when fields differed only in nullability. - Fixed SQL Server sources with `CHAR(N)` columns using multi-byte character encodings failing to replicate correctly. - Fixed MySQL sources where dropping a table during snapshotting could jam the entire source instead of erroring only the affected table. - Fixed an `ALTER CLUSTER` without a `WITH (WAIT ...)` clause resetting the deadline of an in-flight graceful cluster reconfiguration. - Fixed `mz-deploy apply-all` failing when a cluster file references a project-defined role, because the roles phase ran after the clusters phase. - Fixed `mz-deploy compile` and `mz-deploy stage` failing with `type "text[]" does not exist` for projects whose dependencies have array-typed columns. ## v26.35.0 *Released to Materialize Cloud: 2026-07-30*
*Released to Materialize Self-Managed: 2026-07-31*
### Asynchronous Cluster Reconfiguration `ALTER CLUSTER` now runs configuration changes (such as resizing) in the background, rather than blocking until the new replica set is ready. This means you can start a reconfiguration and move on to other tasks while the process completes. Because the command is now asynchronous, you can monitor the progress of an in-flight reconfiguration using `SHOW CLUSTERS`. ```mzsql SHOW CLUSTERS; ``` ```nofmt name | replicas | activity | comment ------------+------------+------------------------------+--------- my_cluster | r1 (400cc) | reconfiguring size to 1600cc | ``` For detailed status, query [`mz_internal.mz_cluster_reconfigurations`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/system-catalog/mz_internal/index.md#mz_cluster_reconfigurations), which reports the target shape, the deadline, and the reconfiguration's lifecycle `status` (`in-progress`, then a terminal `finalized`, `timed-out`, `cancelled`, or `resource-exhausted`): ```mzsql SELECT cluster_id, status, deadline, on_timeout, target, changes FROM mz_internal.mz_cluster_reconfigurations; ``` For more information, see [`ALTER CLUSTER`: Resizing process](https://preview.materialize.com/materialize/40269/markdown-docs/sql/alter-cluster/index.md#resizing-process). ### AWS Glue Schema Registry Support for Sinks > **Public Preview:** This feature is in public preview. Kafka sinks can now use [AWS Glue Schema Registry](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#aws-glue-schema-registry) for Avro schema management, via the new `FORMAT AVRO USING AWS GLUE SCHEMA REGISTRY` syntax on [`CREATE SINK`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/kafka/index.md). With Glue now supported on both sources and sinks, you can manage your Kafka schemas end to end on AWS. ```mzsql -- Authenticate to AWS Glue through an AWS connection. CREATE CONNECTION aws_connection TO AWS ( ASSUME ROLE ARN = 'arn:aws:iam::123456789000:role/MaterializeGlue' ); CREATE CONNECTION glue_connection TO AWS GLUE SCHEMA REGISTRY ( AWS CONNECTION = aws_connection, REGISTRY = 'default-registry' ); -- Write Avro-encoded output, registering schemas with AWS Glue. CREATE SINK avro_sink IN CLUSTER my_io_cluster FROM my_materialized_view INTO KAFKA CONNECTION kafka_connection (TOPIC 'test_topic') KEY (key) FORMAT AVRO USING AWS GLUE SCHEMA REGISTRY CONNECTION glue_connection ( KEY SCHEMA NAME = 'test_topic-key', VALUE SCHEMA NAME = 'test_topic-value' ) ENVELOPE UPSERT; ``` For more information, see [`CREATE SINK`: Using AWS Glue Schema Registry](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/kafka/index.md#using-aws-glue-schema-registry). ### Kafka: Source versioning Kafka sources now support source versioning, so you can adopt upstream Avro schema changes without downtime. This uses the same mechanism already available for PostgreSQL, MySQL, and SQL Server sources, by creating a new table with the evolved schema and swapping it into place with a blue/green cutover. There is new syntax for [`CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/kafka-v2/index.md) and [`CREATE TABLE ... FROM SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/kafka/index.md) for creating and versioning tables independently. Materialize resolves the latest registered Avro schema when the `CREATE TABLE` statement runs, and pins it as the table's reader schema. For more information, refer to: - [Guide: Handling upstream schema changes with zero downtime](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/kafka/source-versioning/index.md) - [Syntax: `CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/kafka-v2/index.md) - [Syntax: `CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/kafka/index.md) ### Improvements - **Faster read queries under write load**: Read-only queries (e.g., `SELECT 1`) are no longer blocked by concurrent write transactions; under high write load, victim query latency drops from multiple seconds to single-digit milliseconds. - **Better query plans for correlated subqueries**: Queries using patterns like `1 IN (SELECT 1 WHERE p)` and `NOT EXISTS (SELECT 1 WHERE p)` are now optimized to a simple filter, eliminating unnecessary semi/anti-joins for faster queries. - **Account hierarchy billing**: Organizations running multiple Materialize accounts under one parent (e.g., separate production and staging accounts) can now see consolidated billing and usage at the parent level, broken out per child account; each child account sees only its own usage. Available on request — talk to your account executive to see if you qualify. - **`mz-debug` CPU profiling**: The `mz-debug` diagnostic tool now automatically collects CPU profiles alongside memory profiles for Self-Managed deployments. ### Bug Fixes - Fixed queries with many chained `INTERSECT` operations (e.g., 35+ inputs) exhausting environmentd memory during planning, causing the environment to become unresponsive. - Fixed a MySQL source stalling entirely when one of its tables was dropped while the initial snapshot was running; the dropped table now reports an error on its own and the rest of the snapshot proceeds. - Fixed a critical bug where a pending replacement materialized view could destroy the data of its live target materialized view after an environmentd restart. - Fixed `COPY FROM PARQUET` failing for columns of types `oid`, `time`, `timestamptz`, `char`, `varchar`, and `mz_timestamp`. - Fixed incorrect results for `variance`, `stddev`, and related aggregate functions when used with `DISTINCT` on inputs containing values that differ only in sign (e.g., `-2` and `2`). - Fixed `ALTER CLUSTER ... WITH (WAIT UNTIL READY ...)` hanging indefinitely and rolling back when the cluster hosts a single-replica source (PostgreSQL, MySQL, or SQL Server). - Fixed `mz_object_arrangement_sizes` silently omitting arrangements smaller than 10 MiB and showing stale sizes after an environmentd restart. - Fixed `EXPLAIN FILTER PUSHDOWN FOR MATERIALIZED VIEW` crashing environmentd when the materialized view's cached plan referenced a since-dropped index. - Fixed array literals with empty dimensions (e.g., `'{{},{}}'::text[]`) and multi-dimensional `array_fill` calls silently producing incorrect results instead of returning errors matching PostgreSQL behavior. - Fixed replica utilization charts in the Console failing to load on initial page render and flashing a loading spinner when switching time filters. - Fixed replica crash and OOM markers not appearing in the "Last hour" and "Last 3 hours" Console utilization chart windows. ## v26.34.1 *Released to Materialize Self-Managed: 2026-07-24*
### Asynchronous Cluster Reconfiguration *Materialize Self-Managed only* `ALTER CLUSTER` now runs configuration changes (such as resizing) in the background, rather than blocking until the new replica set is ready. This means you can start a reconfiguration and move on to other tasks while the process completes. Because the command is now asynchronous, you can monitor the progress of an in-flight reconfiguration using `SHOW CLUSTERS`. ```mzsql SHOW CLUSTERS; ``` ```nofmt name | replicas | activity | comment ------------+------------+------------------------------+--------- my_cluster | r1 (400cc) | reconfiguring size to 1600cc | ``` For detailed status, query [`mz_internal.mz_cluster_reconfigurations`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/system-catalog/mz_internal/index.md#mz_cluster_reconfigurations), which reports the target shape, the deadline, and the reconfiguration's lifecycle `status` (`in-progress`, then a terminal `finalized`, `timed-out`, `cancelled`, or `resource-exhausted`): ```mzsql SELECT cluster_id, status, deadline, on_timeout, target, changes FROM mz_internal.mz_cluster_reconfigurations; ``` For more information, see [`ALTER CLUSTER`: Resizing process](https://preview.materialize.com/materialize/40269/markdown-docs/sql/alter-cluster/index.md#resizing-process). ### Bug Fixes - Fixed an issue where `ALTER CLUSTER ... WITH (WAIT UNTIL READY ...)` would deadlock on clusters hosting single-replica sources (Postgres, MySQL, SQL Server), causing graceful reconfiguration to time out and roll back without resizing. ## v26.34.0 *Released to Materialize Cloud: 2026-07-21*
*Released to Materialize Self-Managed: 2026-07-21*
### Autoscaling to speed up hydration > **Public Preview:** This feature is in public preview. Managed clusters can now temporarily scale up to accelerate hydration. Using the `AUTO SCALING STRATEGY (ON HYDRATION)` strategy, Materialize runs an extra burst replica at the larger `HYDRATION SIZE` while the cluster's objects are un-hydrated. Once a steady-size replica hydrates, the burst replica is retired. An optional `LINGER DURATION` keeps the burst replica running for a grace period after the steady-size replicas hydrate. ```mzsql -- Create a cluster that spins up a 1600cc burst replica while hydrating CREATE CLUSTER my_cluster ( SIZE = '400cc', AUTO SCALING STRATEGY = ( ON HYDRATION (HYDRATION SIZE = '1600cc', LINGER DURATION = '600s') ) ); ``` You can add, change, or remove the strategy on an existing cluster with `ALTER CLUSTER`: ```mzsql ALTER CLUSTER my_cluster SET ( AUTO SCALING STRATEGY = (ON HYDRATION (HYDRATION SIZE = '1600cc')) ); ``` For more information, see the `AUTO SCALING STRATEGY` option on [`CREATE CLUSTER`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-cluster/index.md#autoscaling) and [`ALTER CLUSTER`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/alter-cluster/index.md#speed-up-hydration-by-autoscaling-to-a-larger-size). ### Role Mapping via SCIM *Materialize Cloud only* You can provision identity provider groups via SCIM and map their members to Materialize database roles. The revised setup described in the guide uses an explicit intermediate mapping: assign each synced group a custom organization role, then create a database role matching that organization role’s JWT key. IdP group names can differ from database role names. For setup and migration steps, see [Sync IdP groups](https://preview.materialize.com/materialize/40269/markdown-docs/security/cloud/users-service-accounts/sync-idp-groups/index.md). ### Improvements - **Azure SQL source support**: Materialize can now ingest data from Azure SQL databases using the [SQL Server source connector](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/sql-server/index.md). - **Configurable Iceberg sink commit interval**: The [commit interval](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md#commit-interval-tradeoffs) of an existing Iceberg sink can now be altered using `ALTER ... SET COMMIT INTERVAL`, with a minimum of 1 second. - **MCP query tool replica routing**: The MCP developer query tool now accepts a `cluster_replica` parameter, enabling `EXPLAIN ANALYZE` on clusters with more than one replica. - **Smaller container images**: The `environmentd` and `clusterd` container images now use a distroless base, reducing image size and attack surface for Self-Managed deployments. ### Agent Skills To start using our skills, install them with `npx skills add MaterializeInc/agent-skills`. To update your installed skills, run `npx skills update`. For more information, see [Coding agent skills](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md). - **Materialize Terraform Provider**: New agent skill covering Terraform provider configuration for Cloud and self-managed deployments, resource conventions, cross-resource patterns, import workflows, and known gotchas. - **Materialize Terraform Self-Managed**: New agent skill covering the Terraform modules for deploying self-managed Materialize on AWS, Azure, and GCP, including IAM-based storage auth, upgrade procedures, and project integration patterns. ### Bug Fixes - Fixed a critical bug where a pending replacement materialized view could destroy the data of its live target materialized view after an environmentd restart, by advancing the shared persist shard's since to the empty frontier. - Fixed a correctness bug in join processing where incoming batches could be silently dropped after trace compaction, causing lost updates without error. - Fixed multiple soundness bugs in persist filter pushdown that could silently drop matching rows or cause `persist filter pushdown correctness violation` panics. - Fixed a bug in multi-statement read transactions where a timestamp-independent first statement (e.g., a query over a constant-folded view) could cause subsequent statements to read from incorrect time domains, resulting in errors or incorrect results. - Fixed `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT` crashing the coordinator when a temporary view or index depended on the target materialized view. - Fixed non-temporary objects (views, indexes, etc.) being allowed to depend on temporary objects, which could lead to dangling references when the session ended. - Fixed stack overflow crashes in the adapter when processing environments with deeply nested object dependencies. - Fixed a stack overflow when comparing deeply nested values (e.g., deeply nested JSONB) in query result ordering. - Fixed a stack overflow when executing read-then-write statements (e.g., `INSERT INTO ... SELECT`) over deeply chained view hierarchies. - Fixed stack overflow or memory exhaustion when resolving pathologically deep or wide custom types. - Fixed a crash on diskless replicas where restarting upsert sources could encounter stale RocksDB state. - Fixed environmentd crash-looping on startup when a tombstoned persist shard was still referenced in the catalog. - Fixed `SET TRANSACTION ... READ WRITE` silently modifying session state before returning an error. - `CREATE ROLE` now rejects the reserved role specification names `current_user`, `current_role`, `session_user`, `user`, and `none`. - Fixed a user-created schema named `information_schema` bypassing the `mz_catalog_server` cluster restriction, allowing user queries to run on a reserved system cluster. - Fixed `kubectl apply --server-side` failing for Materialize v1 CRDs when managed fields were originally recorded at v1alpha1, blocking GitOps tooling in Self-Managed deployments. - Fixed the Self-Managed Console deriving the MCP server URL from the pgwire hostname instead of the HTTP endpoint, causing MCP connections to fail when pgwire and HTTP are served on separate hostnames. ## v26.33.0 *Released to Materialize Cloud: 2026-07-16*
*Released to Materialize Self-Managed: 2026-07-17*
### Improved hydration times on Materialize Cloud *Materialize Cloud only* We've upgraded cluster hardware for all Materialize Cloud environments. The new hardware speeds up compute-intensive operations. We've observed a 10%–66% reduction in hydration times. You don't need to take any actions. The improvement is live across all Materialize Cloud environments, on all new and existing clusters. ### READ COMMITTED isolation for PostgreSQL metadata databases *Materialize Self-Managed only* Starting in v26.33, self-managed deployments that use a PostgreSQL metadata database can configure Materialize to run its internal metadata queries under `READ COMMITTED` transaction isolation instead of `SERIALIZABLE`. This improves metadata write throughput. To enable this isolation mode, enable the `persist_pg_consensus_read_committed` system parameter after completing an upgrade to v26.33. > **Note:** The parameter applies only to PostgreSQL metadata databases. Only enable it > after you have upgraded your self-managed deployment to v26.33 or later. For details, see the [Self-Managed upgrade notes](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/version-notes/index.md). ### Improvements - **`EXPLAIN ANALYZE` on multi-replica clusters via MCP**: The Materialize MCP developer endpoint's `query` tool now accepts an optional cluster replica parameter, so `EXPLAIN ANALYZE` can target a specific replica. - **Faster queries on busy environments**: We've improved query latency on query-heavy clusters. We've reduced by caching the catalog snapshot for the duration of a session. In our tests, we've seen QPS improvements of up to 13%. - **Improved responsiveness under load**: A slow timestamp oracle no longer stalls unrelated sessions that are running `EXPLAIN TIMESTAMP` or `SUBSCRIBE`. - **New materialize-dbt [agent skill](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md)**: The `materialize-dbt` skill helps coding agents build and manage dbt models for Materialize. ### Bug Fixes - Fixed server crashes triggered by stack overflows while computing object dependencies and read privileges. - Fixed catalog corruption and coordinator panics triggered by `ALTER SCHEMA RENAME` when the target schema contains user-defined types, functions, or temporary objects. - Fixed a crash that could occur when a `SUBSCRIBE` ran while an index or other dependency it read was concurrently dropped; the query now returns a clean error. - Fixed a crash triggered by binding a non-UTF-8 `char` parameter over the extended query protocol. - Calling `mz_any` or `mz_all` with a non-boolean argument now returns a planning error instead of crashing a compute worker. - Polymorphic array functions such as `array_remove` now return a planning error instead of dropping the connection when an argument would produce an array of `list` or `map`. - Fixed a class of crashes where cancelling or tearing down a statement (for example, `DROP CLUSTER`) while it was being dispatched could abort the server. - Fixed a crash where scraping the usage metrics endpoint could abort the server when an unmanaged cluster replica was present. - Fixed queries with nested, shadowed common table expressions returning incorrect results. - Fixed queries that reference a correlated CTE from a nested correlated scope returning incorrect results. - Fixed `SHOW COLUMNS` returning duplicate rows for certain system catalog objects after upgrading across releases. - Query results that fit within `max_result_size` are no longer incorrectly rejected by an over-counted memory estimate. - `DROP SCHEMA` without `CASCADE` no longer silently drops a schema that contains only user-defined types or functions; it now correctly treats the schema as non-empty. - Casting large OID values from text (`2147483648` through `4294967295`) and copying into `oid` columns no longer fail with an invalid-input error. - `NUL` bytes supplied to text values through query parameters, the HTTP SQL API, `COPY FROM`, and `convert_from` are now rejected, matching PostgreSQL. - A `COPY` that fails before entering copy mode no longer corrupts or hangs the connection for clients such as pgx and libpq. - `RESET` and `DISCARD ALL` now restore client-supplied startup parameters, such as the connected database, rather than server defaults, fixing connection poolers that rebound pooled sessions to the wrong database. - Fixed PostgreSQL sources so that upgrades correctly handle `oid` values above the signed 32-bit range instead of leaving replication stuck. - Fixed PostgreSQL sources that exclude a column erroneously halting when the excluded column and its constraint were dropped upstream. - Kafka source and sink metadata refresh intervals below one second are now rejected, and existing definitions with smaller values are migrated automatically on upgrade. - `COPY FROM` can now read array columns from Arrow files that were written by `COPY TO`. - `GRANT` and `REVOKE USAGE ON ALL POLICIES` now correctly grant and revoke network-policy privileges instead of silently succeeding as a no-op. - Fixed the system administrator role being unable to invoke certain side-effecting functions, such as terminating backend sessions. - Closed a resource-isolation gap that allowed `INSERT ... SELECT` and `COPY ... TO ` reads of user objects to run on the reserved `mz_catalog_server` cluster. - Fixed inline credentials in `CREATE CONNECTION` options being written in clear text to redacted SQL and telemetry. - Error messages that include connection URLs now redact embedded credentials instead of exposing the username and password. ## v26.32.0 *Released to Materialize Cloud: 2026-07-09*
*Released to Materialize Self-Managed: 2026-07-10*
### Improvements - **`COPY TO` replica routing**: `COPY TO` now honors the session's `cluster_replica` setting, matching the behavior of regular `SELECT` queries. ### Agent Skills - **MCP Developer Analysis**: Updated to document the developer `query` tool and `EXPLAIN ANALYZE` workflow for querying user objects on named clusters. ### Bug Fixes - Fixed internal HTTP endpoints not enforcing role-based authorization in Self-Managed deployments with password or OIDC authentication, allowing any authenticated user to access internal administration routes. - Fixed `CREATE REPLACEMENT MATERIALIZED VIEW ... FOR ` not requiring ownership of the target view, allowing another role to block the owner from using the replacement workflow on their own object. - Fixed secret values potentially appearing in `mz_internal.mz_statement_execution_history` error messages when `CREATE SECRET` or `ALTER SECRET` commands failed. - Fixed `COMMENT` bodies and `PARTITION BY` option values not being redacted in redacted SQL output, leaking user-provided text across the redaction boundary. - Fixed float-to-integer casts silently accepting out-of-range boundary values instead of raising errors, affecting `float4`-to-`uint32`/`uint64` and `float8`-to-`uint8` conversions. - Fixed narrowing integer casts (`uint4` to `uint2`, `smallint`, or `integer`) silently filtering out rows with out-of-range values instead of raising errors when used in indexed filter expressions. - Fixed incorrect results when casting arrays between element types. - Fixed `varchar` columns reporting incorrect column type metadata. - Fixed read-only transactions incorrectly accepting write operations after a constant expression peek (e.g., `SELECT 1`), which could silently commit data or cause panics on subsequent writes. - Fixed a priority inversion where sustained strict-serializable reads could stall the coordinator by starving group commit, causing the environment to appear stuck until clients disconnected. - Fixed coordinator stalls when granting privileges to many roles in a single transaction. - Fixed `generate_series` entering an infinite loop when called with a timestamp interval that mixes months and days in a way that prevents forward progress (e.g., `INTERVAL '1 month -29 days'`). - Fixed `mz_sleep` panicking on invalid input values instead of returning an error. - Fixed stale query cancellations from a previous statement incorrectly canceling the next statement within an explicit transaction. - Fixed `ALTER CLUSTER ... WITH (WAIT FOR ...)` and `WITH (WAIT UNTIL READY ...)` being silently accepted and ignored on unmanaged clusters instead of returning an error. - Fixed `SUBSCRIBE` returning an internal error code (`XX000`) instead of the standard "undefined object" code (`42704`) when referencing a non-existent object. - Fixed `TopK` query optimization losing `expected_group_size` hints during operator fusion, causing unnecessary overhead in query execution. - Fixed `app.kubernetes.io/name` label missing from environmentd Kubernetes resources when using the `v1alpha1` CRD. ## v26.31.2 *Released to Materialize Self-Managed: 2026-07-08*
### Bug Fixes - Fixed a priority inversion bug where sustained strict-serializable / real-time-recency reads could starve group commit, leading to livelock in the database coordinator. This would cause queries to hang until pending reads drained. ## v26.31.0 *Released to Materialize Cloud: 2026-07-02*
*Released to Materialize Self-Managed: 2026-07-03*
### AWS Glue Schema Registry Support Kafka sources can now use AWS Glue Schema Registry for Avro schema management via the new `FORMAT AVRO USING AWS GLUE SCHEMA REGISTRY` syntax. This is an alternative to the Confluent Schema Registry, enabling organizations that standardize on AWS Glue to connect their Kafka topics to Materialize without switching schema registries. ### Materialize CRD v1 for Self-Managed Self-managed Kubernetes deployments can now opt in to the v1 Materialize Custom Resource Definition (`materialize.cloud/v1`). The v1 CRD simplifies rollout behavior: rollouts trigger automatically when spec fields change, so you no longer need to set a new `requestRollout` UUID on every change. Adopting `v1` is opt-in, and existing `v1alpha1` deployments continue to work unchanged. For more information, see the [Self-Managed upgrade notes](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/index.md). ### OAuth sign-in for MCP servers The `materialize-agent` and `materialize-developer` MCP servers now support OAuth (browser-based) sign-in, so MCP-compatible clients such as Claude Code, Claude Desktop, and Cursor can authenticate through your browser instead of a Base64-encoded token. With OAuth, the client connects as your own user role with your existing privileges. For more information, see [MCP Server for Agents](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-agent/index.md) and [MCP Server for Developers](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md). ### Improvements - **Faster `count(*)` over `generate_series`**: Queries like `SELECT count(*) FROM generate_series(1, N)` now evaluate in constant time instead of materializing all rows. - **System parameter override introspection**: Added `mz_internal.mz_overridden_system_parameters`, a catalog view that lists environment-wide system parameter overrides set via `ALTER SYSTEM`, readable by all users. - **Kubernetes resource labels for Self-Managed**: Standard `app.kubernetes.io/*` labels are now applied to all Kubernetes resources (pods, services, statefulsets, deployments) managed by the operator. ### Bug Fixes - Fixed `ALTER CONNECTION ... ROTATE KEYS` silently dropping concurrent `ALTER CONNECTION SET` changes when both commands ran at the same time. - Fixed `COPY INTO` not respecting the target table's numeric precision, causing incorrect decimal values in downstream sinks. - Fixed the optimizer panicking when a scalar subquery's body was provably empty, producing a count of zero. - Fixed an overflow in array cardinality calculation when dimension lengths multiply to exceed the maximum integer value. - Fixed multiple panics during proto/Row and persist state decoding when encountering malformed input, improving availability against corrupted data. - Fixed Iceberg sinks accumulating the entire source snapshot in memory during hydration instead of flushing incrementally. - Fixed the MCP `restrict_to_user_objects` guard being bypassed for deferred plans, allowing restricted MCP connections to access system catalog objects. - Fixed Console password authentication breaking when the cached OIDC token expires, causing all subsequent requests to fail with "authentication credentials have expired." - Fixed PostgreSQL source creation panicking when excluded columns include primary key columns. - Fixed SQL parenthesization errors in `SHOW CREATE` output that could cause the generated SQL to fail to reparse. - Fixed replicas doubling in memory during zero-downtime upgrades due to unbounded correction buffer growth in read-only materialized view sinks. ## v26.30.1 *Released to Materialize Cloud: 2026-06-25*
*Released to Materialize Self-Managed: 2026-06-26*
### PostgreSQL Physical Replica Support Materialize now supports replicating from a physical PostgreSQL replica (hot standby), not just the primary server. This lets you offload replication load from the primary to a read replica. Connecting to a physical replica requires PostgreSQL 16 or later. If the replica is promoted to primary, the source fails and must be recreated, consistent with how Materialize handles a primary failover today. For more information, see [CREATE SOURCE: PostgreSQL](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/postgres-v2/index.md). ### MCP Developer Query Tool The MCP server for developers now includes a `query` tool for running `SELECT`, `SHOW`, and `EXPLAIN` queries against user objects and clusters, mirroring the agent endpoint's query capability. ### Advisory - **MySQL zero-value YEAR columns**: This release changes how the MySQL source decodes zero-value `YEAR` columns (`0000`). Previously, zero values were decoded inconsistently: as `0` during the initial snapshot and as `1900` (an invalid year) from the binlog. Both are now decoded as the 4-digit string `0000`, matching MySQL's own representation. Non-zero years (1901–2155) are unaffected. **Upgrade impact**: If you replicate a `YEAR` column that can hold zero values, rows ingested before the upgrade retain their old representation (`0` or `1900`) until the upstream row is modified and re-decoded. To make all rows consistent and avoid potential source errors, drop and recreate the affected source (or subsource/table) after upgrading. Sources without zero-value `YEAR` data require no action. ### Improvements - **mz-debug OIDC and SASL authentication**: The `mz-debug` diagnostic tool now supports OIDC and SASL authentication modes in addition to password authentication. - **Faster LIKE pattern matching**: `LIKE` patterns with multiple `%` wildcards (e.g., `%a%a%a`) no longer exhibit super-linear matching time against long strings, while common patterns like `%substring%` remain on the fast string matcher. - **Fivetran Destination restored**: The Fivetran Destination integration, which was removed in v26.29.0, has been restored. - **Self-managed monitoring docs refreshed**: Self-managed deployments now have a published reference of the metrics Materialize exposes: [essential metrics](https://preview.materialize.com/materialize/40269/markdown-docs/observability/essential-metrics/index.md) and an [appendix of all metrics](https://preview.materialize.com/materialize/40269/markdown-docs/observability/appendix-metrics/index.md). The self-managed monitoring guides for [Prometheus and Grafana](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/grafana/index.md) and [Datadog](https://preview.materialize.com/materialize/40269/markdown-docs/observability/self-managed/datadog/index.md) have been refreshed with updated scrape configurations and dashboards. ### Bug Fixes - Fixed `IS [NOT] DISTINCT FROM` binding too loosely relative to `AND`/`OR`, causing `a IS DISTINCT FROM b AND c` to silently produce wrong results by parsing as `a IS DISTINCT FROM (b AND c)` instead of `(a IS DISTINCT FROM b) AND c`. - Fixed the query optimizer incorrectly propagating errors through `AND`/`OR` expressions, causing queries like `false AND ` to produce an error instead of returning `false`. - Fixed `GRANT ALL ON TABLE` and `REVOKE ALL ON TABLE` on views, materialized views, and sources only granting or revoking `SELECT` instead of the full table privilege set (`SELECT`, `INSERT`, `UPDATE`, `DELETE`). - Fixed MySQL sources incorrectly decoding zero-value `YEAR` columns during both snapshot and replication. - Fixed Avro-formatted sources failing to decode records after a nullable column's type was promoted to a wider numeric type (e.g., `int` to `double`). - Fixed `array_fill` incorrectly rejecting arrays between 128 MB and 256 MB due to an operator precedence bug in the size limit calculation. - Fixed `pg_catalog.pg_description` returning an error when any user object was named `pg_class`, `pg_type`, or `pg_namespace`. - Fixed CSV source ingestion crashing or silently producing corrupted rows when encountering malformed input. - Fixed `EXPLAIN ANALYZE` and `EXPLAIN ANALYZE CLUSTER` silently dropping every-other worker's results. - Fixed a panic when a `GROUP BY` clause repeated a positional column reference, such as `GROUP BY 1, 1`. - Fixed a panic when resizing a managed cluster that hosts a replica-targeted materialized view with a `COMMENT`. - Fixed a panic when decoding binary-format `numeric` values with an out-of-range scale in the wire header. - Fixed a panic when specifying out-of-range interval values in `WITH` options such as `INTROSPECTION INTERVAL` or `REFRESH EVERY`. - Fixed a panic when casting `regtype`, `regclass`, or `mz_aclitem` to text in contexts that disallow subqueries, such as a `RETURNING` clause. - Fixed a panic when setting a non-`MANUAL` schedule on a cluster with `REPLICATION FACTOR > 1`. - Fixed a crash when using `COPY FROM` with a URL or S3 source without specifying a format, or with an unsupported format like `TEXT` or `BINARY`. - Fixed table functions silently accepting unsupported `FILTER`, `OVER`, and `DISTINCT` clauses instead of returning an error. - Fixed `COPY TO STDOUT` silently accepting unsupported `ESCAPE` and `HEADER` options instead of returning an error. - Fixed `SHOW CREATE TABLE ... FROM SOURCE` emitting internal options that prevented the output from being replayed. - Fixed `SHOW CREATE TABLE` failing to round-trip for SQL Server and load generator sources due to incorrect database references. - Fixed multiple SQL parser and pretty-printer bugs that caused `SHOW CREATE` output to fail to reparse, including incorrect keyword quoting and operator precedence in displayed expressions. - Fixed Avro source ingestion crashing when encountering malformed input such as invalid block lengths, unbounded recursion, or unmatched schema references. - Fixed `COPY FROM STDIN` being able to exhaust the shared connection pool by holding blocking threads idle, which could stall all other queries in the environment. - Fixed a panic when creating a Kafka sink with a non-positive `TOPIC METADATA REFRESH INTERVAL`. - Fixed a panic when a Kafka topic refresh interval was set to less than 1 second. - Fixed the MCP `read_data_product` tool failing when the `restrict_to_user_objects` option was enabled. ## v26.29.0 *Released to Materialize Cloud: 2026-06-18*
*Released to Materialize Self-Managed: 2026-06-19*
### Bounded Staleness Isolation Level > **Public Preview:** This feature is in public preview. Bounded staleness is a new SQL isolation level that lets you set a freshness target for your queries. For example, you can configure a session to only serve data that is at most 10 seconds stale. If sufficiently fresh data is unavailable, the query immediately returns an error (`SQLSTATE 40001`) rather than blocking. This positions bounded staleness between [Serializable](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#serializable) and [Strict Serializable](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#strict-serializable): it never blocks on input frontiers, but errors immediately when the staleness bound cannot be met. Bounded staleness is read-only and can be set at the session or connection level. ```mzsql -- Serve data no more than 10 seconds stale; error immediately if unavailable. SET TRANSACTION_ISOLATION TO 'bounded staleness 10s'; ``` For more information, see [Bounded Staleness](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/isolation-level/index.md#bounded-staleness). ### mz-deploy (v0.1) [mz-deploy](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mz-deploy/index.md) is a new CLI for declarative Materialize deployments. You can use mz-deploy to define sources, views, indexes, clusters, and other Materialize objects as code—and so can your coding agents. Projects compile locally with no running Materialize instance required: run unit tests, inspect query plans, and validate changes entirely inside a sandbox before touching a shared environment. Built in Rust, mz-deploy cold-compiles a project with 40,000+ models in under 500ms, with most incremental changes compiling in under 10ms. Deployments only redeploy changed objects, support blue-green deployments, and allow concurrent deployments with conflict detection at promote time. For instance, to create a new Materialize project called `order-monitoring`: ```bash mz-deploy new order-monitoring ``` This scaffolds the following directory structure: ```nofmt order-monitoring/ ├── models/ │ └── materialize/ │ └── public/ # SQL files → materialize.public. ├── clusters/ # Cluster definitions ├── roles/ # Role definitions ├── network-policies/ # Network policy definitions ├── project.toml # Project configuration ├── README.md └── .gitignore ``` For more information, see [mz-deploy](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mz-deploy/index.md). ### Iceberg Sinks for Google Cloud Platform Iceberg sinks can now deliver data into [GCP Lakehouse](https://docs.cloud.google.com/lakehouse/docs/introduction) managed Iceberg tables. A new `GCP` connection type handles Google service account credentials, enabling Materialize to authenticate with BigLake's Iceberg REST catalog. ```mzsql -- Create a GCP service account connection CREATE CONNECTION gcp_connection TO GCP ( SERVICE ACCOUNT KEY = SECRET gcp_sa_key ); -- Create an Iceberg catalog connection using BigLake CREATE CONNECTION biglake_catalog TO ICEBERG CATALOG ( CATALOG TYPE = 'rest', URL = 'https://biglake.googleapis.com/iceberg/v1/restcatalog', GCP CONNECTION = gcp_connection, WAREHOUSE = 'gs://my-gcs-bucket' ); -- Create an Iceberg sink writing into a GCP Lakehouse managed Iceberg table CREATE SINK my_gcp_iceberg_sink IN CLUSTER sink_cluster FROM my_materialized_view INTO ICEBERG CATALOG CONNECTION biglake_catalog ( NAMESPACE = 'my_namespace', TABLE = 'my_table' ) KEY (id) MODE UPSERT WITH (COMMIT INTERVAL = '60s'); ``` For more information, see [Syntax: CREATE SINK... INTO ICEBERG](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md). ### Improvements - **Correct SQLSTATEs for evaluation errors**: Evaluation errors such as division by zero, out-of-range casts, and invalid input now return their correct PostgreSQL-standard SQLSTATE codes instead of the generic `XX000` (internal error). - **PostgreSQL-compatible binary encoding diagnostics**: When a type has no binary output function (e.g., `list`, `map`, `aclitem`), Materialize now returns PostgreSQL's `SQLSTATE 42883` with the message `no binary output function available for type `. ### Bug Fixes - Fixed a panic when a cluster is dropped concurrently with statement execution on that cluster. - Fixed stack overflows on deeply nested query expressions by converting expression visitors to iterative traversals. - Fixed a panic when using `COPY ... TO STDOUT WITH (FORMAT binary)` on types without binary encoding support, including `list`, `map`, `aclitem`, and records or arrays containing these types. - Fixed a panic when specifying `TEXT COLUMNS` with an empty list. - Fixed a panic when specifying `EXCLUDE COLUMNS` with an empty list. - Fixed `oidc_group_claim` and `oidc_group_role_sync_strict` being incorrectly modifiable by environment superusers via `ALTER SYSTEM SET`; these parameters now correctly require `mz_system` access. - Fixed a stack overflow when using Avro schemas with recursive references in maps. - Fixed data corruption in MySQL sources when a table is dropped and immediately recreated with the same name and a compatible schema. - Fixed HTTP health probes (`/api/livez`, `/api/readyz`) and the metrics endpoint failing when the coordinator is unhealthy in deployments with OIDC authentication. - Fixed a crash caused by duplicate statement execution logging that could bring down the entire environment. - Fixed array values failing to write to Iceberg sinks due to the array dimension being stored as a narrower integer type than Iceberg requires. ## v26.28.0 *Released to Materialize Cloud: 2026-06-11*
*Released to Materialize Self-Managed: 2026-06-12*
### Improvements - **Improved performance using temporal filters**: We've made a second round of improvements to temporal filter performance. Steady state CPU usage while using temporal filters is significantly reduced; we saw a drop from 75% CPU to 4% CPU in internal tests. - **Multi-item `DROP` with dependencies**: `DROP` statements now succeed when multiple co-dependent items are named in the same command, matching PostgreSQL behavior. - **Self-Managed OIDC configuration**: Environment superusers can now configure `oidc_group_claim` and `oidc_group_role_sync_strict` via `ALTER SYSTEM SET` without requiring `mz_system` access. - **OIDC group claim nested paths**: OIDC group claims now support dot-separated paths (e.g., `groups.materialize`) for navigating nested JWT structures. - **Self-Managed Console connection info**: The Console in self-managed deployments now displays the actual balancerd hostname in the OIDC and MCP connection dialogs. - **Password redaction in system catalog**: `pg_catalog.pg_user.passwd` now returns `'********'` instead of the actual password hash, matching PostgreSQL behavior. ### Bug Fixes - Fixed Kafka sources appearing healthy after a low-watermark data-loss error by preventing automatic restarts that masked the stalled state. - Fixed Kafka sources becoming unhealthy and producing stale data due to transient connection failures when fetching low watermarks. - Fixed Kafka sinks using upsert envelope becoming permanently stale when a concurrent writer advanced the output shard. - Fixed `generate_subscripts` returning incorrect results for arrays with custom lower bounds. - Fixed `array_lower` and `array_upper` returning incorrect results for arrays with custom lower bounds. - Fixed `SUM(float8)` returning incorrect results when summing large finite values. - Fixed `date_bin` returning incorrect results for timestamps exactly on a bin boundary before the origin. - Fixed `INSERT INTO ... SELECT` queries being incorrectly classified as constant, potentially producing wrong results. - Fixed `SHOW CREATE SINK` including an internal version number that prevented the output from being used to recreate the sink. - Fixed MCP `read_data_product` failing when the role lacks `USAGE` privilege on the data product's cluster; the tool now falls back to the default cluster instead. - Fixed a panic when setting `statement_timeout` or similar duration parameters with Unicode numeric characters. - Fixed a panic when calling `pg_cancel_backend(NULL)`; now returns `NULL` to match PostgreSQL behavior. - Fixed a crash when using `SUBSCRIBE` with duplicate columns in the key; now returns a clear error. - Fixed a crash when using `CREATE TABLE ... FROM SOURCE` with only constraints and no explicit columns. - Fixed a panic when setting `default_timestamp_interval` to `0`; now returns an error. - Fixed cluster size options appearing in incorrect order in the Console. ## v26.27.0 *Released to Materialize Cloud: 2026-06-04*
*Released to Materialize Self-Managed: 2026-06-05*
This release includes improvements to the MCP Server for Agents, general improvements, and bug fixes. ### MCP Server for Agents We've made several improvements to our MCP Server for Agents, which can be used to give agents in production fresh context from Materialize. - **`query` tool enabled by default**: The MCP Server for Agents now enables the [`query` tool](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-agent-tools/index.md#query) by default, allowing agents to join across data products. - **Data product routing**: The `read_data_product` tool now automatically routes queries to the data product's catalog cluster, eliminating the need to specify the cluster manually. - **Data product hydration status**: The MCP Server for Agents now surfaces hydration readiness state for data products, enabling agents to check whether a data product is fully hydrated before querying. For more information, refer to: - [MCP Server for Agents](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-agent/index.md) ### Improvements - **Improved `EXPLAIN` output**: Default `EXPLAIN` output now uses cleaner formatting for joins and explicitly identifies cross joins. ### Bug Fixes - Fixed the Console in self-managed deployments not displaying the balancerd hostname in the connection dialog. - Fixed incorrect query results from filter pushdown when using timestamp or date arithmetic with interval values. - Fixed incorrect query results from filter pushdown when using `CASE` expressions over JSON columns with keys present in only one branch. - Fixed `LATERAL` subqueries with table functions returning wrong results when the input table has an index on a non-leading column. - Fixed `COPY FROM` CSV decoding silently treating quoted `NULL` markers as SQL `NULL` and dropping rows after a quoted end-of-copy marker. - Fixed a panic when applying a timezone offset to a near-maximum timestamp value. - Fixed a panic when applying a timezone offset to a leap-second timestamp value. - Fixed a panic when a replica targeted by `CREATE MATERIALIZED VIEW ... IN CLUSTER ... REPLICA ` was concurrently dropped. - Fixed a panic when specifying a `REFRESH` interval shorter than 1 millisecond; now returns a clear error instead. - Fixed SSH tunnel connections to HTTPS schema registries failing with TLS handshake errors when the URL omitted the default port. - Fixed Iceberg sink errors when writing tables with `smallint` columns, map-typed columns, or `range`-typed equality delete keys. - Fixed `SHOW CREATE` incorrectly displaying passwords and `AS OF` clauses. ## v26.26.0 *Released to Materialize Cloud: 2026-05-28*
*Released to Materialize Self-Managed: 2026-05-29*
This release includes Single Sign-On (SSO) for Self-Managed, a new Objects page in the Console, performance improvements, and bug fixes. ### Single Sign-On (SSO) for Self-Managed > **Public Preview:** This feature is in public preview. Self-managed deployments can now configure single sign-on via any OIDC-compliant identity provider (Okta, Microsoft Entra ID, Auth0, Keycloak). Users authenticate via their IdP and receive a JWT token that Materialize validates; new users are auto-provisioned as database roles on first login, and existing users with matching emails map automatically to their current accounts. Enabling SSO is backward compatible: password-based auth continues to work for applications and service accounts. For more information, refer to: - [Single sign-on (SSO)](https://materialize.com/docs/security/self-managed/sso/) ### Objects page The Console includes a new Objects page, which provides a unified view of all sources, materialized views, indexes and sinks. You can track real-time freshness metrics, hydration status, and cluster assignments. If an object is stale, you can diagnose why. If lag is inherited from upstream, you can visualize the critical path. And if an object itself is the cause of lag, you can diagnose the root cause. ### Improvements - **More performant temporal filters**: We've significantly improved the performance of temporal filters. While specific results will vary by workload, in our tests we saw CPU utilization drop from 75% to 4% on workloads dominated by temporal filter evaluation. - **Faster DDL at scale**: DDL operations (`CREATE TABLE`, `DROP TABLE`, etc.) are now up to 65% faster in environments with many objects by eliminating a per-table loop that previously ran on every group commit. - **Faster storage usage collection**: Periodic storage usage collection is now up to 17x faster at 10,000 shards, reducing coordinator stalls from ~500ms to ~30ms per cycle. - **`dbt-materialize`: `PARTITION BY` support**: Added a `partition_by` config option for materialized views, generating the `PARTITION BY (...)` clause in `CREATE MATERIALIZED VIEW`. - **`dbt-materialize`: Unmanaged cluster support for blue/green deployments**: The `deploy_init` macro now supports unmanaged clusters by cloning each replica's size and availability zone, enabling blue/green deployments for environments not using managed clusters. ### Bug Fixes - Fixed wrong results for `JOIN ... USING (col) AS t` with `RIGHT` or `FULL` joins. - Fixed `round()` producing `-0` for negative fractional values that round to zero, causing mismatches in `DISTINCT`, `UNION`, and `GROUP BY`. - Fixed `list_length_max` returning incorrect results for list-of-lists with `NULL` siblings before non-`NULL` sublists. - Fixed incorrect query results when casting `text` to `"char"` or `bytea` in index lookups and equality filters. - Fixed incorrect query results when casting `text` to `name` or `varchar(n)` in contexts that rely on uniqueness, such as `DISTINCT` or joins. - Fixed MySQL sources failing to decode `TIMESTAMP` and `DATETIME` columns when using `TEXT COLUMNS`. - Fixed `COPY FROM ... (FORMAT PARQUET)` producing range values that did not compare equal to logically-identical values constructed in SQL. - Fixed missing audit log entries for `ALTER TABLE ADD COLUMN` and `ALTER SOURCE ... SET (TIMESTAMP INTERVAL)`. - Fixed the Console Data Explorer page intermittently failing to load due to a WebSocket connection race condition. ## v26.25.0 *Released to Materialize Cloud: 2026-05-21*
*Released to Materialize Self-Managed: 2026-05-22*
This release includes source versioning for MySQL sources, improvements, and bug fixes. ### MySQL: Source versioning > **Public Preview:** This feature is in public preview. For MySQL sources, we've introduced new syntax for [`CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/mysql-v2/index.md) and [`CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md). This allows you to better handle schema changes in your source MySQL tables. > **Note:** - Changing column types is currently unsupported. For more information, refer to: - [Guide: Handling upstream MySQL schema changes with zero downtime](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/source-versioning/index.md) - [Syntax: `CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/mysql-v2/index.md) - [Syntax: `CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md) ### Improvements - **Source versioning in public preview**: Source versioning helps you handle upstream schema changes without downtime in Materialize. With v26.25, source versioning has graduated from private preview to public preview, and is now available by default across all environments. For more information, refer to the source versioning guides: - [PostgreSQL](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/source-versioning/index.md) - [MySQL](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/mysql/source-versioning/index.md) - [SQL Server](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/sql-server/source-versioning/index.md) ### Bug Fixes - Fixed dependents of replica-targeted materialized views being left in an inconsistent state when the target replica is dropped, causing subsequent queries against those dependents to fail. - Fixed `ALTER CLUSTER ... SET (SIZE, WORKLOAD CLASS) WITH (WAIT FOR ...)` silently dropping the workload class change during zero-downtime reconfiguration. - Fixed `CREATE TABLE FROM SOURCE` retaining the old source name in the stored definition after the source is renamed. - Fixed `ALTER CONNECTION IF EXISTS` notice reporting the wrong object type. - Fixed ambiguous column names being silently accepted in sink `KEY` clauses instead of returning an error. - Fixed a panic during query optimization when `EXPECTED GROUP SIZE` is set to `0`. - Fixed real-time recency timeout and dropped-object errors returning generic error messages instead of the correct SQL error codes and descriptions. - Fixed Kafka sources hanging indefinitely when the start offset no longer exists due to topic retention or compaction. - Fixed `EXPLAIN` plans omitting join projections, making some join closures appear as identity when they were not. - Fixed Self-Managed replica scheduling when `availability_zones` is set, where `minDomains` could leave additional replicas stuck in a pending state. ## v26.24.3 *Released to Materialize Self-Managed: 2026-05-20*
This patch release fixes a MySQL source ingestion bug. ### Bug Fixes - Fixed MySQL sources failing to decode `TIMESTAMP` and `DATETIME` columns ingested via `TEXT COLUMNS`. Zero-value timestamps (`0000-00-00 00:00:00`) continue to require `TEXT COLUMNS` plus a `CAST` in user queries. ## v26.24.2 *Released to Materialize Self-Managed: 2026-05-18*
This patch release extends the v26.24.0 catalog migration repair to cover additional edge cases. ### Bug Fixes - Extended the v26.24.0 catalog migration repair to also clear residual negative multiplicities and normalize Role rows still stored in the pre-v81 byte form. ## v26.24.1 *Released to Materialize Cloud: 2026-05-14 on as-needs basis*
This patch release adds configurable Kafka sink message and batch size limits. ### Improvements Configurable Kafka sink size limits: The maximum size of individual Kafka sink messages and message batches can now be configured beyond their previous defaults. ## v26.24.0 *Released to Materialize Cloud: 2026-05-14*
This release introduces the built-in MCP server for agents, improvements, and bug fixes. ### MCP Server for Agents > **Public Preview:** This feature is in public preview. Give your agents fresh context using Materialize. Materialize environments now include a built-in Model Context Protocol (MCP) [server for agents (`/api/mcp/agent`)](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-agent/index.md). Once connected, an agent can discover your data products, understand the underlying data ontology, and run queries to fetch fresh data. Agents can discover [materialized views](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-materialized-view/index.md) or [indexed](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-index/index.md) views. You can use [comments](https://preview.materialize.com/materialize/40269/markdown-docs/sql/comment-on/index.md) to document the data products, and describe them to agents. Agents authenticate as [roles](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-role/index.md) in Materialize, so [RBAC privileges](https://preview.materialize.com/materialize/40269/manage/access-control/) govern which data products are visible. Finally, you can set up a dedicated [cluster](https://preview.materialize.com/materialize/40269/markdown-docs/fundamentals/concepts/clusters/index.md) for your agents, so they're isolated from the rest of your environment. The MCP server for agents complements the [MCP server for developers](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md) released in v26.20.2. The developer server gives coding agents (like Claude Code) access to Materialize's observability so you can build on Materialize faster; the agent server gives production agents fresh, governed context from your data products. For more information, refer to: - [Integrations: MCP Server for Agents](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-agent/index.md) ### Improvements - **`dbt-materialize` connection overrides**: The dbt adapter now supports passing custom connection options via the `options` field in `profiles.yml`, enabling OIDC authentication and other advanced connection configurations. - **`COPY FROM` rejects HTTP redirects**: `COPY FROM` now returns a clear error if the target URL responds with an HTTP redirect, preventing unexpected data sources and potential security issues. - **[Agent skills](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md) — improved `mcp-developer-analysis` client setup**: The skill now includes a comprehensive playbook for connecting MCP-capable clients (Claude Code, Cursor, VS Code, Zed, Continue, Windsurf, Claude Desktop) to the [MCP server for developers](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md). ### Bug Fixes - Fixed MySQL sources with RDS IAM authentication failing when the database username contains special characters like `&` or `#`. - Fixed joins incorrectly failing with a type mismatch error when join columns differed only in nullability. - Fixed fast-path `SELECT` queries returning incorrect results when `OFFSET` was specified. - Fixed `string_to_array` returning incorrect results when `null_string` is specified and the delimiter is empty. - Fixed `INSERT INTO ... SELECT` silently ignoring the `OFFSET` clause in the source query. - Fixed `seahash` function catalog metadata reporting the wrong return type (`uint4` instead of `uint8`). - Fixed `mz_egress_ips` storing non-canonical CIDR notation (e.g., `10.0.5.7/24` instead of `10.0.5.0/24`). - Fixed Console crashing on OIDC-protected routes when the identity provider initialization fails, instead of falling through to password-based sign-in. - Fixed catalog migration bug from v26.18.0 by which a `Non-positive multiplicity in DistinctBy` error could occur on queries containing `SELECT DISTINCT` over role-derived catalog views (e.g., anything reading from `mz_roles`, `mz_role_members`, or views that internally project role columns). The error is resolved automatically by upgrading to v26.24.2 or newer. ## v26.23.2 *Released to Materialize Cloud: 2026-05-11*
This patch release includes bug fixes. ### Bug Fixes - Fixed a regression in v26.23.0 that caused storage replicas to spend a large share of their CPU time walking small data fragments during Parquet decode, slowing queries that read from object storage. - Fixed a regression in v26.23.0 that caused storage replicas to retain extra memory when reading from object storage. ## v26.23.0 *Released to Materialize Cloud: 2026-05-07*
This release introduces enhanced Kafka PrivateLink routing options, security improvements, and bug fixes. ### Features - **Dynamic Kafka brokers with AWS PrivateLink**: Kafka connections can now route dynamically discovered brokers through a PrivateLink tunnel, rather than requiring every advertised broker to be enumerated in the `BROKERS (...)` clause. Two new options are available: - `MATCHING 'pattern' USING AWS PRIVATELINK conn (...)` inside `BROKERS (...)` associates a PrivateLink connection with any broker whose advertised hostname matches `pattern`, including brokers that only appear in Kafka metadata after the connection is established. - `BOOTSTRAP BROKER 'addr' USING AWS PRIVATELINK conn (...)` pins the initial bootstrap address to an explicit PrivateLink tunnel. Together, these resolve availability-zone mismatches that previously affected MSK and other Kafka clusters that rely on broker discovery, by ensuring every broker, including those learned from metadata, is reached through a PrivateLink endpoint in the broker's own AZ. Refer to our documentation on [AWS PrivateLink connections](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/network-security/privatelink/index.md) and the [Kafka `CREATE CONNECTION` PrivateLink syntax](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#kafka-privatelink-syntax) for more information. ### Improvements - **New `repeat_row_non_negative` SQL function**: The new `repeat_row_non_negative` table function generates a specified number of rows but errors on negative input rather than silently producing incorrect results, making it safer to use in general-purpose queries than the existing `repeat_row`. - **Queries fail gracefully on internal errors**: Certain internal errors that previously caused `environmentd` to crash now return a query error instead, improving cluster stability. - **dbt deploy retries on concurrent DDL conflicts**: `dbt deploy` now automatically retries the `ALTER SWAP` atomic deployment when it encounters a DDL interrupt from concurrent catalog operations, preventing spurious deployment failures in busy environments. - **Clearer temporal filter error messages**: Error messages for unsupported temporal predicates now include the actual filter expression, making it easier to identify and fix the offending query. - **`COPY TO S3` Parquet type validation at planning time**: `COPY TO S3` with `FORMAT PARQUET` now rejects Parquet-incompatible column types (such as `interval`) at query planning time with a clear error, rather than failing at execution time with an opaque message. - **`mcp-developer-analysis`**: A new [coding agent skill](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/coding-agent-skills/index.md) that pairs with the `/api/mcp/developer` endpoint to provide diagnostic workflows, system catalog references, and remediation runbooks for AI-powered troubleshooting. - **System catalog ontology for the MCP developer server**: The system catalog now exposes an ontology that describes how `mz_*` tables relate to one another and which tables to consult for common diagnostic questions. The [MCP server for developers](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md) uses this ontology to plan catalog queries directly instead of probing the schema, reducing the number of round trips needed to answer questions about hydration, freshness, and resource usage. - **~10% faster materialized view hydration**: We've reduced the work performed during initial materialized view hydration, observing approximately 10% faster hydration times across our benchmarks. This shortens the window between creating (or restarting) a materialized view and the point at which it begins serving up-to-date results. ### Bug Fixes - Fixed `statement_timeout = 0` (which means "disabled" in PostgreSQL semantics) causing every `SELECT` and `EXPLAIN FILTER PUSHDOWN` to fail immediately with a spurious `StatementTimeout` error. - Tightened default validation on headers in Self-Managed deployments. - Enhanced session-based HTTP authentication. - Fixed `SHOW CREATE TYPE` emitting the bare type name instead of the fully-qualified `database.schema.type` name, unlike every other `SHOW CREATE` variant. - Fixed Self-Managed `orchestratord` `--enable-rbac False` silently inverting the value and enabling RBAC instead of disabling it. - Fixed SQL Server source composite primary key columns being recorded in non-deterministic order, causing incorrect constraint definitions and non-deterministic behavior across `ALTER SOURCE` and re-purification. - Fixed PostgreSQL source RLS policy validation producing false positives that blocked replication for users whose roles inherit BYPASSRLS through role membership. - Fixed SQL Server source growing memory without bound during table snapshots due to a `RowArena` that was never cleared between rows. - Fixed `SELECT` queries with both `LIMIT` and `OFFSET` processing all remaining rows instead of stopping after the limit was reached. - Fixed SQL Server source opening one upstream connection per Timely worker instead of one total, multiplying SQL Server connections and `sp_cdc_cleanup_change_table` calls by the worker count. - Fixed SQL Server source with PrivateLink connections only attempting the first resolved IP address instead of trying all available addresses. - Fixed `regexp_replace` returning an invalid regular expression error instead of `NULL` when called with a `NULL` replacement column and a literal pattern that fails to compile. - Fixed `pg_index.indnatts` counting columns of the indexed table instead of the index itself, and `pg_class.relnatts` always reporting `0` for index rows, improving compatibility with tools that introspect the PostgreSQL catalog. - Fixed toggling `memory_limiter_interval` from `0s` to a non-zero value at runtime potentially triggering an immediate replica kill even when memory usage was well below the limit. - Fixed Self-Managed Kubernetes deployments where setting both `cluster_topology_spread_soft = on` and `cluster_topology_spread_min_domains` caused all replica pod creation to fail with an admission error. ## v26.22.0 *Released to Materialize Cloud: 2026-04-30*
*Released to Materialize Self-Managed: 2026-05-01*
This release includes various improvements, including faster sink performance with up to 50% lower memory usage, and bug fixes. ### Improvements #### Sink improvements - **Faster sink performance with up to 50% lower memory usage**: Sink operations now process data more efficiently by walking arrangements directly via cursors, reducing memory overhead and improving throughput. For large sinks, we have seen memory usage reduced by up to 50%. - **Iceberg sink support for interval and range types**: Iceberg sinks now support `interval` and `range` data types, expanding compatibility with complex data schemas. #### MCP security improvements - **Enhanced MCP server security**: MCP server origin validation now uses CORS allowlists instead of self-comparison checks, preventing DNS rebinding attacks. - **Stricter MCP search path security**: MCP developer endpoint now sets a tight `search_path` to prevent bypass attacks. #### General improvements - Catalog synchronization now uses more efficient consolidation algorithms, reducing overhead for environments with many objects. - Improved query optimization by pushing `COALESCE` operations into `CASE WHEN` expressions where beneficial. ### Bug Fixes - Fixed Iceberg upsert sinks dropping delete operations when handling more than 100,000 distinct keys. - Fixed `EXPLAIN OPTIMIZED PLAN` failure after renaming materialized views, indexes, or continual tasks. - Fixed Parquet map key handling to properly deduplicate keys and use the final value when duplicates exist. - Fixed subquery handling to properly account for negative diffs in accumulation logic. - Fixed PostgreSQL source compatibility by using only `pg_catalog.server_version_num` for version detection. - Fixed PostgreSQL `format_type` output to properly quote the `"char"` type (OID 18). - Fixed an issue in the Console where the cursor would not appear in the SQL editor. - Fixed incorrect results from `mz_dataflow_global_ids` view when multiple objects shared the same dataflow. - Fixed interval conversion overflow in Arrow utilities when converting microseconds to nanoseconds. - Fixed OpenTelemetry rate limiting filter that was incorrectly suppressing all events instead of just rate-limited ones. - Fixed catalog leak when dropping replacement collections without applying them. - Enhanced security by ensuring sensitive authentication data is properly cleared from memory after use. - Enhanced security by ensuring TLS certificate data is properly zeroized when dropped. - Improved SQL name escaping in catalog operations for better reliability. - Removed unused `memory_request` field from replica allocation configuration. - Added regression test for Kafka sink handling of negative accumulations. ## v26.20.2 *Released to Materialize Cloud: 2026-04-16*
*Released to Materialize Self-Managed: 2026-04-17*
This release introduces the built-in Developer MCP server, Console improvements, and bug fixes. ### MCP Server for Developers > **Public Preview:** This feature is in public preview. Materialize environments now include a built-in Model Context Protocol (MCP) [Developer endpoint (`/api/mcp/developer`)](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md). Connecting an MCP-compatible coding agent (such as Claude Code, Claude Desktop, or Cursor) to this endpoint lets you ask natural language questions about your environment. For example, you could ask *why is my materialized view stale?* or *how much memory is my cluster using?*. You'll receive a diagnosis and recommendations on how to fix isssues. For more information, refer to: - [Integrations: MCP Server for Developers](https://preview.materialize.com/materialize/40269/markdown-docs/developer-tools/mcp-server/mcp-developer/index.md) ### Improvements - **Better Console schema navigation**: The schema dropdown in the SQL Shell now prioritizes schemas from the current database, making it easier to find relevant schemas. ### Bug Fixes - Fixed Console RBAC users tab that was displaying incorrectly for cloud users due to null `rolcanlogin` values. - Fixed builtin dependency ordering issue that could cause system catalog inconsistencies. ## v26.19.0 *Released to Materialize Cloud: 2026-04-09*
*Released to Materialize Self-Managed: 2026-04-10*
This release introduces append mode for [Iceberg sinks](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md), and bug fixes. ### Iceberg sink append mode When an [Iceberg sink](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md) is created in append mode, all changes are written as data rows — no Iceberg delete files are produced. This is especially useful if you're sinking data from a materialized view with temporal filters, and you don't want data to be deleted from your Iceberg table as it ages out. ```mzsql CREATE SINK events_log_iceberg IN CLUSTER analytics_cluster FROM user_events INTO ICEBERG CATALOG CONNECTION iceberg_catalog_connection ( NAMESPACE = 'events', TABLE = 'user_events_log' ) USING AWS CONNECTION aws_connection MODE APPEND WITH (COMMIT INTERVAL = '5m'); ``` For more information, refer to: - [Guide: Apache Iceberg sink](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg/index.md) - [Reference: `CREATE SINK ICEBERG`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md) ### Bug Fixes - Fixed identifier display in system catalog tables `mz_kafka_source_tables`, `mz_mysql_source_tables`, and `mz_postgres_source_tables` to show raw values without SQL quoting (e.g., `my-kafka-topic` instead of `"my-kafka-topic"`). ## v26.18.0 *Released to Materialize Cloud: 2026-04-02*
*Released to Materialize Self-Managed: 2026-04-03*
This release includes various improvements and bug fixes. ### Improvements - **Improved Console reconnect behavior**. The Console shell now reconnects more reliably, with toast notifications that no longer stack. - **Expanded `COPY FROM` data type support**. [`COPY FROM` parquet files](https://preview.materialize.com/materialize/40269/markdown-docs/sql/copy-from/index.md#parquet-formatting) now supports `map` and `interval` data types. - **Improved query performance on wide tables**. Queries on tables with many columns now execute faster. ### Bug Fixes - Fixed SSL certificate loading to properly handle all certificates in PEM bundles instead of only the first one. - Fixed materialized view sinks getting stuck when instantiated with output shards whose initial frontier is less than the dataflow as-of. - Fixed panic when dropping computed tables with active `SUBSCRIBE` operations. - Fixed `EXPLAIN ANALYZE` not working correctly due to quoting issues in `mz_mappable_objects`. ## v26.17.1 *Released to Materialize Self-Managed: 2026-03-27*
This release includes a bug fix. ### Bug Fixes - Fixed Iceberg sinks failing to write unsigned integer types (UInt8, UInt16, UInt32, UInt64) by mapping them to Iceberg-compatible signed types. ## v26.17.0 *Released to Materialize Cloud: 2026-03-26*
*Released to Materialize Self-Managed: 2026-03-27*
This release includes performance improvements and bug fixes. ### Improvements - **10% improved transactional DDL performance**: We've eliminated an O(n^2) operation. DDL transactions (such as creating multiple tables from a source in a single transaction) now execute faster. - **Reduced catalog server load during blue/green deploys**: The dbt-materialize adapter now uses a single batched query instead of per-cluster sequential polling. This is especially useful when creating a large number of objects. ### Bug Fixes - Fixed a correctness bug where LEFT JOIN, RIGHT JOIN, and FULL JOIN with an empty relation produced incorrect results (empty instead of NULLs) due to join identity elision. - Fixed Kafka sinks incorrectly writing negative Avro timestamps (pre-epoch dates) by treating the timestamp microseconds as unsigned instead of signed. - Fixed Avro fixed-decimal encoding not left-padding unscaled bytes to the schema's fixed size, which could cause `UnexpectedEof` errors or data corruption in downstream consumers. - Fixed a race condition in persist where a batch could be selected before obtaining a lease, potentially causing unexpected read-time halts. - Fixed PROXY protocol v2 header parsing failing when headers arrived across multiple TCP segments, which could corrupt subsequent HTTP parsing between balancerd and environmentd. - Fixed the Fivetran destination connector logging `app_password` in plaintext in connection logs. - Fixed queries with expensive functions in subqueries (e.g., `UNION ALL`, `EXISTS`, scalar subqueries) being incorrectly routed to `mz_catalog_server` instead of the user's cluster. - Fixed webhook secret cache not invalidating when secrets are changed, requiring a restart to pick up new secret values. - Fixed orchestratord image reference parsing treating registry ports (e.g., `gcr.io:443/...`) and digest separators (`@sha256:...`) as image tags, producing invalid references for Self-Managed deployments. - Fixed optimizer feature flags being auto-enabled during item parsing, which rendered plan caching ineffective. - Fixed `mz_catalog_raw` not being consistently readable under strict serializable isolation by keeping the catalog shard's frontier up-to-date with the oracle read timestamp. - Fixed a security vulnerability in the `lz4_flex` dependency (RUSTSEC-2026-0041). - Fixed a bad assertion in oneshot source storage worker reconciliation that could cause panics. - Fixed hydration check errors during 0dt upgrades for replica-targeted collections, where non-target replicas would report `CollectionMissing` errors. - Fixed SQL Server source `Transaction::drop` not sending ROLLBACK, leaving the SQL Server session in an open transaction after drop. - Fixed a panic in authentication when receiving a proof of unexpected length. - Fixed an issue causing console session variables to be lost after a reconnect. ## v26.16.0 *Released to Materialize Cloud: 2026-03-19*
*Released to Materialize Self-Managed: 2026-03-20*
This release adds support for copying Parquet files from object storage, performance improvements, and bug fixes. ### `COPY FROM` Parquet files in object storage `COPY FROM` now supports bulk importing data from Parquet files stored in Amazon S3 and any S3-compatible object storage service, such as Google Cloud Storage, Cloudflare R2, or MinIO. You can import Parquet files using an AWS connection or a presigned URL. ```mzsql COPY INTO my_table FROM 's3://my_bucket/my_data.parquet' (FORMAT PARQUET, AWS CONNECTION = my_aws_conn); ``` For more information, refer to: - [Syntax: COPY FROM](https://preview.materialize.com/materialize/40269/markdown-docs/sql/copy-from/index.md) - [Syntax: CREATE CONNECTION (S3-compatible)](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#s3-compatible-object-storage) ### Improvements - **Improved [`AS OF`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/subscribe/index.md#as-of) error messages**: Error messages for `AS OF` queries now use user-facing terminology (e.g., "Indexed input", "Storage inputs") instead of internal names. - **Streamed [WebSocket](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/websocket-api/index.md) query results**: WebSocket query results are now streamed directly instead of buffered, reducing memory usage for large result sets. ### Bug Fixes - Fixed an RBAC security bypass that allowed a non-superuser with `CREATEROLE` privilege to strip superuser status from any role via `ALTER ROLE ... NOSUPERUSER`. - Fixed indexes on older versions of altered tables or replaced materialized views being lost during environment bootstrap, which could cause panics. - Fixed pgwire encoding errors leaving partial messages in the connection buffer, which caused clients to see "lost synchronization" errors instead of proper error messages. - Fixed unbounded queue growth in storage since-downgrade processing that could lead to out-of-memory conditions in environments with many storage collections. - Fixed a correctness bug when parsing large Avro fixed-size decimals from Kafka sources, where values were returned as raw bytes instead of decoded decimal numbers. - Fixed subqueries being incorrectly allowed in the `SET` clause of `UPDATE` statements. - Fixed `COPY FROM S3` requiring manual column specification for tables with `NOT NULL` columns by removing a redundant non-null check during planning. - Fixed a correctness issue with `COPY FROM STDIN` when using headers. - Fixed column name deduplication bug in `COPY TO` / Parquet writer that could produce duplicate column names. - Fixed `RETAIN HISTORY` value being ignored for webhook tables. - Fixed `DROP OWNED BY` and `REASSIGN OWNED BY` not including network policies, which could block `DROP ROLE` for roles that own network policies. - Fixed false positive wallclock lag reporting (showing ~56 years of lag) during replica startup for compute introspection indexes. ## v26.15.0 *Released to Materialize Cloud: 2026-03-12*
*Released to Materialize Self-Managed: 2026-03-13*
This release includes various improvements and bug fixes. ### Improvements - **Improved memory efficiency for joins on `varchar` and `text` columns**: Previously, joining on these columns required creating a new arrangement, effectively doubling memory usage. Materialize can now reuse existing arrangements on these columns. We've seen memory improvements by as much as 25% in some cases involving `varchar` indexes. - Added support for setting `cpu_request` independently of `cpu_limit` in cluster replica sizes for Self-Managed deployments. - Renamed the **Org ID** label to **Environment ID** in the Console Shell to disambiguate organization IDs from environment IDs, which was causing confusion for Self-Managed deployments. ### Bug Fixes - Fixed unmaterializable functions (e.g., `now()`) being allowed in `AS OF` queries, which could return incorrect results. - Fixed Kafka sink creation failing with an authorization error when the progress topic already exists, which affected workflows where topics are pre-created by a superuser. - Fixed a panic when running `COPY FROM STDIN` concurrently with table drops. - Fixed unbounded command queue buildup in internal storage writer tasks that could lead to out-of-memory conditions when environments have a large number of indexes. - Fixed the Role Filters display in dark mode in the Console. - Fixed an incorrect join condition in the Console cluster list that could cause incorrect cluster information to be displayed. ## v26.14.1 *Released to Materialize Cloud: 2026-03-05*
*Released to Materialize Self-Managed: 2026-03-06*
This release introduces `COPY FROM` support for CSVs in object storage, source versioning for SQL Server sources, and performance improvements to DDL. ### `COPY FROM` CSVs in object storage `COPY FROM` now supports bulk importing data directly from Amazon S3 and any S3-compatible object storage service, such as Google Cloud Storage, Cloudflare R2, or MinIO. You can import CSV files using an AWS connection or a presigned URL. ```mzsql COPY INTO my_table FROM 's3://my_bucket/my_data.csv' (FORMAT CSV, AWS CONNECTION = my_aws_conn); ``` For more information, refer to: - [Syntax: COPY FROM](https://preview.materialize.com/materialize/40269/markdown-docs/sql/copy-from/index.md) - [Syntax: CREATE CONNECTION (S3-compatible)](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-connection/index.md#s3-compatible-object-storage) ### SQL Server: Source versioning For SQL Server sources, we've introduced new syntax for [`CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/sql-server-v2/index.md) and [`CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md). This allows you to better handle schema changes in your source SQL Server tables. > **Note:** - Changing column types is currently unsupported. For more information, refer to: - [Guide: Handling upstream schema changes with zero downtime](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/sql-server/source-versioning/index.md) - [Syntax: `CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/sql-server-v2/index.md) - [Syntax: `CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md) ### Improvements - **Faster DDL at scale**: We've improved DDL (e.g., `CREATE VIEW`, `CREATE INDEX`, `DROP`) latency by 37-55% for environments with many objects by making the internal catalog state a persistent data structure with structural sharing. - **Faster Iceberg sink commits**: We've improved Iceberg sink commit performance by disabling the duplicate check for RowDelta actions, which was causing significant commit time overhead. - **Up to 28x faster `COPY FROM STDIN`**: We've improved `COPY FROM STDIN` performance by parallelizing ingestion and using constant memory. ### Bug Fixes - Fixed the jsonb contains operator (`?`) to correctly return NULL when the left operand is NULL, matching PostgreSQL behavior. - Internal optimization that reduces resource usage of the catalog server; this can reduce resource consumption on restart when indexes are added. - Fixed a panic when using `COPY FROM` with invalid range values (e.g., `[7,3)` where lower bound exceeds upper bound), now returning a proper error message. - Fixed incorrect replication lag display in the Console during PostgreSQL source snapshots, where `offset_committed` was incorrectly reported as zero until the snapshot completed. - Fixed a panic when dropping materialized views that had active subscribes depending on older GlobalIds. - Fixed dataflows being incorrectly re-planned after an environmentd restart due to missing per-cluster optimizer feature overrides. - Fixed query formatting for SQL Server and MySQL sources. ## v26.13.0 *Released to Materialize Cloud: 2026-02-26*
*Released to Materialize Self-Managed: 2026-02-27*
This release includes the release of our Iceberg Sink, performance improvements to `SUBSCRIBE`, and bugfixes. ### Iceberg Sink > **Public Preview:** This feature is in public preview. Iceberg sinks provide exactly once delivery of updates from Materialize into [Apache Iceberg](https://iceberg.apache.org/) tables hosted on [Amazon S3 Tables](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables.html). As data changes in Materialize, the corresponding Iceberg tables are automatically kept up to date. You can sink data from a materialized view, a source, or a table. ```mzsql CREATE SINK my_iceberg_sink IN CLUSTER sink_cluster FROM materialized_view_mv1 INTO ICEBERG CATALOG CONNECTION iceberg_catalog_connection ( NAMESPACE = 'my_iceberg_namespace', TABLE = 'mv1' ) USING AWS CONNECTION aws_connection KEY (row_id) MODE UPSERT WITH (COMMIT INTERVAL = '60s'); ``` For more information, refer to: - [Guide: How to export results from Materialize to Apache Iceberg Tables](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/iceberg/index.md) - [Blog: Making Iceberg work for Operational Data](https://materialize.com/blog/making-iceberg-work-for-operational-data/) - [Syntax: CREATE SINK... INTO ICEBERG ](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-sink/iceberg/index.md) ### Improvements - **Improved `SUBSCRIBE` Performance**: We've optimized `SUBSCRIBE` to skip initial snapshots in more cases. This can speed up `SUBSCRIBE` start times. - **Improved compatibility with external tools**: We've added `strpos` as a synonym for the `position` function, improving compatibility with tools such as PowerBI. - **Improved database concurrency**: We've reduced contention when a single collection experiences a high volume of updates. ### Bug Fixes - Fixed a panic when constructing multi-dimensional arrays with null values, now treating null elements as zero-dimensional arrays consistent with PostgreSQL behavior. - Fixed a bug where dropping a replacement materialized view (instead of applying the replacement) could seal the target materialized view for all times after an environmentd restart. - Fixed a bug where `Int2Vector` to `Array` casting did not correctly handle element type conversions, potentially causing incorrect results or errors. - Fixed the Self-Managed bug in the memory-based calculation of replica size credits, which was incorrectly multiplying by the number of workers instead of using the correct per-process memory limit. - Fixed an overflow display issue on the roles page in the console. - Fixed SSO connection configuration pages in the console, which did not load properly due to missing content security policy entries. ## v26.12.0 *Released to Materialize Cloud: 2026-02-19*
*Released to Materialize Self-Managed: 2026-02-20*
This release introduces our Roles and Users page, performance improvements, and bugfixes. ### Role Management The new Roles and Users page on the Materialize Console allows organization administrators to create roles, grant privileges, and assign roles to users. You can also track the hierarchy of roles using the graph view. ![Create Role experience](https://preview.materialize.com/materialize/40269/images/releases/v2612_create_role.png) ![Graph View experience](https://preview.materialize.com/materialize/40269/images/releases/v2612_graph_view.png) You can navigate to the Roles and Users page directly from the Materialize console. If you're on Materialize Self-Managed, upgrade to v26.12 first. If you're on Materialize Cloud, you can go directly to https://console.materialize.com/roles to reach the page. ### Improvements - **Updated default resource requirements** (*Materialize Self-Managed only*): We've updated the Materialize Self-Managed Helm charts to ensure correct operation on Kind clusters - **Improved console query history performance**: We've optimized RBAC queries to use OIDs instead of names, resulting in 2-3x faster page execution. ### Bug Fixes - Fixed a panic when using unsupported types (e.g., float) with range expressions, now returning a proper error message instead of an internal error. - Fixed a panic when using empty `int2vector` values, which could cause internal errors during query optimization or execution. - Fixed internal errors that could occur during query optimization due to type checking mismatches in `ColumnKnowledge` and related transforms, adding fallback handling to prevent crashes. - Fixed compatibility with older Amazon Aurora PostgreSQL versions when using parallel snapshots, by using `SELECT current_setting()` instead of `SHOW` for version retrieval. - Fixed version comparison in the Materialize Kubernetes operator to correctly follow semver precedence rules, no longer rejecting upgrades that differ only in build metadata. ## v26.11.0 *Released to Materialize Cloud: 2026-02-19*
*Released to Materialize Self-Managed: 2026-02-13*
This release includes improvements to Avro Schema references, `EXPLAIN` commands, and bug fixes. ### Improvements - **Avro Schema References**: Sources can now use avro schemas which reference other schemas when using Confluent Schema Registry. - **`EXPLAIN` improvements**: `EXPLAIN` now allows you to inspect the query plan for `SUBSCRIBE` statements. It also fully qualifies index names if there are identically-named indexes across different schemas. - **More efficient dbt-adapter**: We've added indexes on `mz_hydration_statuses` and `mz_materialization_lag`. This should speed up "deployment ready" queries made by our dbt-adapter. ### Bug Fixes - Fixed a bug where `IS DISTINCT FROM` could fail typechecking in certain cases involving different data types, causing query errors. - Improved the error message when `INSERT INTO ... SELECT` transitively references a source. ## v26.10.1 *Released to Materialize Cloud: 2026-02-05*
*Released to Materialize Self-Managed: 2026-02-06*
This release introduces Replacement Materialized Views, performance improvements, and bugfixes. ### Replacement Materialized Views > **Public Preview:** This feature is in public preview. Replacement materialized views allow you to modify the definition of an existing materialized view, while preserving all downstream dependencies. Materialize is able to replace a materialized view in place, by calculating the *diff* between the original and the replacement. Once applied, the *diff* flows downstream to all dependent objects. For more information, refer to: - [Guide: Replace Materialized Views](https://preview.materialize.com/materialize/40269/markdown-docs/transform-data/updating-materialized-views/replace-materialized-view/index.md) - [Syntax: CREATE REPLACEMENT MATERIALIZED VIEW](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-materialized-view/index.md) - [Syntax: ALTER MATERIALIZED VIEW](https://preview.materialize.com/materialize/40269/markdown-docs/sql/alter-materialized-view/index.md) ### Improvements - **Improved hydration times for PostgreSQL sources**: PostgreSQL sources now perform parallel snapshots. This should improve initial hydration times, especially for large tables. ### Bug Fixes - Fixed an issue where floating-point values like `-0.0` and `+0.0` could be treated as different values in equality comparisons but the same in ordering, causing incorrect results in operations like `DISTINCT`. - Fixed an issue where certain SQL keywords required incorrect quoting in expressions. - Fixed the `ORDER BY` clause in `EXPLAIN ANALYZE MEMORY` to correctly sort by memory usage instead of by the text representation. - Fixed a bug where the optimizer could mishandle nullability inside record types. - Fixed an issue where the `mz_roles` system table could produce invalid retractions when certain system variables were changed. - *Console*: Fixed SQL injection vulnerability in identifier quoting where only the first quote character was being escaped. ## v26.9.0 *Released to Materialize Cloud: 2026-01-29*
*Released to Materialize Self-Managed: 2026-01-30*
v26.9 includes significant performance improvements to QPS & query latency. ### Improvements - **Up to 2.5x increased QPS**: We've significantly optimized how `SELECT` statements are processed; they are now processed outside the main thread. In our tests, this change increased QPS by as much as 2.5x. ![Chart of QPS before/after](https://preview.materialize.com/materialize/40269/images/releases/v2609_qps.png) - **Significant reduction in query latency**: Moving `SELECT` statements off the main thread has significantly reduced latency. p99 has reduced by up to 50% for some workloads. ![Chart of latency before/after](https://preview.materialize.com/materialize/40269/images/releases/v2609_latency.png) - **Dynamically configure system parameters using a ConfigMap** (*Materialize Self-Managed only*): You can now use a ConfigMap to dynamically update system parameters at runtime. In many cases, this means you don't need to restart Materialize for new system parameters to take effect. You can also specify system parameters which survive restarts and upgrades. Refer to our [documentation on configuring system parameters](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/configuration-system-parameters/index.md#configure-system-parameters-via-configmap). - Added `ABORT` as a PostgreSQL-compatible alias for the `ROLLBACK` transaction command, to improve compatibility with GraphQL engines like Hasura ### Bug Fixes - Fixed an issue causing new generations to be promoted prematurely when using the `WaitUntilReady` upgrade strategy (*Materialize Self-Managed only*) - Fixed a race condition in source reclock that could cause panics when the `as_of` timestamp was newer than the cached upper bound. - Improved error messages when the load balancer cannot connect to the upstream environment server ## v26.8.0 *Released to Materialize Cloud: 2026-01-22*
*Released to Materialize Self-Managed: 2026-01-23*
v26.8 includes a new notice in the Console to help catch common SQL mistakes, Protobuf compatibility improvements, and performance optimizations for view creation. ### Improvements - Added a Console notice when users write `= NULL`, `!= NULL`, or `<> NULL` in SQL expressions instead of `IS NULL` or `IS NOT NULL`. Comparisons using `=`, `!=`, or `<>` with `NULL` always evaluate to `NULL`. - Protobuf schemas that import well-known types (such as `google.protobuf.Timestamp` or `google.protobuf.Duration`) now work automatically when using a Confluent Schema Registry connection. - Improved performance of view creation by caching optimized expressions, resulting in approximately 2x faster view creation in some scenarios. ## v26.7.0 *Released to Materialize Self-Managed: 2026-01-16*
*Released to Materialize Cloud: 2026-01-17*
v26.7 improves compatibility with go-jet and includes bug fixes. ### Improvements - **Improved compatibility with go-jet**: We've added the `attndims` column to `pg_attribute`. We've also fixed `pg_type.typelem` to correctly report element types for named list types. - **Pretty print SQL in the console**: We've made it easier to read the definitions for views and materialized views in the console. ### Bug Fixes - Fixed an issue where type error messages could inadvertently expose constant values from queries. - The console reconnects more gracefully if the connection to the backend is interrupted ## v26.6.0 *Released to Materialize Cloud: 2026-01-08*
*Released to Materialize Self-Managed: 2026-01-09*
v26.6.0 includes bug fixes for Kafka sinks and Self-Managed deployments. ### Bug Fixes - Fixed an issue where console and balancer deployments could fail to upgrade to the correct version during Self-Managed environment upgrades. - Fixed an issue where `ALTER SINK ... SET FROM` on Kafka sinks could incorrectly restart in snapshot mode even when the sink had already made progress, causing unnecessary resource consumption and potential out-of-memory errors. ## v26.5.1 *Released to Materialize Self-Managed: 2025-12-23*
*Released to Materialize Cloud: 2026-01-08*
v26.5.1 enhances our SQL Server source, improves performance, and strengthens Materialize Self-Managed reliability. ### Improvements - **VARCHAR(MAX) and NVARCHAR(MAX) support for SQL Server**: The Materialize SQL Server source now supports `varchar(max)` and `nvarchar(max)` data types. - **Faster authentication for connection poolers**: We've added an index to the `pg_authid` system catalog. This should significantly improve the performance of default authentication queries made by connection poolers like pgbouncer. - **Faster Kafka sink startup**: We've updated the default Kafka progress topic configuration to reduce the amount of progress data processed when creating new [Kafka sinks](https://preview.materialize.com/materialize/40269/markdown-docs/export-data/kafka/index.md). - **dbt strict mode**: We've introduced `strict_mode` to dbt-materialize, our dbt adapter. `strict_mode` enforces production-ready isolation rules and improves cluster health monitoring. It does so by validating source idempotency, schema isolation, cluster isolation and index restrictions. - **SQL Server Always On HA failover support** (*Materialize Self-Managed only*): Materialize Self-Managed now offers better support for handling failovers, without downtime, in SQL Server Always On sources. [Contact our support team](https://materialize.com/support/) to enable this in your environment. - **Auto-repair accidental changes** (*Materialize Self-Managed only*): Improvements to the controller logic allow Materialize to auto-repair changes such as deleting a StatefulSet. This means that your production setups should be more robust in the face of accidental changes. - **Track deployment status after upgrades** (*Materialize Self-Managed only*): The Materialize custom resource now displays both active and desired `environmentd` versions. This makes it easier to track deployment status after upgrades. ### Bug fixes - Added additional checks to string functions (`replace`, `translate`, etc.) to help prevent out-of-memory errors from inflationary string operations. - Fixed an issue which could cause panics during connection drops; this means improved stability when clients disconnect. - Fixed an issue where disabling console or balancers would fail if they were already running. - Fixed an issue where balancerd failed to upgrade and remained stuck on its pre-upgrade version. ## v26.4.0 *Released to Materialize Self-Managed: 2025-12-17*
*Released to Materialize Cloud: 2025-12-18* v26.4.0 introduces several performance improvements and bugfixes. ### Improvements - **Over 2x higher connections per second (CPS)**: We've optimized how Materialize handles inbound connection requests. In our tests, we've observed 2x - 4x improvements to the rate at which new client connections can be established. This is especially beneficial when spinning up new environments, warming up connection pools, or scaling client instances. - **Up to 3x faster hydration times for large PostgreSQL tables**: We've reduced the overhead incurred by communication between multiple *workers* on a large cluster. We've observed up to 3x throughput improvement when ingesting 1 TB PostgreSQL tables on large clusters. - **More efficient source ingestion batching**: Sources now batch writes more effectively. This can result in improved freshness and lower resource utilization, especially when a source is doing a large number of writes. - **CloudSQL HA failover support** (*Materialize Self-Managed only*): Materialize Self-Managed now offers better support for handling failovers in CloudSQL HA sources, without downtime. [Contact our support team](https://materialize.com/support/) to enable this in your environment. - **Manual Promotion** (*Materialize Self-Managed only*): [Rollout strategies](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/index.md#rollout-strategies) allow you control how Materialize transitions from the current generation to a new generation during an upgrade. We've added a new rollout strategy called `ManuallyPromote` which allows you to choose when to promote the new generation. This means that you can minimize the impact of potential downtime. ### Bug Fixes - Fixed timestamp determination logic to handle empty read holds correctly. - Fixed lazy creation of temporary schemas to prevent schema-related errors. - Reduced SCRAM iterations in scalability framework and fixed fallback image configuration. ## v26.3.0 *Released to Materialize Cloud & Materialize Self-Managed: 2025-12-12*
### Improvements - For Self-Managed: added version upgrade window validation, to prevent skipping required intermediate versions during upgrades. - Improved activity log throttling to apply across all statement executions, not just initial prepared statement execution, providing more consistent logging behavior. ### Bug Fixes - Fixed validation for replica sizes to prevent configurations with zero scale or workers, which previously caused division-by-zero errors and panics. - Fixed frontend `SELECT` sequencing to gracefully handle collections that are dropped during real-time recent timestamp determination. ## v26.2.0 *Released Cloud: 2025-12-05*
*Released Self-Managed: 2025-12-09* This release focuses primarily on bug fixes. ### Bug fixes - **Catalog updates**: Fixed a bug where catalog item version updates were incorrectly ignored when the `create_sql` didn't change, which could cause version updates to not be applied properly. - **Console division by zero**: Fixed a division by zero error in the console, specifically when viewing `mz_console_cluster_utilization_overview`. - **ALTER SINK improvements**: Fixed `ALTER SINK ... SET FROM` to prevent panics in certain situations. - **Improved rollout handling**: Fixed an issue where rollouts could leave a pod at their previous configuration. - **Dependency drop handling**: Fixed panics that could occur when dependencies are dropped during a SELECT or COPY TO. These operations now gracefully return a `ConcurrentDependencyDrop` error. ## v26.1.0 *Released Self-Managed: 2025-11-26* v26.1.0 introduces `EXPLAIN ANALYZE CLUSTER`, console bugfixes, and improvements for SQL Server support, including the ability to create a SQL Server Source via the Console. ### `EXPLAIN ANALYZE CLUSTER` The [`EXPLAIN ANALYZE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/explain-analyze/index.md) statement helps analyze how objects, namely indexes or materialized views, are running. We've introduced a variation of this statement, `EXPLAIN ANALYZE CLUSTER`, which presents a summary of every object running on your current cluster. You can use this statement to understand the CPU time spent and memory consumed per object on a given cluster. You can also reveal whether an object has skewed operators, where work isn't evenly distributed among workers. For example, to get a report on memory, you can run `EXPLAIN ANALYZE CLUSTER MEMORY`, and you'll receive an output similar to the table below: | object | global_id | total_memory | total_records | | --------------------------------------- | --------- | ------------ | ------------- | | materialize.public.idx_top_buyers | u85496 | 2086 bytes | 25 | | materialize.public.idx_sales_by_product | u85492 | 1909 kB | 148607 | | materialize.public.idx_top_buyers | u85495 | 1332 kB | 77133 | To understand worker skew, you can run `EXPLAIN ANALYZE CLUSTER CPU WITH SKEW`, and you'll receive an output similar the table below: | object | global_id | worker_id | max_operator_cpu_ratio | worker_elapsed | avg_elapsed | total_elapsed | | --------------------------------------- | --------- | --------- | ---------------------- | --------------- | --------------- | --------------- | | materialize.public.idx_sales_by_product | u85492 | 0 | 1.18 | 00:00:00.094447 | 00:00:00.079829 | 00:00:00.159659 | | materialize.public.idx_top_buyers | u85495 | 0 | 1.15 | 00:00:01.371221 | 00:00:01.363659 | 00:00:02.727319 | | materialize.public.idx_top_buyers | u85495 | 1 | 1.03 | 00:00:01.356098 | 00:00:01.363659 | 00:00:02.727319 | | materialize.public.idx_top_buyers | u85496 | 1 | 1.01 | 00:00:00.021163 | 00:00:00.021048 | 00:00:00.042096 | | materialize.public.idx_top_buyers | u85496 | 0 | 0.99 | 00:00:00.020932 | 00:00:00.021048 | 00:00:00.042096 | | materialize.public.idx_sales_by_product | u85492 | 1 | 0.82 | 00:00:00.065211 | 00:00:00.079829 | 00:00:00.159659 | ### Improved SQL Server support Materialize v26.1.0 includes improved support for SQLServer, including the ability to create a SQLServer Source via the console. ### Upgrade notes for v26.1.0 - To upgrade to `v26.1` or future versions, you must first upgrade to `v26.0` ## Self-Managed v26.0.0 *Released: 2025-11-18* ### Swap support Starting in v26.0.0, Self-Managed Materialize enables swap by default. Swap allows for infrequently accessed data to be moved from memory to disk. Enabling swap reduces the memory required to operate Materialize and improves cost efficiency. To facilitate upgrades from v25.2, Self-Managed Materialize added new labels to the node selectors for `clusterd` pods. To upgrade, you must prepare your nodes by adding the required labels. For detailed instructions, see [Prepare for swap and upgrade to v26.0](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/appendix/upgrade-to-swap/index.md). ### SASL/SCRAM-SHA-256 support Starting in v26.0.0, Self-Managed Materialize supports SASL/SCRAM-SHA-256 authentication for PostgreSQL wire protocol connections. For more information, see [Authentication](https://preview.materialize.com/materialize/40269/markdown-docs/security/self-managed/authentication/index.md). When SASL authentication is enabled: - **PostgreSQL connections** (e.g., `psql`, client libraries, [connection poolers](https://preview.materialize.com/materialize/40269/markdown-docs/serve-results/connection-pooling/index.md)) use SCRAM-SHA-256 authentication - **HTTP/Web Console connections** use standard password authentication This hybrid approach provides maximum security for SQL connections while maintaining compatibility with web-based tools. ### License Key Starting in v26.0.0, Self-Managed Materialize requires a license key. | License key type | Deployment type | Action | | --- | --- | --- | | Community | New deployments |

To get a license key:

| | Community | Existing deployments | Contact Materialize support. | | Enterprise | New deployments | Visit https://materialize.com/self-managed/enterprise-license/ to purchase an Enterprise license. | | Enterprise | Existing deployments | Contact Materialize support. | For new deployments, you configure your license key in the Kubernetes Secret resource during the installation process. For details, see the [installation guides](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/installation/index.md). For existing deployments, you can configure your license key via: ```bash kubectl -n materialize-environment patch secret materialize-backend -p '{"stringData":{"license_key":""}}' --type=merge ``` ### PostgreSQL: Source versioning For PostgreSQL sources, starting in v26.0.0, Materialize introduces new syntax for [`CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/postgres-v2/index.md) and [`CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md) to allow better handle DDL changes to the upstream PostgreSQL tables. > **Note:** - This feature is currently supported for PostgreSQL sources, with > additional source types coming soon. > - Changing column types is currently unsupported. For more information, see: - [Guide: Handling upstream schema changes with zero downtime](https://preview.materialize.com/materialize/40269/markdown-docs/ingest-data/postgres/source-versioning/index.md) - [`CREATE SOURCE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-source/postgres-v2/index.md) - [`CREATE TABLE`](https://preview.materialize.com/materialize/40269/markdown-docs/sql/create-table/index.md) ### Deprecation The `inPlaceRollout` setting has been deprecated and will be ignored. Instead, use the new setting `rolloutStrategy` to specify either: - `WaitUntilReady` (*Default*) - `ImmediatelyPromoteCausingDowntime` For more information, see [`rolloutStrategy`](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/index.md#rollout-strategies). ### Terraform helpers The following sample Terraform modules are available for deploying Materialize: | Module | Description | | --- | --- | | Amazon Web Services (AWS) | An example Terraform module for deploying Materialize on AWS. See Install on AWS for detailed instructions usage. | | Azure | An example Terraform module for deploying Materialize on Azure. See Install on Azure for detailed instructions usage. | | Google Cloud Platform (GCP) | An example Terraform module for deploying Materialize on GCP. See Install on GCP for detailed instructions usage. | #### Upgrade notes for v26.0.0 - Upgrading to `v26.0.0` is a major version upgrade. To upgrade to `v26.0` from `v25.2.X` or `v25.1`, you must first upgrade to `v25.2.16` and then upgrade to `v26.0.0`. - For upgrades, the `inPlaceRollout` setting has been deprecated and will be ignored. Instead, use the new setting `rolloutStrategy` to specify either: - `WaitUntilReady` (*Default*) - `ImmediatelyPromoteCausingDowntime` For more information, see [`rolloutStrategy`](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/index.md#rollout-strategies). - New requirements were introduced for [license keys](https://preview.materialize.com/materialize/40269/markdown-docs/releases/index.md#license-key). To upgrade, you will first need to add a license key to the `backendSecret` used in the spec for your Materialize resource. See [License key](https://preview.materialize.com/materialize/40269/markdown-docs/releases/index.md#license-key) for details on getting your license key. - Swap is now enabled by default. Swap reduces the memory required to operate Materialize and improves cost efficiency. Upgrading to `v26.0` requires some preparation to ensure Kubernetes nodes are labeled and configured correctly. As such: - If you are using the Materialize-provided Terraforms, upgrade to version `v0.6.1` of the Terraform. - If you are **not** using a Materialize-provided Terraform, refer to [Prepare for swap and upgrade to v26.0](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/appendix/upgrade-to-swap/index.md). See also [Version-specific upgrade notes](https://preview.materialize.com/materialize/40269/markdown-docs/self-managed-deployments/upgrading/version-notes/index.md). ## See also - [Release Schedule](https://preview.materialize.com/materialize/40269/markdown-docs/releases/schedule/index.md) ## Pages in this section - [Materialize v0.108](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.108/index.md) - [Materialize v0.107](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.107/index.md) - [Materialize v0.106](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.106/index.md) - [Materialize v0.101](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.101/index.md) - [Materialize v0.100](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.100/index.md) - [Materialize v0.99](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.99/index.md) - [Materialize v0.98](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.98/index.md) - [Materialize v0.97](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.97/index.md) - [Materialize v0.96](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.96/index.md) - [Materialize v0.95](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.95/index.md) - [Materialize v0.94](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.94/index.md) - [Materialize v0.93](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.93/index.md) - [Materialize v0.92](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.92/index.md) - [Materialize v0.91](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.91/index.md) - [Materialize v0.90](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.90/index.md) - [Materialize v0.89](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.89/index.md) - [Materialize v0.88](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.88/index.md) - [Materialize v0.87](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.87/index.md) - [Materialize v0.86](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.86/index.md) - [Materialize v0.85](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.85/index.md) - [Materialize v0.84](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.84/index.md) - [Materialize v0.83](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.83/index.md) - [Materialize v0.82](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.82/index.md) - [Materialize v0.81](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.81/index.md) - [Materialize v0.80](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.80/index.md) - [Materialize v0.79](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.79/index.md) - [Materialize v0.78](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.78/index.md) - [Materialize v0.77](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.77/index.md) - [Materialize v0.76](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.76/index.md) - [Materialize v0.75](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.75/index.md) - [Materialize v0.74](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.74/index.md) - [Materialize v0.73](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.73/index.md) - [Materialize v0.72](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.72/index.md) - [Materialize v0.71](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.71/index.md) - [Materialize v0.70](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.70/index.md) - [Materialize v0.69](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.69/index.md) - [Materialize v0.68](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.68/index.md) - [Materialize v0.67](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.67/index.md) - [Materialize v0.66](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.66/index.md) - [Materialize v0.65](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.65/index.md) - [Materialize v0.64](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.64/index.md) - [Materialize v0.63](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.63/index.md) - [Materialize v0.62](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.62/index.md) - [Materialize v0.61](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.61/index.md) - [Materialize v0.60](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.60/index.md) - [Materialize v0.59](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.59/index.md) - [Materialize v0.58](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.58/index.md) - [Materialize v0.57](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.57/index.md) - [Materialize v0.56](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.56/index.md) - [Materialize v0.55](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.55/index.md) - [Materialize v0.54](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.54/index.md) - [Materialize v0.53](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.53/index.md) - [Materialize v0.52](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.52/index.md) - [Materialize v0.51](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.51/index.md) - [Materialize v0.50](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.50/index.md) - [Materialize v0.49](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.49/index.md) - [Materialize v0.48](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.48/index.md) - [Materialize v0.47](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.47/index.md) - [Materialize v0.46](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.46/index.md) - [Materialize v0.45](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.45/index.md) - [Materialize v0.44](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.44/index.md) - [Materialize v0.43](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.43/index.md) - [Materialize v0.42](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.42/index.md) - [Materialize v0.41](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.41/index.md) - [Materialize v0.40](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.40/index.md) - [Materialize v0.39](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.39/index.md) - [Materialize v0.38](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.38/index.md) - [Materialize v0.37](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.37/index.md) - [Materialize v0.36](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.36/index.md) - [Materialize v0.33](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.33/index.md) - [Materialize v0.32](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.32/index.md) - [Materialize v0.31](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.31/index.md) - [Materialize v0.30](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.30/index.md) - [Materialize v0.29](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.29/index.md) - [Materialize v0.28](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.28/index.md) - [Materialize v0.27](https://preview.materialize.com/materialize/40269/markdown-docs/releases/v0.27/index.md) - [Release Schedule](https://preview.materialize.com/materialize/40269/markdown-docs/releases/schedule/index.md): Release schedule for Materialize Cloud and Self-Managed