diff --git a/doc/user/content/sql/system-catalog/mz_internal.md b/doc/user/content/sql/system-catalog/mz_internal.md index a0d1f90d4c1b3..b43e671b5ea06 100644 --- a/doc/user/content/sql/system-catalog/mz_internal.md +++ b/doc/user/content/sql/system-catalog/mz_internal.md @@ -1338,6 +1338,7 @@ The `mz_webhook_sources` table contains a row for each webhook source in the sys + @@ -1349,6 +1350,7 @@ The `mz_webhook_sources` table contains a row for each webhook source in the sys + diff --git a/misc/python/materialize/mzcompose/__init__.py b/misc/python/materialize/mzcompose/__init__.py index 257a882294587..238b78813d06e 100644 --- a/misc/python/materialize/mzcompose/__init__.py +++ b/misc/python/materialize/mzcompose/__init__.py @@ -108,6 +108,7 @@ def get_minimal_system_parameters( "enable_refresh_every_mvs": "true", "enable_repr_typecheck": "true", "enable_cluster_schedule_refresh": "true", + "enable_replacement_materialized_views": "true", "enable_sql_server_source": "true", "enable_statement_lifecycle_logging": "true", "enable_compute_temporal_bucketing": "true", diff --git a/src/adapter/src/catalog.rs b/src/adapter/src/catalog.rs index 26e90758c6afe..10a3f70712fc8 100644 --- a/src/adapter/src/catalog.rs +++ b/src/adapter/src/catalog.rs @@ -396,7 +396,8 @@ impl Catalog { | CatalogItemType::Func | CatalogItemType::Secret | CatalogItemType::Connection - | CatalogItemType::ContinualTask => { + | CatalogItemType::ContinualTask + | CatalogItemType::ReplacementMaterializedView => { dependencies.extend(global_ids); } CatalogItemType::View => { @@ -1553,6 +1554,7 @@ pub(crate) fn comment_id_to_audit_object_type(id: CommentObjectId) -> ObjectType CommentObjectId::ClusterReplica(_) => ObjectType::ClusterReplica, CommentObjectId::ContinualTask(_) => ObjectType::ContinualTask, CommentObjectId::NetworkPolicy(_) => ObjectType::NetworkPolicy, + CommentObjectId::ReplacementMaterializedView(_) => ObjectType::ReplacementMaterializedView, } } @@ -1584,6 +1586,9 @@ pub(crate) fn system_object_type_to_audit_object_type( mz_sql::catalog::ObjectType::Func => ObjectType::Func, mz_sql::catalog::ObjectType::ContinualTask => ObjectType::ContinualTask, mz_sql::catalog::ObjectType::NetworkPolicy => ObjectType::NetworkPolicy, + mz_sql::catalog::ObjectType::ReplacementMaterializedView => { + ObjectType::ReplacementMaterializedView + } }, SystemObjectType::System => ObjectType::System, } diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 57ba0352e0d9b..b86a2e3233bee 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -1925,7 +1925,8 @@ fn sort_updates_inner(updates: Vec) -> Vec { | CatalogItemType::Type | CatalogItemType::Func | CatalogItemType::Secret - | CatalogItemType::Connection => push_update( + | CatalogItemType::Connection + | CatalogItemType::ReplacementMaterializedView => push_update( StateUpdate { kind: StateUpdateKind::SystemObjectMapping(builtin_item_update), ts, @@ -2046,7 +2047,8 @@ fn sort_updates_inner(updates: Vec) -> Vec { CatalogItemType::Table => tables.push(update), CatalogItemType::View | CatalogItemType::MaterializedView - | CatalogItemType::Index => derived_items.push(update), + | CatalogItemType::Index + | CatalogItemType::ReplacementMaterializedView => derived_items.push(update), CatalogItemType::Sink => sinks.push(update), CatalogItemType::ContinualTask => continual_tasks.push(update), } @@ -2116,7 +2118,8 @@ fn sort_updates_inner(updates: Vec) -> Vec { CatalogItemType::Table => tables.push(update), CatalogItemType::View | CatalogItemType::MaterializedView - | CatalogItemType::Index => derived_items.push(update), + | CatalogItemType::Index + | CatalogItemType::ReplacementMaterializedView => derived_items.push(update), CatalogItemType::Sink => sinks.push(update), CatalogItemType::ContinualTask => continual_tasks.push(update), } diff --git a/src/adapter/src/catalog/builtin_table_updates.rs b/src/adapter/src/catalog/builtin_table_updates.rs index 714b731d87d7c..272f4f4c08222 100644 --- a/src/adapter/src/catalog/builtin_table_updates.rs +++ b/src/adapter/src/catalog/builtin_table_updates.rs @@ -26,18 +26,18 @@ use mz_catalog::builtin::{ MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES, MZ_MATERIALIZED_VIEWS, MZ_MYSQL_SOURCE_TABLES, MZ_NETWORK_POLICIES, MZ_NETWORK_POLICY_RULES, MZ_OBJECT_DEPENDENCIES, MZ_OBJECT_GLOBAL_IDS, MZ_OPERATORS, MZ_PENDING_CLUSTER_REPLICAS, MZ_POSTGRES_SOURCE_TABLES, MZ_POSTGRES_SOURCES, - MZ_PSEUDO_TYPES, MZ_ROLE_AUTH, MZ_ROLE_MEMBERS, MZ_ROLE_PARAMETERS, MZ_ROLES, MZ_SCHEMAS, - MZ_SECRETS, MZ_SESSIONS, MZ_SINKS, MZ_SOURCE_REFERENCES, MZ_SOURCES, - MZ_SQL_SERVER_SOURCE_TABLES, MZ_SSH_TUNNEL_CONNECTIONS, MZ_STORAGE_USAGE_BY_SHARD, - MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, MZ_TABLES, MZ_TYPE_PG_METADATA, MZ_TYPES, MZ_VIEWS, - MZ_WEBHOOKS_SOURCES, + MZ_PSEUDO_TYPES, MZ_REPLACEMENT_MATERIALIZED_VIEWS, MZ_ROLE_AUTH, MZ_ROLE_MEMBERS, + MZ_ROLE_PARAMETERS, MZ_ROLES, MZ_SCHEMAS, MZ_SECRETS, MZ_SESSIONS, MZ_SINKS, + MZ_SOURCE_REFERENCES, MZ_SOURCES, MZ_SQL_SERVER_SOURCE_TABLES, MZ_SSH_TUNNEL_CONNECTIONS, + MZ_STORAGE_USAGE_BY_SHARD, MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, MZ_TABLES, + MZ_TYPE_PG_METADATA, MZ_TYPES, MZ_VIEWS, MZ_WEBHOOKS_SOURCES, }; use mz_catalog::config::AwsPrincipalContext; use mz_catalog::durable::SourceReferences; use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, ClusterVariant, Connection, ContinualTask, DataSourceDesc, Func, - Index, MaterializedView, Sink, Table, TableDataSource, Type, View, + Index, MaterializedView, ReplacementMaterializedView, Sink, Table, TableDataSource, Type, View, }; use mz_controller::clusters::{ ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaLocation, @@ -55,7 +55,7 @@ use mz_repr::adt::jsonb::Jsonb; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem, PrivilegeMap}; use mz_repr::adt::regex; use mz_repr::network_policy_id::NetworkPolicyId; -use mz_repr::refresh_schedule::RefreshEvery; +use mz_repr::refresh_schedule::{RefreshEvery, RefreshSchedule}; use mz_repr::role_id::RoleId; use mz_repr::{CatalogItemId, Datum, Diff, GlobalId, Row, RowPacker, SqlScalarType, Timestamp}; use mz_sql::ast::{ContinualTaskStmt, CreateIndexStatement, Statement, UnresolvedItemName}; @@ -818,6 +818,10 @@ impl CatalogState { CatalogItem::ContinualTask(ct) => self.pack_continual_task_update( id, oid, schema_id, name, owner_id, privileges, ct, diff, ), + CatalogItem::ReplacementMaterializedView(mview) => self + .pack_replacement_materialized_view_update( + id, oid, schema_id, name, owner_id, privileges, mview, diff, + ), }; if !entry.item().is_temporary() { @@ -1480,7 +1484,23 @@ impl CatalogState { diff, )); - if let Some(refresh_schedule) = &mview.refresh_schedule { + Self::pack_refresh_strategy_update( + &id, + mview.refresh_schedule.as_ref(), + diff, + &mut updates, + ); + + updates + } + + fn pack_refresh_strategy_update( + id: &CatalogItemId, + refresh_schedule: Option<&RefreshSchedule>, + diff: Diff, + updates: &mut Vec>, + ) { + if let Some(refresh_schedule) = refresh_schedule { // This can't be `ON COMMIT`, because that is represented by a `None` instead of an // empty `RefreshSchedule`. assert!(!refresh_schedule.is_empty()); @@ -1537,6 +1557,65 @@ impl CatalogState { diff, )); } + } + + fn pack_replacement_materialized_view_update( + &self, + id: CatalogItemId, + oid: u32, + schema_id: &SchemaSpecifier, + name: &str, + owner_id: &RoleId, + privileges: Datum, + mview: &ReplacementMaterializedView, + diff: Diff, + ) -> Vec> { + let create_stmt = mz_sql::parse::parse(&mview.create_sql) + .unwrap_or_else(|e| { + panic!( + "create_sql cannot be invalid: `{}` --- error: `{}`", + mview.create_sql, e + ) + }) + .into_element() + .ast; + let query_string = match &create_stmt { + Statement::CreateReplacementMaterializedView(stmt) => { + let mut query_string = stmt.query.to_ast_string_stable(); + // PostgreSQL appends a semicolon in `pg_matviews.definition`, we + // do the same for compatibility's sake. + query_string.push(';'); + query_string + } + _ => unreachable!(), + }; + + let mut updates = Vec::new(); + + updates.push(BuiltinTableUpdate::row( + &*MZ_REPLACEMENT_MATERIALIZED_VIEWS, + Row::pack_slice(&[ + Datum::String(&id.to_string()), + Datum::UInt32(oid), + Datum::String(&mview.replaces.to_string()), + Datum::String(&schema_id.to_string()), + Datum::String(name), + Datum::String(&mview.cluster_id.to_string()), + Datum::String(&query_string), + Datum::String(&owner_id.to_string()), + privileges, + Datum::String(&mview.create_sql), + Datum::String(&create_stmt.to_ast_string_redacted()), + ]), + diff, + )); + + Self::pack_refresh_strategy_update( + &id, + mview.refresh_schedule.as_ref(), + diff, + &mut updates, + ); updates } @@ -2284,7 +2363,8 @@ impl CatalogState { | CommentObjectId::Connection(global_id) | CommentObjectId::Secret(global_id) | CommentObjectId::Type(global_id) - | CommentObjectId::ContinualTask(global_id) => global_id.to_string(), + | CommentObjectId::ContinualTask(global_id) + | CommentObjectId::ReplacementMaterializedView(global_id) => global_id.to_string(), CommentObjectId::Role(role_id) => role_id.to_string(), CommentObjectId::Database(database_id) => database_id.to_string(), CommentObjectId::Schema((_, schema_id)) => schema_id.to_string(), diff --git a/src/adapter/src/catalog/consistency.rs b/src/adapter/src/catalog/consistency.rs index daaa6ae5d3b28..ed7a763ab267c 100644 --- a/src/adapter/src/catalog/consistency.rs +++ b/src/adapter/src/catalog/consistency.rs @@ -274,7 +274,8 @@ impl CatalogState { | CommentObjectId::Connection(item_id) | CommentObjectId::Type(item_id) | CommentObjectId::Secret(item_id) - | CommentObjectId::ContinualTask(item_id) => { + | CommentObjectId::ContinualTask(item_id) + | CommentObjectId::ReplacementMaterializedView(item_id) => { let entry = self.entry_by_id.get(&item_id); match entry { None => comment_inconsistencies diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index b3fe318f75359..b5ddddf85fecd 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -893,7 +893,8 @@ fn add_new_remove_old_builtin_items_migration( | CatalogItemType::Func | CatalogItemType::Secret | CatalogItemType::Connection - | CatalogItemType::ContinualTask => continue, + | CatalogItemType::ContinualTask + | CatalogItemType::ReplacementMaterializedView => continue, }; deleted_comments.insert(comment_id); } diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index 368a8f639c7be..ccfd604dbc6c5 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -32,8 +32,8 @@ use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogCollectionEntry, CatalogEntry, CatalogItem, Cluster, ClusterReplica, CommentsMap, Connection, DataSourceDesc, Database, DefaultPrivileges, Index, MaterializedView, - NetworkPolicy, Role, RoleAuth, Schema, Secret, Sink, Source, SourceReferences, Table, - TableDataSource, Type, View, + NetworkPolicy, ReplacementMaterializedView, Role, RoleAuth, Schema, Secret, Sink, Source, + SourceReferences, Table, TableDataSource, Type, View, }; use mz_controller::clusters::{ ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaAllocation, ReplicaLocation, @@ -76,9 +76,9 @@ use mz_sql::names::{ ResolvedDatabaseSpecifier, ResolvedIds, SchemaId, SchemaSpecifier, SystemObjectId, }; use mz_sql::plan::{ - CreateConnectionPlan, CreateIndexPlan, CreateMaterializedViewPlan, CreateSecretPlan, - CreateSinkPlan, CreateSourcePlan, CreateTablePlan, CreateTypePlan, CreateViewPlan, Params, - Plan, PlanContext, + CreateConnectionPlan, CreateIndexPlan, CreateMaterializedViewPlan, + CreateReplacementMaterializedViewPlan, CreateSecretPlan, CreateSinkPlan, CreateSourcePlan, + CreateTablePlan, CreateTypePlan, CreateViewPlan, Params, Plan, PlanContext, }; use mz_sql::rbac; use mz_sql::session::metadata::SessionMetadata; @@ -423,7 +423,8 @@ impl CatalogState { item @ (CatalogItem::View(_) | CatalogItem::MaterializedView(_) | CatalogItem::Connection(_) - | CatalogItem::ContinualTask(_)) => { + | CatalogItem::ContinualTask(_) + | CatalogItem::ReplacementMaterializedView(_)) => { // TODO(jkosh44) Unclear if this table wants to include all uses or only references. for item_id in item.references().items() { self.introspection_dependencies_inner(*item_id, out); @@ -1452,6 +1453,86 @@ impl CatalogState { details, resolved_ids, }), + Plan::CreateReplacementMaterializedView(CreateReplacementMaterializedViewPlan { + materialized_view, + replaces, + .. + }) => { + // Collect optimizer parameters. + let optimizer_config = + optimize::OptimizerConfig::from(session_catalog.system_vars()); + let previous_exprs = previous_item.map(|item| match item { + CatalogItem::ReplacementMaterializedView(materialized_view) => { + (materialized_view.raw_expr, materialized_view.optimized_expr) + } + item => { + unreachable!("expected replacement materialized view, found: {item:#?}") + } + }); + + let (raw_expr, optimized_expr) = match (cached_expr, previous_exprs) { + (Some(local_expr), _) + if local_expr.optimizer_features == optimizer_config.features => + { + debug!("local expression cache hit for {global_id:?}"); + ( + Arc::new(materialized_view.expr), + Arc::new(local_expr.local_mir), + ) + } + // If the new expr is equivalent to the old expr, then we don't need to re-optimize. + (_, Some((raw_expr, optimized_expr))) + if *raw_expr == materialized_view.expr => + { + (Arc::clone(&raw_expr), Arc::clone(&optimized_expr)) + } + (cached_expr, _) => { + let optimizer_features = optimizer_config.features.clone(); + // TODO(aalexandrov): ideally this should be a materialized_view::Optimizer. + let mut optimizer = optimize::view::Optimizer::new(optimizer_config, None); + + let raw_expr = materialized_view.expr; + let optimized_expr = match optimizer.optimize(raw_expr.clone()) { + Ok(optimized_expr) => optimized_expr, + Err(err) => return Err((err.into(), cached_expr)), + }; + + uncached_expr = Some((optimized_expr.clone(), optimizer_features)); + + (Arc::new(raw_expr), Arc::new(optimized_expr)) + } + }; + let mut typ = optimized_expr.typ(); + for &i in &materialized_view.non_null_assertions { + typ.column_types[i].nullable = false; + } + let desc = RelationDesc::new(typ, materialized_view.column_names); + + let initial_as_of = materialized_view.as_of.map(Antichain::from_elem); + + // Resolve all item dependencies from the HIR expression. + let dependencies = raw_expr + .depends_on() + .into_iter() + .map(|gid| self.get_entry_by_global_id(&gid).id()) + .collect(); + + CatalogItem::ReplacementMaterializedView(ReplacementMaterializedView { + create_sql: materialized_view.create_sql, + global_id, + replaces, + raw_expr, + optimized_expr, + desc, + resolved_ids, + dependencies, + cluster_id: materialized_view.cluster_id, + non_null_assertions: materialized_view.non_null_assertions, + custom_logical_compaction_window: materialized_view.compaction_window, + refresh_schedule: materialized_view.refresh_schedule, + initial_as_of, + }) + } _ => { return Err(( Error::new(ErrorKind::Corruption { @@ -1786,7 +1867,8 @@ impl CatalogState { | CatalogItemType::Index | CatalogItemType::Secret | CatalogItemType::Connection - | CatalogItemType::ContinualTask => schema.items[builtin.name()], + | CatalogItemType::ContinualTask + | CatalogItemType::ReplacementMaterializedView => schema.items[builtin.name()], } } @@ -2195,6 +2277,9 @@ impl CatalogState { CatalogItemType::Type => CommentObjectId::Type(item_id), CatalogItemType::Secret => CommentObjectId::Secret(item_id), CatalogItemType::ContinualTask => CommentObjectId::ContinualTask(item_id), + CatalogItemType::ReplacementMaterializedView => { + CommentObjectId::ReplacementMaterializedView(item_id) + } } } ObjectId::Role(role_id) => CommentObjectId::Role(role_id), @@ -2607,7 +2692,8 @@ impl CatalogState { | CommentObjectId::Connection(id) | CommentObjectId::Type(id) | CommentObjectId::Secret(id) - | CommentObjectId::ContinualTask(id) => Some(*id), + | CommentObjectId::ContinualTask(id) + | CommentObjectId::ReplacementMaterializedView(id) => Some(*id), CommentObjectId::Role(_) | CommentObjectId::Database(_) | CommentObjectId::Schema(_) @@ -2637,7 +2723,8 @@ impl CatalogState { | CommentObjectId::Connection(id) | CommentObjectId::Type(id) | CommentObjectId::Secret(id) - | CommentObjectId::ContinualTask(id) => { + | CommentObjectId::ContinualTask(id) + | CommentObjectId::ReplacementMaterializedView(id) => { let item = self.get_entry(&id); let name = self.resolve_full_name(item.name(), Some(conn_id)); name.to_string() diff --git a/src/adapter/src/catalog/timeline.rs b/src/adapter/src/catalog/timeline.rs index e5ba67377056d..b943e3ba0c7a6 100644 --- a/src/adapter/src/catalog/timeline.rs +++ b/src/adapter/src/catalog/timeline.rs @@ -12,7 +12,9 @@ use std::collections::{BTreeMap, BTreeSet}; use itertools::Itertools; -use mz_catalog::memory::objects::{CatalogItem, ContinualTask, MaterializedView, View}; +use mz_catalog::memory::objects::{ + CatalogItem, ContinualTask, MaterializedView, ReplacementMaterializedView, View, +}; use mz_expr::CollectionPlan; use mz_ore::collections::CollectionExt; use mz_repr::{CatalogItemId, GlobalId}; @@ -82,7 +84,10 @@ impl Catalog { id_bundle.storage_ids.insert(source.global_id()); } CatalogItem::MaterializedView(mv) => { - id_bundle.storage_ids.insert(mv.global_id_writes()); + id_bundle.storage_ids.extend(mv.global_ids()); + } + CatalogItem::ReplacementMaterializedView(mv) => { + id_bundle.storage_ids.insert(mv.global_id()); } CatalogItem::ContinualTask(ct) => { id_bundle.storage_ids.insert(ct.global_id()); @@ -218,6 +223,23 @@ impl Catalog { .map(|gid| self.resolve_item_id(&gid)); ids.extend(item_ids); } + CatalogItem::ReplacementMaterializedView(ReplacementMaterializedView { + optimized_expr, + .. + }) => { + // In some cases the timestamp selected may not affect the answer to a + // query, but it may affect our ability to query the materialized view. + // Materialized views must durably materialize the result of a query, even + // for constant queries. If we choose a timestamp larger than the upper, + // which represents the current progress of the view, then the query will + // need to block and wait for the materialized view to advance. + timelines.insert(TimelineContext::TimestampDependent); + let item_ids = optimized_expr + .depends_on() + .into_iter() + .map(|gid| self.resolve_item_id(&gid)); + ids.extend(item_ids); + } CatalogItem::ContinualTask(ContinualTask { raw_expr, .. }) => { // See comment in MaterializedView timelines.insert(TimelineContext::TimestampDependent); diff --git a/src/adapter/src/catalog/transact.rs b/src/adapter/src/catalog/transact.rs index 73f5debb7b18b..0f58a3c181d2f 100644 --- a/src/adapter/src/catalog/transact.rs +++ b/src/adapter/src/catalog/transact.rs @@ -100,6 +100,12 @@ pub enum Op { typ: SqlColumnType, sql: RawDataType, }, + AlterMaterializedViewApplyReplacement { + id: CatalogItemId, + replacement_id: CatalogItemId, + cluster_id: ClusterId, + replaced_id: GlobalId, + }, CreateDatabase { name: String, owner_id: RoleId, @@ -391,18 +397,17 @@ impl Catalog { let drop_ids: BTreeSet = ops .iter() - .filter_map(|op| match op { + .flat_map(|op| match op { Op::DropObjects(drop_object_infos) => { let ids = drop_object_infos.iter().map(|info| info.to_object_id()); - let item_ids = ids.filter_map(|id| match id { + ids.filter_map(|id| match id { ObjectId::Item(id) => Some(id), _ => None, - }); - Some(item_ids) + }) + .collect::>() } - _ => None, + _ => vec![], }) - .flatten() .collect(); let temporary_drops = drop_ids .iter() @@ -769,6 +774,58 @@ impl Catalog { tx.update_item(id, new_entry.into())?; storage_collections_to_register.insert(new_global_id, shard_id); } + Op::AlterMaterializedViewApplyReplacement { + id, + replacement_id, + replaced_id: _, + cluster_id: _, + } => { + let mut new_entry = state.get_entry(&id).clone(); + let replacement = state.get_entry(&replacement_id); + + let CatalogItem::MaterializedView(mv) = &mut new_entry.item else { + return Err(AdapterError::Unsupported( + "applying replacements non-Materialized views", + )); + }; + let CatalogItem::ReplacementMaterializedView(rmv) = &replacement.item else { + return Err(AdapterError::Unsupported( + "applying replacements non-Materialized views", + )); + }; + + *mv = rmv.merge_into(mv); + + tx.update_item(id, new_entry.clone().into())?; + tx.remove_items(&BTreeSet::from([replacement_id]))?; + if Self::should_audit_log_item(replacement.item()) { + CatalogState::add_to_audit_log( + &state.system_configuration, + oracle_write_ts, + session, + tx, + audit_events, + EventType::Drop, + catalog_type_to_audit_object_type(replacement.item().typ()), + EventDetails::IdFullNameV1(IdFullNameV1 { + id: replacement_id.to_string(), + name: Self::full_name_detail(&state.resolve_full_name( + replacement.name(), + session.map(|session| session.conn_id()), + )), + }), + )?; + } + info!( + "applied {} {} ({}) on {} {} ({})", + replacement.item_type(), + state.resolve_full_name(replacement.name(), replacement.conn_id()), + replacement_id, + new_entry.item_type(), + state.resolve_full_name(new_entry.name(), new_entry.conn_id()), + id + ); + } Op::CreateDatabase { name, owner_id } => { let database_owner_privileges = vec![rbac::owner_privilege( mz_sql::catalog::ObjectType::Database, @@ -1088,6 +1145,22 @@ impl Catalog { CatalogItem::Sink(sink) => { storage_collections_to_create.insert(sink.global_id()); } + CatalogItem::ReplacementMaterializedView(rmv) => { + let mut mv = state.get_entry(&rmv.replaces).clone(); + // All versions of a table share the same shard, so it shouldn't matter what + // GlobalId we use here. + let shard_id = state + .storage_metadata() + .get_collection_shard(mv.latest_global_id())?; + + // TODO(alter-mv): Support adding columns to materialized views. + let CatalogItem::MaterializedView(_target_mv) = &mut mv.item else { + return Err(AdapterError::Unsupported( + "replacing materialized view with different type", + )); + }; + storage_collections_to_register.insert(rmv.global_id(), shard_id); + } CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Index(_) diff --git a/src/adapter/src/command.rs b/src/adapter/src/command.rs index 32c62dc7742ed..8399a5988a997 100644 --- a/src/adapter/src/command.rs +++ b/src/adapter/src/command.rs @@ -350,6 +350,8 @@ pub enum ExecuteResponse { CreatedType, /// The requested network policy was created. CreatedNetworkPolicy, + /// The requested replacement materialized view was created. + CreatedReplacementMaterializedView, /// The requested prepared statement was removed. Deallocate { all: bool }, /// The requested cursor was declared. @@ -518,6 +520,9 @@ impl TryInto for ExecuteResponseKind { ExecuteResponseKind::CreatedNetworkPolicy => Ok(ExecuteResponse::CreatedNetworkPolicy), ExecuteResponseKind::CreatedContinualTask => Ok(ExecuteResponse::CreatedContinualTask), ExecuteResponseKind::CreatedType => Ok(ExecuteResponse::CreatedType), + ExecuteResponseKind::CreatedReplacementMaterializedView => { + Ok(ExecuteResponse::CreatedReplacementMaterializedView) + } ExecuteResponseKind::Deallocate => Err(()), ExecuteResponseKind::DeclaredCursor => Ok(ExecuteResponse::DeclaredCursor), ExecuteResponseKind::Deleted => Err(()), @@ -581,6 +586,9 @@ impl ExecuteResponse { CreatedContinualTask { .. } => Some("CREATE CONTINUAL TASK".into()), CreatedType => Some("CREATE TYPE".into()), CreatedNetworkPolicy => Some("CREATE NETWORKPOLICY".into()), + CreatedReplacementMaterializedView { .. } => { + Some("CREATE REPLACEMENT MATERIALIZED VIEW".into()) + } Deallocate { all } => Some(format!("DEALLOCATE{}", if *all { " ALL" } else { "" })), DeclaredCursor => Some("DECLARE CURSOR".into()), Deleted(n) => Some(format!("DELETE {}", n)), @@ -635,6 +643,7 @@ impl ExecuteResponse { | AlterClusterReplicaRename | AlterOwner | AlterItemRename + | AlterMaterializedViewApplyReplacement | AlterRetainHistory | AlterNoop | AlterSchemaRename @@ -671,6 +680,7 @@ impl ExecuteResponse { CreateContinualTask => &[CreatedContinualTask], CreateIndex => &[CreatedIndex], CreateType => &[CreatedType], + CreateReplacementMaterializedView => &[CreatedReplacementMaterializedView], PlanKind::Deallocate => &[ExecuteResponseKind::Deallocate], CreateNetworkPolicy => &[CreatedNetworkPolicy], Declare => &[DeclaredCursor], diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 200bc1f061d60..a353c0f33706c 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -305,6 +305,11 @@ pub enum Message { span: Span, stage: CreateMaterializedViewStage, }, + CreateReplacementMaterializedViewStageReady { + ctx: ExecuteContext, + span: Span, + stage: CreateReplacementMaterializedViewStage, + }, SubscribeStageReady { ctx: ExecuteContext, span: Span, @@ -398,6 +403,9 @@ impl Message { Message::CreateMaterializedViewStageReady { .. } => { "create_materialized_view_stage_ready" } + Message::CreateReplacementMaterializedViewStageReady { .. } => { + "create_replacement_materialized_view_stage_ready" + } Message::SubscribeStageReady { .. } => "subscribe_stage_ready", Message::IntrospectionSubscribeStageReady { .. } => { "introspection_subscribe_stage_ready" @@ -835,6 +843,33 @@ pub struct CreateMaterializedViewExplain { explain_ctx: ExplainPlanContext, } +#[derive(Debug)] +pub enum CreateReplacementMaterializedViewStage { + Optimize(CreateReplacementMaterializedViewOptimize), + Finish(CreateReplacementMaterializedViewFinish), +} + +#[derive(Debug)] +pub struct CreateReplacementMaterializedViewOptimize { + validity: PlanValidity, + plan: plan::CreateReplacementMaterializedViewPlan, + resolved_ids: ResolvedIds, +} + +#[derive(Debug)] +pub struct CreateReplacementMaterializedViewFinish { + /// The ID of this Replacement Materialized View in the Catalog. + item_id: CatalogItemId, + /// The ID of the durable pTVC backing this Materialized View. + global_id: GlobalId, + validity: PlanValidity, + plan: plan::CreateReplacementMaterializedViewPlan, + resolved_ids: ResolvedIds, + local_mir_plan: optimize::materialized_view::LocalMirPlan, + global_mir_plan: optimize::materialized_view::GlobalMirPlan, + global_lir_plan: optimize::materialized_view::GlobalLirPlan, +} + #[derive(Debug)] pub enum SubscribeStage { OptimizeMir(SubscribeOptimizeMir), @@ -2155,6 +2190,52 @@ impl Coordinator { self.ship_dataflow(df_desc, ct.cluster_id, None).await; self.allow_writes(ct.cluster_id, ct.global_id()); } + CatalogItem::ReplacementMaterializedView(mview) => { + policies_to_set + .entry( + policy + .expect("replacement materialized views have a compaction window"), + ) + .or_insert_with(Default::default) + .storage_ids + .insert(mview.global_id()); + + let mut df_desc = self + .catalog() + .try_get_physical_plan(&mview.global_id()) + .expect("added in `bootstrap_dataflow_plans`") + .clone(); + + if let Some(initial_as_of) = mview.initial_as_of.clone() { + df_desc.set_initial_as_of(initial_as_of); + } + + // If we have a refresh schedule that has a last refresh, then set the `until` to the last refresh. + let until = mview + .refresh_schedule + .as_ref() + .and_then(|s| s.last_refresh()) + .and_then(|r| r.try_step_forward()); + if let Some(until) = until { + df_desc.until.meet_assign(&Antichain::from_elem(until)); + } + + let df_meta = self + .catalog() + .try_get_dataflow_metainfo(&mview.global_id()) + .expect("added in `bootstrap_dataflow_plans`"); + + if self.catalog().state().system_config().enable_mz_notices() { + // Collect optimization hint updates. + self.catalog().state().pack_optimizer_notices( + &mut builtin_table_updates, + df_meta.optimizer_notices.iter(), + Diff::ONE, + ); + } + + self.ship_dataflow(df_desc, mview.cluster_id, None).await; + } // Nothing to do for these cases CatalogItem::Log(_) | CatalogItem::Type(_) @@ -2807,14 +2888,15 @@ impl Coordinator { collections.extend(collection_descs); compute_collections.push((mv.global_id_writes(), mv.desc.latest())); } + CatalogItem::ReplacementMaterializedView(rp) => { + let collection_desc = + CollectionDescription::for_other(rp.desc.clone(), rp.initial_as_of.clone()); + collections.push((rp.global_id(), collection_desc)); + compute_collections.push((rp.global_id(), rp.desc.clone())); + } CatalogItem::ContinualTask(ct) => { - let collection_desc = CollectionDescription { - desc: ct.desc.clone(), - data_source: DataSource::Other, - since: ct.initial_as_of.clone(), - status_collection_id: None, - timeline: None, - }; + let collection_desc = + CollectionDescription::for_other(ct.desc.clone(), ct.initial_as_of.clone()); if ct.global_id().is_system() && collection_desc.since.is_none() { // We need a non-0 since to make as_of selection work. Fill it in below with // the `bootstrap_builtin_continual_tasks` call, which can only be run after @@ -3218,6 +3300,100 @@ impl Coordinator { compute_instance.insert_collection(ct.global_id()); } + CatalogItem::ReplacementMaterializedView(mv) => { + // Collect optimizer parameters. + let compute_instance = + instance_snapshots.entry(mv.cluster_id).or_insert_with(|| { + self.instance_snapshot(mv.cluster_id) + .expect("compute instance exists") + }); + let global_id = mv.global_id(); + + let (optimized_plan, physical_plan, metainfo) = + match cached_global_exprs.remove(&global_id) { + Some(global_expressions) + if global_expressions.optimizer_features + == optimizer_config.features => + { + debug!("global expression cache hit for {global_id:?}"); + ( + global_expressions.global_mir, + global_expressions.physical_plan, + global_expressions.dataflow_metainfos, + ) + } + Some(_) | None => { + let (_, internal_view_id) = self.allocate_transient_id(); + let debug_name = self + .catalog() + .resolve_full_name(entry.name(), None) + .to_string(); + let force_non_monotonic = Default::default(); + + let (optimized_plan, global_lir_plan) = { + // Build an optimizer for this MATERIALIZED VIEW. + let mut optimizer = optimize::materialized_view::Optimizer::new( + self.owned_catalog().as_optimizer_catalog(), + compute_instance.clone(), + global_id, + internal_view_id, + mv.desc.iter_names().cloned().collect(), + mv.non_null_assertions.clone(), + mv.refresh_schedule.clone(), + debug_name, + optimizer_config.clone(), + self.optimizer_metrics(), + force_non_monotonic, + ); + + // MIR ⇒ MIR optimization (global) + let global_mir_plan = + optimizer.optimize(mv.optimized_expr.as_ref().clone())?; + let optimized_plan = global_mir_plan.df_desc().clone(); + + // MIR ⇒ LIR lowering and LIR ⇒ LIR optimization (global) + let global_lir_plan = optimizer.optimize(global_mir_plan)?; + + (optimized_plan, global_lir_plan) + }; + + let (physical_plan, metainfo) = global_lir_plan.unapply(); + let metainfo = { + // Pre-allocate a vector of transient GlobalIds for each notice. + let notice_ids = + std::iter::repeat_with(|| self.allocate_transient_id()) + .map(|(_item_id, global_id)| global_id) + .take(metainfo.optimizer_notices.len()) + .collect::>(); + // Return a metainfo with rendered notices. + self.catalog().render_notices( + metainfo, + notice_ids, + Some(mv.global_id()), + ) + }; + uncached_expressions.insert( + global_id, + GlobalExpressions { + global_mir: optimized_plan.clone(), + physical_plan: physical_plan.clone(), + dataflow_metainfos: metainfo.clone(), + optimizer_features: OptimizerFeatures::from( + self.catalog().system_config(), + ), + }, + ); + (optimized_plan, physical_plan, metainfo) + } + }; + + let catalog = self.catalog_mut(); + catalog.set_optimized_plan(mv.global_id(), optimized_plan); + catalog.set_physical_plan(mv.global_id(), physical_plan); + catalog.set_dataflow_metainfo(mv.global_id(), metainfo); + + compute_instance.insert_collection(mv.global_id()); + } _ => (), } } @@ -3243,6 +3419,7 @@ impl Coordinator { CatalogItem::Index(idx) => idx.global_id(), CatalogItem::MaterializedView(mv) => mv.global_id_writes(), CatalogItem::ContinualTask(ct) => ct.global_id(), + CatalogItem::ReplacementMaterializedView(mv) => mv.global_id(), CatalogItem::Table(_) | CatalogItem::Source(_) | CatalogItem::Log(_) diff --git a/src/adapter/src/coord/appends.rs b/src/adapter/src/coord/appends.rs index 048c06bfd4faf..bb3e3cf130f0c 100644 --- a/src/adapter/src/coord/appends.rs +++ b/src/adapter/src/coord/appends.rs @@ -961,6 +961,7 @@ pub(crate) fn waiting_on_startup_appends( | Plan::CreateMaterializedView(_) | Plan::CreateIndex(_) | Plan::CreateType(_) + | Plan::CreateReplacementMaterializedView(_) | Plan::Comment(_) | Plan::DiscardTemp | Plan::DiscardAll @@ -990,6 +991,7 @@ pub(crate) fn waiting_on_startup_appends( | Plan::AlterClusterReplicaRename(_) | Plan::AlterCluster(_) | Plan::AlterConnection(_) + | Plan::AlterMaterializedViewApplyReplacement(_) | Plan::AlterSource(_) | Plan::AlterSetCluster(_) | Plan::AlterItemRename(_) diff --git a/src/adapter/src/coord/catalog_serving.rs b/src/adapter/src/coord/catalog_serving.rs index ede6db25a3b22..77b391093be3b 100644 --- a/src/adapter/src/coord/catalog_serving.rs +++ b/src/adapter/src/coord/catalog_serving.rs @@ -85,6 +85,7 @@ pub fn auto_run_on_catalog_server<'a, 's, 'p>( | Plan::CreateMaterializedView(_) | Plan::CreateIndex(_) | Plan::CreateType(_) + | Plan::CreateReplacementMaterializedView(_) | Plan::Comment(_) | Plan::DiscardTemp | Plan::DiscardAll @@ -114,6 +115,7 @@ pub fn auto_run_on_catalog_server<'a, 's, 'p>( | Plan::AlterClusterReplicaRename(_) | Plan::AlterCluster(_) | Plan::AlterConnection(_) + | Plan::AlterMaterializedViewApplyReplacement(_) | Plan::AlterSource(_) | Plan::AlterSetCluster(_) | Plan::AlterItemRename(_) diff --git a/src/adapter/src/coord/command_handler.rs b/src/adapter/src/coord/command_handler.rs index 549efa3cf444a..74cc73ac0140e 100644 --- a/src/adapter/src/coord/command_handler.rs +++ b/src/adapter/src/coord/command_handler.rs @@ -929,6 +929,7 @@ impl Coordinator { | Statement::AlterConnection(_) | Statement::AlterDefaultPrivileges(_) | Statement::AlterIndex(_) + | Statement::AlterMaterializedViewApplyReplacement(_) | Statement::AlterSetCluster(_) | Statement::AlterOwner(_) | Statement::AlterRetainHistory(_) @@ -958,6 +959,7 @@ impl Coordinator { | Statement::CreateView(_) | Statement::CreateWebhookSource(_) | Statement::CreateNetworkPolicy(_) + | Statement::CreateReplacementMaterializedView(_) | Statement::Delete(_) | Statement::DropObjects(_) | Statement::DropOwned(_) diff --git a/src/adapter/src/coord/ddl.rs b/src/adapter/src/coord/ddl.rs index 223595fd73324..9919db5688d6b 100644 --- a/src/adapter/src/coord/ddl.rs +++ b/src/adapter/src/coord/ddl.rs @@ -216,6 +216,7 @@ impl Coordinator { let mut storage_sink_gids_to_drop = vec![]; let mut indexes_to_drop = vec![]; let mut materialized_views_to_drop = vec![]; + let mut materialized_views_to_drop_compute = vec![]; let mut continual_tasks_to_drop = vec![]; let mut views_to_drop = vec![]; let mut replication_slots_to_drop: Vec<(PostgresConnection, String)> = vec![]; @@ -308,6 +309,10 @@ impl Coordinator { _ => (), } } + CatalogItem::ReplacementMaterializedView(rmv) => { + materialized_views_to_drop_compute + .push((rmv.cluster_id, rmv.global_id())); + } _ => (), } } @@ -413,6 +418,13 @@ impl Coordinator { config.location.num_processes(), )); } + catalog::Op::AlterMaterializedViewApplyReplacement { + cluster_id, + replaced_id, + .. + } => { + materialized_views_to_drop_compute.push((*cluster_id, *replaced_id)); + } _ => (), } } @@ -500,11 +512,17 @@ impl Coordinator { .chain(storage_sink_gids_to_drop.iter().copied()) .chain(table_gids_to_drop.iter().map(|(_, gid)| *gid)) .chain(materialized_views_to_drop.iter().map(|(_, gid)| *gid)) + .chain( + materialized_views_to_drop_compute + .iter() + .map(|(_, gid)| *gid), + ) .chain(continual_tasks_to_drop.iter().map(|(_, _, gid)| *gid)); let compute_ids_to_drop = indexes_to_drop .iter() .copied() .chain(materialized_views_to_drop.iter().copied()) + .chain(materialized_views_to_drop_compute.iter().copied()) .chain( continual_tasks_to_drop .iter() @@ -661,6 +679,9 @@ impl Coordinator { if !materialized_views_to_drop.is_empty() { self.drop_materialized_views(materialized_views_to_drop); } + if !materialized_views_to_drop_compute.is_empty() { + self.drop_materialized_views_compute_only(materialized_views_to_drop_compute); + } if !continual_tasks_to_drop.is_empty() { self.drop_continual_tasks(continual_tasks_to_drop); } @@ -1046,13 +1067,14 @@ impl Coordinator { } } - /// A convenience method for dropping materialized views. - fn drop_materialized_views(&mut self, mviews: Vec<(ClusterId, GlobalId)>) { + /// A convenience method for dropping the compute part of materialized views. + fn drop_materialized_views_compute_only(&mut self, mviews: I) + where + I: IntoIterator, + { let mut by_cluster: BTreeMap<_, Vec<_>> = BTreeMap::new(); - let mut mv_gids = Vec::new(); for (cluster_id, gid) in mviews { by_cluster.entry(cluster_id).or_default().push(gid); - mv_gids.push(gid); } // Drop compute sinks. @@ -1065,6 +1087,13 @@ impl Coordinator { .unwrap_or_terminate("cannot fail to drop collections"); } } + } + + /// A convenience method for dropping materialized views. + fn drop_materialized_views(&mut self, mviews: Vec<(ClusterId, GlobalId)>) { + self.drop_materialized_views_compute_only(mviews.iter().cloned()); + + let mv_gids = mviews.into_iter().map(|(_cluster_id, gid)| gid).collect(); // Drop storage resources. let storage_metadata = self.catalog.state().storage_metadata(); @@ -1429,6 +1458,9 @@ impl Coordinator { CatalogItem::ContinualTask(_) => { new_continual_tasks += 1; } + CatalogItem::ReplacementMaterializedView(_) => { + new_materialized_views += 1; + } CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Index(_) @@ -1511,6 +1543,9 @@ impl Coordinator { CatalogItem::ContinualTask(_) => { new_continual_tasks -= 1; } + CatalogItem::ReplacementMaterializedView(_) => { + new_materialized_views -= 1; + } CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Index(_) @@ -1546,8 +1581,19 @@ impl Coordinator { | CatalogItem::Index(_) | CatalogItem::Type(_) | CatalogItem::Func(_) - | CatalogItem::ContinualTask(_) => {} + | CatalogItem::ContinualTask(_) + | CatalogItem::ReplacementMaterializedView(_) => {} }, + Op::AlterMaterializedViewApplyReplacement { replacement_id, .. } => { + let entry = self.catalog().get_entry(replacement_id); + *new_objects_per_schema + .entry(( + entry.name().qualifiers.database_spec.clone(), + entry.name().qualifiers.schema_spec.clone(), + )) + .or_insert(0) -= 1; + new_materialized_views -= 1; + } Op::AlterRole { .. } | Op::AlterRetainHistory { .. } | Op::AlterNetworkPolicy { .. } diff --git a/src/adapter/src/coord/indexes.rs b/src/adapter/src/coord/indexes.rs index 1b313131bd37d..c760c5b9d634f 100644 --- a/src/adapter/src/coord/indexes.rs +++ b/src/adapter/src/coord/indexes.rs @@ -72,7 +72,8 @@ impl DataflowBuilder<'_> { | CatalogItem::Type(_) | CatalogItem::Func(_) | CatalogItem::Secret(_) - | CatalogItem::Connection(_) => { + | CatalogItem::Connection(_) + | CatalogItem::ReplacementMaterializedView(_) => { // Non-indexable thing; no work to do. } } diff --git a/src/adapter/src/coord/message_handler.rs b/src/adapter/src/coord/message_handler.rs index 804e3c762e717..2b4a86bf98527 100644 --- a/src/adapter/src/coord/message_handler.rs +++ b/src/adapter/src/coord/message_handler.rs @@ -161,6 +161,9 @@ impl Coordinator { Message::CreateMaterializedViewStageReady { ctx, span, stage } => { self.sequence_staged(ctx, span, stage).boxed_local().await; } + Message::CreateReplacementMaterializedViewStageReady { ctx, span, stage } => { + self.sequence_staged(ctx, span, stage).boxed_local().await; + } Message::SubscribeStageReady { ctx, span, stage } => { self.sequence_staged(ctx, span, stage).boxed_local().await; } diff --git a/src/adapter/src/coord/sequencer.rs b/src/adapter/src/coord/sequencer.rs index 046b5444b488b..a4a75ba723a8e 100644 --- a/src/adapter/src/coord/sequencer.rs +++ b/src/adapter/src/coord/sequencer.rs @@ -276,6 +276,10 @@ impl Coordinator { .await; ctx.retire(res); } + Plan::CreateReplacementMaterializedView(plan) => { + self.sequence_create_replacement_materialized_view(ctx, plan, resolved_ids) + .await; + } Plan::Comment(plan) => { let result = self.sequence_comment_on(ctx.session(), plan).await; ctx.retire(result); @@ -460,6 +464,12 @@ impl Coordinator { Plan::AlterConnection(plan) => { self.sequence_alter_connection(ctx, plan).await; } + Plan::AlterMaterializedViewApplyReplacement(plan) => { + let result = self + .sequence_alter_materialized_view_apply_replacement(&mut ctx, plan) + .await; + ctx.retire(result); + } Plan::AlterSetCluster(plan) => { let result = self.sequence_alter_set_cluster(ctx.session(), plan).await; ctx.retire(result); diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index ff844043eb442..293f10fe54fdf 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -128,6 +128,7 @@ mod create_materialized_view; mod create_view; mod explain_timestamp; mod peek; +mod replace_materialized_view; mod secret; mod subscribe; @@ -3031,7 +3032,11 @@ impl Coordinator { } } match entry.item().typ() { - typ @ (Func | View | MaterializedView | ContinualTask) => { + typ @ (Func + | View + | MaterializedView + | ContinualTask + | ReplacementMaterializedView) => { ids_to_check.extend(entry.uses()); let valid_id = id.is_user() || matches!(typ, Func); valid_id @@ -3417,7 +3422,8 @@ impl Coordinator { | CatalogItem::Type(_) | CatalogItem::Func(_) | CatalogItem::Secret(_) - | CatalogItem::Connection(_) => unreachable!(), + | CatalogItem::Connection(_) + | CatalogItem::ReplacementMaterializedView(_) => unreachable!(), }; match cluster { Some(cluster) => { diff --git a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs index 333fecce291d7..3fd53f5bdb003 100644 --- a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs +++ b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs @@ -13,6 +13,7 @@ use maplit::btreemap; use maplit::btreeset; use mz_adapter_types::compaction::CompactionWindow; use mz_catalog::memory::objects::{CatalogItem, MaterializedView}; +use mz_controller_types::ClusterId; use mz_expr::{CollectionPlan, ResultSpec}; use mz_ore::collections::CollectionExt; use mz_ore::instrument; @@ -21,11 +22,14 @@ use mz_repr::explain::{ExprHumanizerExt, TransientItem}; use mz_repr::optimize::OptimizerFeatures; use mz_repr::optimize::OverrideFrom; use mz_repr::refresh_schedule::RefreshSchedule; -use mz_repr::{CatalogItemId, Datum, RelationVersion, Row, VersionedRelationDesc}; +use mz_repr::{ + CatalogItemId, ColumnName, Datum, GlobalId, RelationVersion, Row, VersionedRelationDesc, +}; use mz_sql::ast::ExplainStage; use mz_sql::catalog::CatalogError; -use mz_sql::names::ResolvedIds; +use mz_sql::names::{QualifiedItemName, ResolvedIds}; use mz_sql::plan; +use mz_sql::plan::HirRelationExpr; use mz_sql::session::metadata::SessionMetadata; use mz_sql_parser::ast; use mz_sql_parser::ast::display::AstDisplay; @@ -47,6 +51,7 @@ use crate::explain::explain_dataflow; use crate::explain::explain_plan; use crate::explain::optimizer_trace::OptimizerTrace; use crate::optimize::dataflows::dataflow_import_id_bundle; +use crate::optimize::materialized_view::{GlobalLirPlan, GlobalMirPlan, LocalMirPlan, Optimizer}; use crate::optimize::{self, Optimize}; use crate::session::Session; use crate::util::ResultExt; @@ -335,6 +340,41 @@ impl Coordinator { .. } = &plan; + let validity = self.create_materialized_view_validate_inner( + session, + &resolved_ids, + expr, + cluster_id, + refresh_schedule, + ambiguous_columns, + &explain_ctx, + )?; + + Ok(CreateMaterializedViewStage::Optimize( + CreateMaterializedViewOptimize { + validity, + plan, + resolved_ids, + explain_ctx, + }, + )) + } + + /// Validates that the given materialized view can be created. + /// + /// Shared with replacement materialized views. + pub(super) fn create_materialized_view_validate_inner( + &self, + session: &Session, + resolved_ids: &ResolvedIds, + expr: &HirRelationExpr, + cluster_id: &ClusterId, + refresh_schedule: &Option, + ambiguous_columns: &bool, + // An optional context set iff the state machine is initiated from + // sequencing an EXPLAIN for this statement. + explain_ctx: &ExplainContext, + ) -> Result { // Validate any references in the materialized view's expression. We do // this on the unoptimized plan to better reflect what the user typed. // We want to reject queries that depend on log sources, for example, @@ -393,15 +433,7 @@ impl Coordinator { } } } - - Ok(CreateMaterializedViewStage::Optimize( - CreateMaterializedViewOptimize { - validity, - plan, - resolved_ids, - explain_ctx, - }, - )) + Ok(validity) } #[instrument] @@ -427,63 +459,29 @@ impl Coordinator { .. } = &plan; - // Collect optimizer parameters. - let compute_instance = self - .instance_snapshot(*cluster_id) - .expect("compute instance does not exist"); - let (item_id, global_id) = if let ExplainContext::None = explain_ctx { - let id_ts = self.get_catalog_write_ts().await; - self.catalog().allocate_user_id(id_ts).await? - } else { - self.allocate_transient_id() - }; - - let (_, view_id) = self.allocate_transient_id(); - let debug_name = self.catalog().resolve_full_name(name, None).to_string(); - let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) - .override_from(&self.catalog.get_cluster(*cluster_id).config.features()) - .override_from(&explain_ctx); - let force_non_monotonic = Default::default(); - - // Build an optimizer for this MATERIALIZED VIEW. - let mut optimizer = optimize::materialized_view::Optimizer::new( - self.owned_catalog().as_optimizer_catalog(), - compute_instance, - global_id, - view_id, - column_names.clone(), - non_null_assertions.clone(), - refresh_schedule.clone(), - debug_name, - optimizer_config, - self.optimizer_metrics(), - force_non_monotonic, - ); + let (item_id, global_id, optimizer) = self + .create_materialized_view_optimize_common( + name, + column_names.clone(), + cluster_id, + non_null_assertions.clone(), + refresh_schedule.clone(), + &explain_ctx, + ) + .await?; let span = Span::current(); Ok(StageResult::Handle(mz_ore::task::spawn_blocking( || "optimize create materialized view", move || { span.in_scope(|| { - let mut pipeline = || -> Result<( - optimize::materialized_view::LocalMirPlan, - optimize::materialized_view::GlobalMirPlan, - optimize::materialized_view::GlobalLirPlan, - ), AdapterError> { - let _dispatch_guard = explain_ctx.dispatch_guard(); - - let raw_expr = plan.materialized_view.expr.clone(); - - // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local and global) - let local_mir_plan = optimizer.catch_unwind_optimize(raw_expr)?; - let global_mir_plan = optimizer.catch_unwind_optimize(local_mir_plan.clone())?; - // MIR ⇒ LIR lowering and LIR ⇒ LIR optimization (global) - let global_lir_plan = optimizer.catch_unwind_optimize(global_mir_plan.clone())?; - - Ok((local_mir_plan, global_mir_plan, global_lir_plan)) - }; + let raw_expr = plan.materialized_view.expr.clone(); - let stage = match pipeline() { + let stage = match Self::create_materialized_view_call_optimizer( + optimizer, + raw_expr, + &explain_ctx, + ) { Ok((local_mir_plan, global_mir_plan, global_lir_plan)) => { if let ExplainContext::Plan(explain_ctx) = explain_ctx { let (_, df_meta) = global_lir_plan.unapply(); @@ -544,6 +542,70 @@ impl Coordinator { ))) } + /// Create an optimizer to transform the materialized view. + /// + /// Shared with replacement materialized views. + pub(super) async fn create_materialized_view_optimize_common( + &mut self, + name: &QualifiedItemName, + column_names: Vec, + cluster_id: &ClusterId, + non_null_assertions: Vec, + refresh_schedule: Option, + explain_ctx: &ExplainContext, + ) -> Result<(CatalogItemId, GlobalId, Optimizer), AdapterError> { + // Collect optimizer parameters. + let compute_instance = self + .instance_snapshot(*cluster_id) + .expect("compute instance does not exist"); + let (item_id, global_id) = if let ExplainContext::None = explain_ctx { + let id_ts = self.get_catalog_write_ts().await; + self.catalog().allocate_user_id(id_ts).await? + } else { + self.allocate_transient_id() + }; + + let (_, view_id) = self.allocate_transient_id(); + let debug_name = self.catalog().resolve_full_name(name, None).to_string(); + let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&self.catalog.get_cluster(*cluster_id).config.features()) + .override_from(explain_ctx); + let force_non_monotonic = Default::default(); + + // Build an optimizer for this MATERIALIZED VIEW. + let optimizer = Optimizer::new( + self.owned_catalog().as_optimizer_catalog(), + compute_instance, + global_id, + view_id, + column_names, + non_null_assertions, + refresh_schedule, + debug_name, + optimizer_config, + self.optimizer_metrics(), + force_non_monotonic, + ); + Ok((item_id, global_id, optimizer)) + } + + /// Call an optimizer to optimize a materialized view. + pub(super) fn create_materialized_view_call_optimizer( + mut optimizer: Optimizer, + raw_expr: HirRelationExpr, + explain_ctx: &ExplainContext, + ) -> Result<(LocalMirPlan, GlobalMirPlan, GlobalLirPlan), AdapterError> { + let _dispatch_guard = explain_ctx.dispatch_guard(); + + // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local and global) + let local_mir_plan = optimizer.catch_unwind_optimize(raw_expr)?; + let global_mir_plan = optimizer.catch_unwind_optimize(local_mir_plan.clone())?; + // MIR ⇒ LIR lowering and LIR ⇒ LIR optimization (global) + let global_lir_plan = optimizer.catch_unwind_optimize(global_mir_plan.clone())?; + + Ok((local_mir_plan, global_mir_plan, global_lir_plan)) + } + #[instrument] async fn create_materialized_view_finish( &mut self, @@ -747,7 +809,7 @@ impl Coordinator { /// Select the initial `dataflow_as_of`, `storage_as_of`, and `until` frontiers for a /// materialized view. - fn select_timestamps( + pub(super) fn select_timestamps( &self, id_bundle: CollectionIdBundle, refresh_schedule: Option<&RefreshSchedule>, diff --git a/src/adapter/src/coord/sequencer/inner/peek.rs b/src/adapter/src/coord/sequencer/inner/peek.rs index f8a608832d7ec..95dfb91ec2baa 100644 --- a/src/adapter/src/coord/sequencer/inner/peek.rs +++ b/src/adapter/src/coord/sequencer/inner/peek.rs @@ -888,15 +888,11 @@ impl Coordinator { { let entry = self.catalog.state().get_entry(&item_id); match entry.item() { - // TODO(alter_table): Adding all of the GlobalIds for an object is incorrect. - // For example, this peek may depend on just a single version of a table, but - // we would add dependencies on all versions of said table. Doing this is okay - // for now since we can't yet version tables, but should get fixed. CatalogItem::Table(_) | CatalogItem::Source(_) => { - transitive_storage_deps.extend(entry.global_ids()); + transitive_storage_deps.insert(entry.latest_global_id()); } CatalogItem::MaterializedView(_) | CatalogItem::Index(_) => { - transitive_compute_deps.extend(entry.global_ids()); + transitive_compute_deps.insert(entry.latest_global_id()); } _ => {} } diff --git a/src/adapter/src/coord/sequencer/inner/replace_materialized_view.rs b/src/adapter/src/coord/sequencer/inner/replace_materialized_view.rs new file mode 100644 index 0000000000000..05cc4cca25bee --- /dev/null +++ b/src/adapter/src/coord/sequencer/inner/replace_materialized_view.rs @@ -0,0 +1,434 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use maplit::btreeset; +use mz_adapter_types::compaction::CompactionWindow; +use mz_catalog::memory::objects::{CatalogItem, ReplacementMaterializedView}; +use mz_ore::collections::CollectionExt; +use mz_ore::instrument; +use mz_sql::catalog::ObjectType; +use mz_sql::names::ResolvedIds; +use mz_sql::plan; +use mz_sql::plan::AlterMaterializedViewApplyReplacementPlan; +use mz_sql::session::metadata::SessionMetadata; +use mz_sql_parser::ast; +use mz_sql_parser::ast::display::AstDisplay; +use mz_storage_client::controller::{CollectionDescription, DataSource}; +use tracing::Span; + +use crate::command::ExecuteResponse; +use crate::coord::sequencer::inner::return_if_err; +use crate::coord::{ + Coordinator, CreateReplacementMaterializedViewFinish, + CreateReplacementMaterializedViewOptimize, CreateReplacementMaterializedViewStage, + ExplainContext, Message, PlanValidity, StageResult, Staged, +}; +use crate::error::AdapterError; +use crate::optimize::dataflows::dataflow_import_id_bundle; +use crate::session::Session; +use crate::util::ResultExt; +use crate::{ExecuteContext, catalog}; + +impl Staged for CreateReplacementMaterializedViewStage { + type Ctx = ExecuteContext; + + fn validity(&mut self) -> &mut PlanValidity { + match self { + Self::Optimize(stage) => &mut stage.validity, + Self::Finish(stage) => &mut stage.validity, + } + } + + async fn stage( + self, + coord: &mut Coordinator, + ctx: &mut ExecuteContext, + ) -> Result>, AdapterError> { + match self { + CreateReplacementMaterializedViewStage::Optimize(stage) => { + coord + .create_replacement_materialized_view_optimize(stage) + .await + } + CreateReplacementMaterializedViewStage::Finish(stage) => { + coord + .create_replacement_materialized_view_finish(ctx, stage) + .await + } + } + } + + fn message(self, ctx: ExecuteContext, span: Span) -> Message { + Message::CreateReplacementMaterializedViewStageReady { + ctx, + span, + stage: self, + } + } + + fn cancel_enabled(&self) -> bool { + true + } +} + +impl Coordinator { + #[instrument] + pub(crate) async fn sequence_create_replacement_materialized_view( + &mut self, + ctx: ExecuteContext, + plan: plan::CreateReplacementMaterializedViewPlan, + resolved_ids: ResolvedIds, + ) { + let stage = return_if_err!( + self.create_replacement_materialized_view_validate(ctx.session(), plan, resolved_ids,), + ctx + ); + self.sequence_staged(ctx, Span::current(), stage).await; + } + + #[instrument] + fn create_replacement_materialized_view_validate( + &mut self, + session: &Session, + plan: plan::CreateReplacementMaterializedViewPlan, + resolved_ids: ResolvedIds, + ) -> Result { + let plan::CreateReplacementMaterializedViewPlan { + materialized_view: + plan::MaterializedView { + expr, + cluster_id, + refresh_schedule, + .. + }, + ambiguous_columns, + .. + } = &plan; + + let validity = self.create_materialized_view_validate_inner( + session, + &resolved_ids, + expr, + cluster_id, + refresh_schedule, + ambiguous_columns, + &ExplainContext::None, + )?; + + Ok(CreateReplacementMaterializedViewStage::Optimize( + CreateReplacementMaterializedViewOptimize { + validity, + plan, + resolved_ids, + }, + )) + } + + #[instrument] + async fn create_replacement_materialized_view_optimize( + &mut self, + CreateReplacementMaterializedViewOptimize { + validity, + plan, + resolved_ids, + }: CreateReplacementMaterializedViewOptimize, + ) -> Result>, AdapterError> { + let plan::CreateReplacementMaterializedViewPlan { + name, + materialized_view: + plan::MaterializedView { + column_names, + cluster_id, + non_null_assertions, + refresh_schedule, + .. + }, + .. + } = &plan; + + let (item_id, global_id, optimizer) = self + .create_materialized_view_optimize_common( + name, + column_names.clone(), + cluster_id, + non_null_assertions.clone(), + refresh_schedule.clone(), + &ExplainContext::None, + ) + .await?; + + let span = Span::current(); + Ok(StageResult::Handle(mz_ore::task::spawn_blocking( + || "optimize create replacement materialized view", + move || { + span.in_scope(|| { + let raw_expr = plan.materialized_view.expr.clone(); + + let (local_mir_plan, global_mir_plan, global_lir_plan) = + Self::create_materialized_view_call_optimizer( + optimizer, + raw_expr, + &ExplainContext::None, + )?; + + let finish = CreateReplacementMaterializedViewFinish { + item_id, + global_id, + validity, + plan, + resolved_ids, + local_mir_plan, + global_mir_plan, + global_lir_plan, + }; + let stage = CreateReplacementMaterializedViewStage::Finish(finish); + + Ok(Box::new(stage)) + }) + }, + ))) + } + + #[instrument] + async fn create_replacement_materialized_view_finish( + &mut self, + ctx: &mut ExecuteContext, + stage: CreateReplacementMaterializedViewFinish, + ) -> Result>, AdapterError> { + let CreateReplacementMaterializedViewFinish { + item_id, + global_id, + plan: + plan::CreateReplacementMaterializedViewPlan { + name, + replaces, + materialized_view: + plan::MaterializedView { + mut create_sql, + expr: raw_expr, + dependencies, + cluster_id, + non_null_assertions, + compaction_window, + refresh_schedule, + .. + }, + .. + }, + resolved_ids, + local_mir_plan, + global_mir_plan, + global_lir_plan, + .. + } = stage; + + let Some(mv) = self.catalog().get_entry(&replaces).materialized_view() else { + return Err(AdapterError::internal( + "create materialized view", + "original SQL should roundtrip", + )); + }; + + if &mv.desc.latest() != global_lir_plan.desc() { + return Err(AdapterError::ChangedPlan( + "Schemas are incompatible".to_string(), + )); + } + + // Timestamp selection + let id_bundle = dataflow_import_id_bundle(global_lir_plan.df_desc(), cluster_id); + + let read_holds_owned; + let read_holds = if let Some(txn_reads) = self.txn_read_holds.get(ctx.session().conn_id()) { + // In some cases, for example when REFRESH is used, the preparatory + // stages will already have acquired ReadHolds, we can re-use those. + + txn_reads + } else { + // No one has acquired holds, make sure we can determine an as_of + // and render our dataflow below. + read_holds_owned = self.acquire_read_holds(&id_bundle); + &read_holds_owned + }; + + let (dataflow_as_of, storage_as_of, until) = + self.select_timestamps(id_bundle, refresh_schedule.as_ref(), read_holds)?; + + tracing::info!( + dataflow_as_of = ?dataflow_as_of, + storage_as_of = ?storage_as_of, + until = ?until, + "materialized view timestamp selection", + ); + + let initial_as_of = storage_as_of.clone(); + + // Update the `create_sql` with the selected `as_of`. This is how we make sure the `as_of` + // is persisted to the catalog and can be relied on during bootstrapping. + // This has to be the `storage_as_of`, because bootstrapping uses this in + // `bootstrap_storage_collections`. + if let Some(storage_as_of_ts) = storage_as_of.as_option() { + let stmt = mz_sql::parse::parse(&create_sql) + .map_err(|_| { + AdapterError::internal( + "create materialized view", + "original SQL should roundtrip", + ) + })? + .into_element() + .ast; + let ast::Statement::CreateReplacementMaterializedView(mut stmt) = stmt else { + panic!("unexpected statement type"); + }; + stmt.as_of = Some(storage_as_of_ts.into()); + create_sql = stmt.to_ast_string_stable(); + } + + let ops = vec![catalog::Op::CreateItem { + id: item_id, + name: name.clone(), + item: CatalogItem::ReplacementMaterializedView(ReplacementMaterializedView { + create_sql, + replaces, + raw_expr: raw_expr.into(), + optimized_expr: local_mir_plan.expr().into(), + desc: global_lir_plan.desc().clone(), + global_id, + resolved_ids, + dependencies, + cluster_id, + non_null_assertions, + custom_logical_compaction_window: compaction_window, + refresh_schedule: refresh_schedule.clone(), + initial_as_of: Some(initial_as_of.clone()), + }), + owner_id: *ctx.session().current_role_id(), + }]; + + // Pre-allocate a vector of transient GlobalIds for each notice. + let notice_ids = std::iter::repeat_with(|| self.allocate_transient_id()) + .map(|(_item_id, global_id)| global_id) + .take(global_lir_plan.df_meta().optimizer_notices.len()) + .collect::>(); + + self.catalog_transact_with_side_effects(Some(ctx), ops, move |coord, ctx| { + Box::pin(async move { + let output_desc = global_lir_plan.desc().clone(); + let (mut df_desc, df_meta) = global_lir_plan.unapply(); + + // Save plan structures. + coord + .catalog_mut() + .set_optimized_plan(global_id, global_mir_plan.df_desc().clone()); + coord + .catalog_mut() + .set_physical_plan(global_id, df_desc.clone()); + + let notice_builtin_updates_fut = coord + .process_dataflow_metainfo(df_meta, global_id, ctx, notice_ids) + .await; + + df_desc.set_as_of(dataflow_as_of.clone()); + df_desc.set_initial_as_of(initial_as_of); + df_desc.until = until; + + let storage_metadata = coord.catalog.state().storage_metadata(); + + // Announce the creation of the materialized view source. + coord + .controller + .storage + .create_collections( + storage_metadata, + None, + vec![( + global_id, + CollectionDescription { + desc: output_desc, + data_source: DataSource::Other, + since: Some(storage_as_of), + status_collection_id: None, + timeline: None, + }, + )], + ) + .await + .unwrap_or_terminate("cannot fail to append"); + + coord + .initialize_storage_read_policies( + btreeset![item_id], + compaction_window.unwrap_or(CompactionWindow::Default), + ) + .await; + + coord + .ship_dataflow_and_notice_builtin_table_updates( + df_desc, + cluster_id, + notice_builtin_updates_fut, + ) + .await; + }) + }) + .await?; + + Ok(StageResult::Response( + ExecuteResponse::CreatedReplacementMaterializedView, + )) + } + + pub(crate) async fn sequence_alter_materialized_view_apply_replacement( + &mut self, + ctx: &mut ExecuteContext, + AlterMaterializedViewApplyReplacementPlan { + id, + replacement_id, + }: AlterMaterializedViewApplyReplacementPlan, + ) -> Result { + let mv = self + .catalog() + .get_entry(&id) + .materialized_view() + .ok_or_else(|| { + AdapterError::internal( + "alter materialized view apply replacement", + "replacement id should refer to a materialized view", + ) + })?; + let rmv = self + .catalog() + .get_entry(&replacement_id) + .replacement_materialized_view() + .ok_or_else(|| { + AdapterError::internal( + "alter materialized view apply replacement", + "replacement id should refer to a replacement materialized view", + ) + })?; + let rmv_cluster = rmv.cluster_id; + let sink_id = rmv.global_id(); + self.catalog_transact_with_side_effects( + Some(ctx), + vec![catalog::Op::AlterMaterializedViewApplyReplacement { + id, + replacement_id, + replaced_id: mv.global_id_writes(), + cluster_id: mv.cluster_id, + }], + move |coord, _ctx| { + Box::pin(async move { + coord.allow_writes(rmv_cluster, sink_id); + }) + }, + ) + .await?; + Ok(ExecuteResponse::AlteredObject(ObjectType::MaterializedView)) + } +} diff --git a/src/adapter/src/optimize/dataflows.rs b/src/adapter/src/optimize/dataflows.rs index dca7f9cbb1df5..c47ddf8ea8583 100644 --- a/src/adapter/src/optimize/dataflows.rs +++ b/src/adapter/src/optimize/dataflows.rs @@ -401,7 +401,8 @@ impl<'a> DataflowBuilder<'a> { | CatalogItem::MaterializedView(_) | CatalogItem::Sink(_) | CatalogItem::Func(_) - | CatalogItem::ContinualTask(_) => Ok(false), + | CatalogItem::ContinualTask(_) + | CatalogItem::ReplacementMaterializedView(_) => Ok(false), } })?; diff --git a/src/adapter/src/statement_logging.rs b/src/adapter/src/statement_logging.rs index 7931037eee15d..d00dc90286bbd 100644 --- a/src/adapter/src/statement_logging.rs +++ b/src/adapter/src/statement_logging.rs @@ -223,6 +223,7 @@ impl From<&ExecuteResponse> for StatementEndedExecutionReason { | ExecuteResponse::CreatedContinualTask | ExecuteResponse::CreatedType | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedReplacementMaterializedView | ExecuteResponse::Deallocate { .. } | ExecuteResponse::DeclaredCursor | ExecuteResponse::Deleted(_) diff --git a/src/audit-log/src/lib.rs b/src/audit-log/src/lib.rs index 95bbaee5fefd5..31f14e275effd 100644 --- a/src/audit-log/src/lib.rs +++ b/src/audit-log/src/lib.rs @@ -123,6 +123,7 @@ pub enum ObjectType { Table, Type, View, + ReplacementMaterializedView, } impl ObjectType { @@ -146,6 +147,7 @@ impl ObjectType { ObjectType::Table => "Table", ObjectType::Type => "Type", ObjectType::View => "View", + Self::ReplacementMaterializedView => "Replacement Materialized View", } } } diff --git a/src/buf.yaml b/src/buf.yaml index f2264d33a1884..85038bd7075ec 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -41,6 +41,8 @@ breaking: - catalog-protos/protos/objects_v77.proto # reason: does currently not require backward-compatibility - catalog-protos/protos/objects_v78.proto + # reason: does currently not require backward-compatibility + - catalog-protos/protos/objects_v79.proto # reason: Ignore because plans are currently not persisted. - expr/src/scalar.proto # reason: we very carefully evolve these protobuf definitions diff --git a/src/catalog-debug/src/main.rs b/src/catalog-debug/src/main.rs index 76a04b8879e29..51c7f0f4ca643 100644 --- a/src/catalog-debug/src/main.rs +++ b/src/catalog-debug/src/main.rs @@ -683,6 +683,7 @@ async fn upgrade_check( CatalogItem::Source(source) => Some((source.global_id(), source.desc.clone())), CatalogItem::ContinualTask(ct) => Some((ct.global_id(), ct.desc.clone())), CatalogItem::MaterializedView(mv) => Some((mv.global_id_writes(), mv.desc.latest())), + CatalogItem::ReplacementMaterializedView(mv) => Some((mv.global_id(), mv.desc.clone())), CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Sink(_) diff --git a/src/catalog-protos/protos/hashes.json b/src/catalog-protos/protos/hashes.json index fdd291dd6dd59..6290e80cbe4de 100644 --- a/src/catalog-protos/protos/hashes.json +++ b/src/catalog-protos/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "3e9f4c62f87441ac7897d96462f3c0c9" + "md5": "32ab3b31fe78b07bc20f8319a900c714" }, { "name": "objects_v67.proto", @@ -50,5 +50,9 @@ { "name": "objects_v78.proto", "md5": "64e78f72cd10034f91e4c034ff9e4f96" + }, + { + "name": "objects_v79.proto", + "md5": "f1a48a376d7d6d8012d6c2376932a16a" } ] diff --git a/src/catalog-protos/protos/objects.proto b/src/catalog-protos/protos/objects.proto index f68bafb7c8817..20e179dda71af 100644 --- a/src/catalog-protos/protos/objects.proto +++ b/src/catalog-protos/protos/objects.proto @@ -206,6 +206,7 @@ message CommentKey { ClusterId cluster = 15; ClusterReplicaId cluster_replica = 16; NetworkPolicyId network_policy = 18; + CatalogItemId replacement_materialized_view = 19; } oneof sub_component { uint64 column_pos = 3; @@ -299,6 +300,7 @@ enum CatalogItemType { CATALOG_ITEM_TYPE_SECRET = 9; CATALOG_ITEM_TYPE_CONNECTION = 10; CATALOG_ITEM_TYPE_CONTINUAL_TASK = 11; + CATALOG_ITEM_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 12; } message CatalogItem { @@ -549,6 +551,7 @@ enum ObjectType { OBJECT_TYPE_FUNC = 15; OBJECT_TYPE_CONTINUAL_TASK = 16; OBJECT_TYPE_NETWORK_POLICY = 17; + OBJECT_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 18; } message DefaultPrivilegesKey { @@ -603,6 +606,7 @@ message AuditLogEventV1 { OBJECT_TYPE_SYSTEM = 16; OBJECT_TYPE_CONTINUAL_TASK = 17; OBJECT_TYPE_NETWORK_POLICY = 18; + OBJECT_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 19; } message IdFullNameV1 { diff --git a/src/catalog-protos/protos/objects_v79.proto b/src/catalog-protos/protos/objects_v79.proto new file mode 100644 index 0000000000000..e009a9e91ff84 --- /dev/null +++ b/src/catalog-protos/protos/objects_v79.proto @@ -0,0 +1,1101 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +// This protobuf file defines the types we store in the Stash. +// +// Before and after modifying this file, make sure you have a snapshot of the before version, +// e.g. a copy of this file named 'objects_v{CATALOG_VERSION}.proto', and a snapshot of the file +// after your modifications, e.g. 'objects_v{CATALOG_VERSION + 1}.proto'. Then you can write a +// migration using these two files, and no matter how the types change in the future, we'll always +// have these snapshots to facilitate the migration. + +// buf breaking: ignore (does currently not require backward-compatibility) + +syntax = "proto3"; + +package objects_v79; + +message ConfigKey { + string key = 1; +} + +message ConfigValue { + uint64 value = 1; +} + +message SettingKey { + string name = 1; +} + +message SettingValue { + string value = 1; +} + +message IdAllocKey { + string name = 1; +} + +message IdAllocValue { + uint64 next_id = 1; +} + +message GidMappingKey { + string schema_name = 1; + CatalogItemType object_type = 2; + string object_name = 3; +} + +message GidMappingValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 id = 1; + string fingerprint = 2; + SystemGlobalId global_id = 3; +} + +message ClusterKey { + ClusterId id = 1; +} + +message ClusterValue { + reserved 2; + string name = 1; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + ClusterConfig config = 5; +} + +message ClusterIntrospectionSourceIndexKey { + ClusterId cluster_id = 1; + string name = 2; +} + +message ClusterIntrospectionSourceIndexValue { + // TODO(parkmycar): Ideally this is a IntrospectionSourceCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new IntrospectionSourceCatalogItemId type. + uint64 index_id = 1; + uint32 oid = 2; + IntrospectionSourceIndexGlobalId global_id = 3; +} + +message ClusterReplicaKey { + ReplicaId id = 1; +} + +message ClusterReplicaValue { + ClusterId cluster_id = 1; + string name = 2; + ReplicaConfig config = 3; + RoleId owner_id = 4; +} + +message DatabaseKey { + DatabaseId id = 1; +} + +message DatabaseValue { + string name = 1; + RoleId owner_id = 2; + repeated MzAclItem privileges = 3; + uint32 oid = 4; +} + +message SchemaKey { + SchemaId id = 1; +} + +message SchemaValue { + DatabaseId database_id = 1; + string name = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ItemKey { + CatalogItemId gid = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; + uint32 oid = 6; + GlobalId global_id = 7; + repeated ItemVersion extra_versions = 8; +} + +message ItemVersion { + GlobalId global_id = 1; + Version version = 2; +} + +message RoleKey { + RoleId id = 1; +} + +message RoleValue { + string name = 1; + RoleAttributes attributes = 2; + RoleMembership membership = 3; + RoleVars vars = 4; + uint32 oid = 5; +} + +message RoleAuthKey { + RoleId id = 1; +} + +message RoleAuthValue { + optional string password_hash = 1; + EpochMillis updated_at = 2; +} + +message NetworkPolicyKey { + NetworkPolicyId id = 1; +} + +message NetworkPolicyValue { + string name = 1; + repeated NetworkPolicyRule rules = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ServerConfigurationKey { + string name = 1; +} + +message ServerConfigurationValue { + string value = 1; +} + +message AuditLogKey { + oneof event { + AuditLogEventV1 v1 = 1; + } +} + +message CommentKey { + oneof object { + CatalogItemId table = 1; + CatalogItemId view = 2; + CatalogItemId materialized_view = 4; + CatalogItemId source = 5; + CatalogItemId sink = 6; + CatalogItemId index = 7; + CatalogItemId func = 8; + CatalogItemId connection = 9; + CatalogItemId type = 10; + CatalogItemId secret = 11; + CatalogItemId continual_task = 17; + RoleId role = 12; + DatabaseId database = 13; + ResolvedSchema schema = 14; + ClusterId cluster = 15; + ClusterReplicaId cluster_replica = 16; + NetworkPolicyId network_policy = 18; + CatalogItemId replacement_materialized_view = 19; + } + oneof sub_component { + uint64 column_pos = 3; + } +} + +message CommentValue { + string comment = 1; +} + +message SourceReferencesKey { + CatalogItemId source = 1; +} + +message SourceReferencesValue { + repeated SourceReference references = 1; + EpochMillis updated_at = 2; +} + +message SourceReference { + string name = 1; + optional string namespace = 2; + repeated string columns = 3; +} + +message StorageCollectionMetadataKey { + GlobalId id = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message StorageCollectionMetadataValue { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message UnfinalizedShardKey { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message TxnWalShardValue { + string shard = 1; +} + +// ---- Common Types +// +// Note: Normally types like this would go in some sort of `common.proto` file, but we want to keep +// our proto definitions in a single file to make snapshotting easier, hence them living here. + +message Empty { + /* purposefully empty */ +} + +// In protobuf a "None" string is the same thing as an empty string. To get the same semantics of +// an `Option` from Rust, we need to wrap a string in a message. +message StringWrapper { + string inner = 1; +} + +message Duration { + uint64 secs = 1; + uint32 nanos = 2; +} + +message EpochMillis { + uint64 millis = 1; +} + +// Opaque timestamp type that is specific to Materialize. +message Timestamp { + uint64 internal = 1; +} + +message Version { + uint64 value = 2; +} + +enum CatalogItemType { + CATALOG_ITEM_TYPE_UNKNOWN = 0; + CATALOG_ITEM_TYPE_TABLE = 1; + CATALOG_ITEM_TYPE_SOURCE = 2; + CATALOG_ITEM_TYPE_SINK = 3; + CATALOG_ITEM_TYPE_VIEW = 4; + CATALOG_ITEM_TYPE_MATERIALIZED_VIEW = 5; + CATALOG_ITEM_TYPE_INDEX = 6; + CATALOG_ITEM_TYPE_TYPE = 7; + CATALOG_ITEM_TYPE_FUNC = 8; + CATALOG_ITEM_TYPE_SECRET = 9; + CATALOG_ITEM_TYPE_CONNECTION = 10; + CATALOG_ITEM_TYPE_CONTINUAL_TASK = 11; + CATALOG_ITEM_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 12; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message CatalogItemId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + uint64 introspection_source_index = 4; + } +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "system" namespace. +message SystemCatalogItemId { + uint64 value = 1; +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexCatalogItemId { + uint64 value = 1; +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + uint64 introspection_source_index = 5; + } +} + +/// A newtype wrapper for a `GlobalId` that is always in the "system" namespace. +message SystemGlobalId { + uint64 value = 1; +} + +/// A newtype wrapper for a `GlobalId` that is always in the "introspection source index" namespace. +message IntrospectionSourceIndexGlobalId { + uint64 value = 1; +} + +message ClusterId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message DatabaseId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ResolvedDatabaseSpecifier { + oneof spec { + Empty ambient = 1; + DatabaseId id = 2; + } +} + +message SchemaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message SchemaSpecifier { + oneof spec { + Empty temporary = 1; + SchemaId id = 2; + } +} + +message ResolvedSchema { + ResolvedDatabaseSpecifier database = 1; + SchemaSpecifier schema = 2; +} + +message ReplicaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ClusterReplicaId { + ClusterId cluster_id = 1; + ReplicaId replica_id = 2; +} + +message NetworkPolicyId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ReplicaLogging { + bool log_logging = 1; + Duration interval = 2; +} + +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + +message ClusterScheduleRefreshOptions { + Duration rehydration_time_estimate = 1; +} + +message ClusterSchedule { + oneof value { + Empty manual = 1; + ClusterScheduleRefreshOptions refresh = 2; + } +} + +message ClusterConfig { + message ManagedCluster { + string size = 1; + uint32 replication_factor = 2; + repeated string availability_zones = 3; + ReplicaLogging logging = 4; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; + ClusterSchedule schedule = 8; + } + + oneof variant { + Empty unmanaged = 1; + ManagedCluster managed = 2; + } + optional string workload_class = 3; +} + +message ReplicaConfig { + message UnmanagedLocation { + repeated string storagectl_addrs = 1; + repeated string computectl_addrs = 3; + } + + message ManagedLocation { + string size = 1; + optional string availability_zone = 2; + bool internal = 5; + optional string billed_as = 6; + bool pending = 7; + } + + oneof location { + UnmanagedLocation unmanaged = 1; + ManagedLocation managed = 2; + } + ReplicaLogging logging = 3; +} + +message RoleId { + oneof value { + uint64 system = 1; + uint64 user = 2; + Empty public = 3; + uint64 predefined = 4; + } +} + +message RoleAttributes { + bool inherit = 1; + optional bool superuser = 2; + optional bool login = 3; +} + +message RoleMembership { + message Entry { + RoleId key = 1; + RoleId value = 2; + } + + repeated Entry map = 1; +} + +message RoleVars { + message SqlSet { + repeated string entries = 1; + } + + message Entry { + string key = 1; + oneof val { + string flat = 2; + SqlSet sql_set = 3; + } + } + + repeated Entry entries = 1; +} + +message NetworkPolicyRule { + string name = 1; + oneof action { + Empty allow = 2; + } + oneof direction { + Empty ingress = 3; + } + string address = 4; +} + +message AclMode { + // A bit flag representing all the privileges that can be granted to a role. + uint64 bitflags = 1; +} + +message MzAclItem { + RoleId grantee = 1; + RoleId grantor = 2; + AclMode acl_mode = 3; +} + +enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_TABLE = 1; + OBJECT_TYPE_VIEW = 2; + OBJECT_TYPE_MATERIALIZED_VIEW = 3; + OBJECT_TYPE_SOURCE = 4; + OBJECT_TYPE_SINK = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_TYPE = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_CLUSTER = 9; + OBJECT_TYPE_CLUSTER_REPLICA = 10; + OBJECT_TYPE_SECRET = 11; + OBJECT_TYPE_CONNECTION = 12; + OBJECT_TYPE_DATABASE = 13; + OBJECT_TYPE_SCHEMA = 14; + OBJECT_TYPE_FUNC = 15; + OBJECT_TYPE_CONTINUAL_TASK = 16; + OBJECT_TYPE_NETWORK_POLICY = 17; + OBJECT_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 18; +} + +message DefaultPrivilegesKey { + RoleId role_id = 1; + DatabaseId database_id = 2; + SchemaId schema_id = 3; + ObjectType object_type = 4; + RoleId grantee = 5; +} + +message DefaultPrivilegesValue { + AclMode privileges = 1; +} + +message SystemPrivilegesKey { + RoleId grantee = 1; + RoleId grantor = 2; +} + +message SystemPrivilegesValue { + AclMode acl_mode = 1; +} + +message AuditLogEventV1 { + enum EventType { + EVENT_TYPE_UNKNOWN = 0; + EVENT_TYPE_CREATE = 1; + EVENT_TYPE_DROP = 2; + EVENT_TYPE_ALTER = 3; + EVENT_TYPE_GRANT = 4; + EVENT_TYPE_REVOKE = 5; + EVENT_TYPE_COMMENT = 6; + } + + enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_CLUSTER = 1; + OBJECT_TYPE_CLUSTER_REPLICA = 2; + OBJECT_TYPE_CONNECTION = 3; + OBJECT_TYPE_DATABASE = 4; + OBJECT_TYPE_FUNC = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_MATERIALIZED_VIEW = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_SECRET = 9; + OBJECT_TYPE_SCHEMA = 10; + OBJECT_TYPE_SINK = 11; + OBJECT_TYPE_SOURCE = 12; + OBJECT_TYPE_TABLE = 13; + OBJECT_TYPE_TYPE = 14; + OBJECT_TYPE_VIEW = 15; + OBJECT_TYPE_SYSTEM = 16; + OBJECT_TYPE_CONTINUAL_TASK = 17; + OBJECT_TYPE_NETWORK_POLICY = 18; + OBJECT_TYPE_REPLACEMENT_MATERIALIZED_VIEW = 19; + } + + message IdFullNameV1 { + string id = 1; + FullNameV1 name = 2; + } + + message FullNameV1 { + string database = 1; + string schema = 2; + string item = 3; + } + + message IdNameV1 { + string id = 1; + string name = 2; + } + + message RenameClusterV1 { + string id = 1; + string old_name = 2; + string new_name = 3; + } + + message RenameClusterReplicaV1 { + string cluster_id = 1; + string replica_id = 2; + string old_name = 3; + string new_name = 4; + } + + message RenameItemV1 { + string id = 1; + FullNameV1 old_name = 2; + FullNameV1 new_name = 3; + } + + message CreateClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + } + + message CreateClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 10; + } + + message CreateClusterReplicaV3 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV2 scheduling_policies = 10; + } + + message CreateClusterReplicaV4 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + optional string billed_as = 6; + bool internal = 7; + CreateOrDropClusterReplicaReasonV1 reason = 8; + SchedulingDecisionsWithReasonsV2 scheduling_policies = 9; + } + + message DropClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + } + + message DropClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 6; + } + + message DropClusterReplicaV3 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV2 scheduling_policies = 6; + } + + message CreateOrDropClusterReplicaReasonV1 { + oneof reason { + Empty Manual = 1; + Empty Schedule = 2; + Empty System = 3; + } + } + + message SchedulingDecisionsWithReasonsV1 { + RefreshDecisionWithReasonV1 on_refresh = 1; + } + + message SchedulingDecisionsWithReasonsV2 { + RefreshDecisionWithReasonV2 on_refresh = 1; + } + + message RefreshDecisionWithReasonV1 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + string rehydration_time_estimate = 4; + } + + message RefreshDecisionWithReasonV2 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + repeated string objects_needing_compaction = 5; + string rehydration_time_estimate = 4; + } + + message CreateSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + } + + message CreateSourceSinkV2 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + string external_type = 4; + } + + message CreateSourceSinkV3 { + string id = 1; + FullNameV1 name = 2; + string external_type = 3; + } + + message CreateSourceSinkV4 { + string id = 1; + StringWrapper cluster_id = 2; + FullNameV1 name = 3; + string external_type = 4; + } + + message CreateIndexV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message CreateMaterializedViewV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message AlterSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_size = 3; + StringWrapper new_size = 4; + } + + message AlterSetClusterV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_cluster = 3; + StringWrapper new_cluster = 4; + } + + message GrantRoleV1 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + } + + message GrantRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message RevokeRoleV1 { + string role_id = 1; + string member_id = 2; + } + + message RevokeRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message UpdatePrivilegeV1 { + string object_id = 1; + string grantee_id = 2; + string grantor_id = 3; + string privileges = 4; + } + + message AlterDefaultPrivilegeV1 { + string role_id = 1; + StringWrapper database_id = 2; + StringWrapper schema_id = 3; + string grantee_id = 4; + string privileges = 5; + } + + message UpdateOwnerV1 { + string object_id = 1; + string old_owner_id = 2; + string new_owner_id = 3; + } + + message SchemaV1 { + string id = 1; + string name = 2; + string database_name = 3; + } + + message SchemaV2 { + string id = 1; + string name = 2; + StringWrapper database_name = 3; + } + + message RenameSchemaV1 { + string id = 1; + optional string database_name = 2; + string old_name = 3; + string new_name = 4; + } + + message UpdateItemV1 { + string id = 1; + FullNameV1 name = 2; + } + + message AlterRetainHistoryV1 { + string id = 1; + optional string old_history = 2; + optional string new_history = 3; + } + + message ToNewIdV1 { + string id = 1; + string new_id = 2; + } + + message FromPreviousIdV1 { + string id = 1; + string previous_id = 2; + } + + message SetV1 { + string name = 1; + optional string value = 2; + } + + message RotateKeysV1 { + string id = 1; + string name = 2; + } + + uint64 id = 1; + EventType event_type = 2; + ObjectType object_type = 3; + StringWrapper user = 4; + EpochMillis occurred_at = 5; + + oneof details { + CreateClusterReplicaV1 create_cluster_replica_v1 = 6; + CreateClusterReplicaV2 create_cluster_replica_v2 = 33; + CreateClusterReplicaV3 create_cluster_replica_v3 = 41; + CreateClusterReplicaV4 create_cluster_replica_v4 = 43; + DropClusterReplicaV1 drop_cluster_replica_v1 = 7; + DropClusterReplicaV2 drop_cluster_replica_v2 = 34; + DropClusterReplicaV3 drop_cluster_replica_v3 = 42; + CreateSourceSinkV1 create_source_sink_v1 = 8; + CreateSourceSinkV2 create_source_sink_v2 = 9; + AlterSourceSinkV1 alter_source_sink_v1 = 10; + AlterSetClusterV1 alter_set_cluster_v1 = 25; + GrantRoleV1 grant_role_v1 = 11; + GrantRoleV2 grant_role_v2 = 12; + RevokeRoleV1 revoke_role_v1 = 13; + RevokeRoleV2 revoke_role_v2 = 14; + UpdatePrivilegeV1 update_privilege_v1 = 22; + AlterDefaultPrivilegeV1 alter_default_privilege_v1 = 23; + UpdateOwnerV1 update_owner_v1 = 24; + IdFullNameV1 id_full_name_v1 = 15; + RenameClusterV1 rename_cluster_v1 = 20; + RenameClusterReplicaV1 rename_cluster_replica_v1 = 21; + RenameItemV1 rename_item_v1 = 16; + IdNameV1 id_name_v1 = 17; + SchemaV1 schema_v1 = 18; + SchemaV2 schema_v2 = 19; + RenameSchemaV1 rename_schema_v1 = 27; + UpdateItemV1 update_item_v1 = 26; + CreateSourceSinkV3 create_source_sink_v3 = 29; + AlterRetainHistoryV1 alter_retain_history_v1 = 30; + ToNewIdV1 to_new_id_v1 = 31; + FromPreviousIdV1 from_previous_id_v1 = 32; + SetV1 set_v1 = 35; + Empty reset_all_v1 = 36; + RotateKeysV1 rotate_keys_v1 = 37; + CreateSourceSinkV4 create_source_sink_v4 = 38; + CreateIndexV1 create_index_v1 = 39; + CreateMaterializedViewV1 create_materialized_view_v1 = 40; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + reserved "Epoch"; + + message AuditLog { + AuditLogKey key = 1; + } + + message Cluster { + ClusterKey key = 1; + ClusterValue value = 2; + } + + message ClusterReplica { + ClusterReplicaKey key = 1; + ClusterReplicaValue value = 2; + } + + message Comment { + CommentKey key = 1; + CommentValue value = 2; + } + + message Config { + ConfigKey key = 1; + ConfigValue value = 2; + } + + message Database { + DatabaseKey key = 1; + DatabaseValue value = 2; + } + + message DefaultPrivileges { + DefaultPrivilegesKey key = 1; + DefaultPrivilegesValue value = 2; + } + + message FenceToken { + uint64 deploy_generation = 1; + int64 epoch = 2; + } + + message IdAlloc { + IdAllocKey key = 1; + IdAllocValue value = 2; + } + + message ClusterIntrospectionSourceIndex { + ClusterIntrospectionSourceIndexKey key = 1; + ClusterIntrospectionSourceIndexValue value = 2; + } + + message Item { + ItemKey key = 1; + ItemValue value = 2; + } + + message Role { + RoleKey key = 1; + RoleValue value = 2; + } + + message RoleAuth { + RoleAuthKey key = 1; + RoleAuthValue value = 2; + } + + message NetworkPolicy { + NetworkPolicyKey key = 1; + NetworkPolicyValue value = 2; + } + + message Schema { + SchemaKey key = 1; + SchemaValue value = 2; + } + + message Setting { + SettingKey key = 1; + SettingValue value = 2; + } + + message ServerConfiguration { + ServerConfigurationKey key = 1; + ServerConfigurationValue value = 2; + } + + message SourceReferences { + SourceReferencesKey key = 1; + SourceReferencesValue value = 2; + } + + message GidMapping { + GidMappingKey key = 1; + GidMappingValue value = 2; + } + + message SystemPrivileges { + SystemPrivilegesKey key = 1; + SystemPrivilegesValue value = 2; + } + + message StorageCollectionMetadata { + StorageCollectionMetadataKey key = 1; + StorageCollectionMetadataValue value = 2; + } + + message UnfinalizedShard { + UnfinalizedShardKey key = 1; + } + + message TxnWalShard { + TxnWalShardValue value = 1; + } + + reserved 15; + reserved "storage_usage"; + reserved 19; + reserved "timestamp"; + reserved 22; + reserved "persist_txn_shard"; + reserved 8; + reserved "epoch"; + + oneof kind { + AuditLog audit_log = 1; + Cluster cluster = 2; + ClusterReplica cluster_replica = 3; + Comment comment = 4; + Config config = 5; + Database database = 6; + DefaultPrivileges default_privileges = 7; + IdAlloc id_alloc = 9; + ClusterIntrospectionSourceIndex cluster_introspection_source_index = 10; + Item item = 11; + Role role = 12; + Schema schema = 13; + Setting setting = 14; + ServerConfiguration server_configuration = 16; + GidMapping gid_mapping = 17; + SystemPrivileges system_privileges = 18; + StorageCollectionMetadata storage_collection_metadata = 20; + UnfinalizedShard unfinalized_shard = 21; + TxnWalShard txn_wal_shard = 23; + SourceReferences source_references = 24; + FenceToken fence_token = 25; + NetworkPolicy network_policy = 26; + RoleAuth role_auth = 27; + } +} diff --git a/src/catalog-protos/src/audit_log.rs b/src/catalog-protos/src/audit_log.rs index 927bbcd32e743..0adaaa38f903d 100644 --- a/src/catalog-protos/src/audit_log.rs +++ b/src/catalog-protos/src/audit_log.rs @@ -124,6 +124,9 @@ impl RustType for mz_audit_log:: } mz_audit_log::ObjectType::Type => crate::objects::audit_log_event_v1::ObjectType::Type, mz_audit_log::ObjectType::View => crate::objects::audit_log_event_v1::ObjectType::View, + mz_audit_log::ObjectType::ReplacementMaterializedView => { + crate::objects::audit_log_event_v1::ObjectType::ReplacementMaterializedView + } } } @@ -185,6 +188,9 @@ impl RustType for mz_audit_log:: crate::objects::audit_log_event_v1::ObjectType::View => { Ok(mz_audit_log::ObjectType::View) } + crate::objects::audit_log_event_v1::ObjectType::ReplacementMaterializedView => { + Ok(mz_audit_log::ObjectType::ReplacementMaterializedView) + } crate::objects::audit_log_event_v1::ObjectType::Unknown => Err( TryFromProtoError::unknown_enum_variant("ObjectType::Unknown"), ), diff --git a/src/catalog-protos/src/lib.rs b/src/catalog-protos/src/lib.rs index 93699d00adc1f..33d2d6bbc88b7 100644 --- a/src/catalog-protos/src/lib.rs +++ b/src/catalog-protos/src/lib.rs @@ -24,7 +24,7 @@ pub mod serialization; /// We will initialize new `Catalog`s with this version, and migrate existing `Catalog`s to this /// version. Whenever the `Catalog` changes, e.g. the protobufs we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 78; +pub const CATALOG_VERSION: u64 = 79; /// The minimum `Catalog` version number that we support migrating from. /// @@ -46,7 +46,9 @@ macro_rules! proto_objects { }; } -proto_objects!(v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78); +proto_objects!( + v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79 +); #[cfg(test)] mod tests { diff --git a/src/catalog-protos/src/serialization.rs b/src/catalog-protos/src/serialization.rs index 8f97be4c42f4b..d969989e0fe2d 100644 --- a/src/catalog-protos/src/serialization.rs +++ b/src/catalog-protos/src/serialization.rs @@ -220,6 +220,9 @@ impl RustType for CatalogItemType { CatalogItemType::Secret => crate::objects::CatalogItemType::Secret, CatalogItemType::Connection => crate::objects::CatalogItemType::Connection, CatalogItemType::ContinualTask => crate::objects::CatalogItemType::ContinualTask, + CatalogItemType::ReplacementMaterializedView => { + crate::objects::CatalogItemType::ReplacementMaterializedView + } } } @@ -236,6 +239,9 @@ impl RustType for CatalogItemType { crate::objects::CatalogItemType::Secret => CatalogItemType::Secret, crate::objects::CatalogItemType::Connection => CatalogItemType::Connection, crate::objects::CatalogItemType::ContinualTask => CatalogItemType::ContinualTask, + crate::objects::CatalogItemType::ReplacementMaterializedView => { + CatalogItemType::ReplacementMaterializedView + } crate::objects::CatalogItemType::Unknown => { return Err(TryFromProtoError::unknown_enum_variant("CatalogItemType")); } @@ -264,6 +270,9 @@ impl RustType for ObjectType { ObjectType::Func => crate::objects::ObjectType::Func, ObjectType::ContinualTask => crate::objects::ObjectType::ContinualTask, ObjectType::NetworkPolicy => crate::objects::ObjectType::NetworkPolicy, + ObjectType::ReplacementMaterializedView => { + crate::objects::ObjectType::ReplacementMaterializedView + } } } @@ -286,6 +295,9 @@ impl RustType for ObjectType { crate::objects::ObjectType::Func => Ok(ObjectType::Func), crate::objects::ObjectType::ContinualTask => Ok(ObjectType::ContinualTask), crate::objects::ObjectType::NetworkPolicy => Ok(ObjectType::NetworkPolicy), + crate::objects::ObjectType::ReplacementMaterializedView => { + Ok(ObjectType::ReplacementMaterializedView) + } crate::objects::ObjectType::Unknown => Err(TryFromProtoError::unknown_enum_variant( "ObjectType::Unknown", )), @@ -434,6 +446,11 @@ impl RustType for CommentObjectId { CommentObjectId::MaterializedView(global_id) => { crate::objects::comment_key::Object::MaterializedView(global_id.into_proto()) } + CommentObjectId::ReplacementMaterializedView(global_id) => { + crate::objects::comment_key::Object::ReplacementMaterializedView( + global_id.into_proto(), + ) + } CommentObjectId::Source(global_id) => { crate::objects::comment_key::Object::Source(global_id.into_proto()) } @@ -497,6 +514,9 @@ impl RustType for CommentObjectId { crate::objects::comment_key::Object::MaterializedView(item_id) => { CommentObjectId::MaterializedView(item_id.into_rust()?) } + crate::objects::comment_key::Object::ReplacementMaterializedView(item_id) => { + CommentObjectId::ReplacementMaterializedView(item_id.into_rust()?) + } crate::objects::comment_key::Object::Source(item_id) => { CommentObjectId::Source(item_id.into_rust()?) } diff --git a/src/catalog/src/builtin.rs b/src/catalog/src/builtin.rs index 24cc98254f6b1..511381ca638a5 100644 --- a/src/catalog/src/builtin.rs +++ b/src/catalog/src/builtin.rs @@ -2850,6 +2850,76 @@ pub static MZ_MATERIALIZED_VIEWS: LazyLock = LazyLock::new(|| Buil is_retained_metrics_object: false, access: vec![PUBLIC_SELECT], }); +pub static MZ_REPLACEMENT_MATERIALIZED_VIEWS: LazyLock = LazyLock::new(|| { + BuiltinTable { + name: "mz_replacement_materialized_views", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::TABLE_MZ_REPLACEMENT_MATERIALIZED_VIEWS_OID, + desc: RelationDesc::builder() + .with_column("id", SqlScalarType::String.nullable(false)) + .with_column("oid", SqlScalarType::Oid.nullable(false)) + .with_column("replaces", SqlScalarType::String.nullable(false)) + .with_column("schema_id", SqlScalarType::String.nullable(false)) + .with_column("name", SqlScalarType::String.nullable(false)) + .with_column("cluster_id", SqlScalarType::String.nullable(false)) + .with_column("definition", SqlScalarType::String.nullable(false)) + .with_column("owner_id", SqlScalarType::String.nullable(false)) + .with_column( + "privileges", + SqlScalarType::Array(Box::new(SqlScalarType::MzAclItem)).nullable(false), + ) + .with_column("create_sql", SqlScalarType::String.nullable(false)) + .with_column("redacted_create_sql", SqlScalarType::String.nullable(false)) + .with_key(vec![0]) + .with_key(vec![1]) + .finish(), + column_comments: BTreeMap::from_iter([ + ( + "id", + "Materialize's unique ID for the replacement materialized view.", + ), + ( + "oid", + "A [PostgreSQL-compatible OID][`oid`] for the replacement materialized view.", + ), + ( + "replaces", + "The catalog item ID of the materialized view this one replaces.", + ), + ( + "schema_id", + "The ID of the schema to which the materialized view belongs. Corresponds to `mz_schemas.id`.", + ), + ("name", "The name of the replacement materialized view."), + ( + "cluster_id", + "The ID of the cluster maintaining the materialized view. Corresponds to `mz_clusters.id`.", + ), + ( + "definition", + "The materialized view definition (a `SELECT` query).", + ), + ( + "owner_id", + "The role ID of the owner of the materialized view. Corresponds to `mz_roles.id`.", + ), + ( + "privileges", + "The privileges belonging to the materialized view.", + ), + ( + "create_sql", + "The `CREATE` SQL statement for the materialized view.", + ), + ( + "redacted_create_sql", + "The redacted `CREATE` SQL statement for the materialized view.", + ), + ]), + is_retained_metrics_object: false, + access: vec![PUBLIC_SELECT], + } +}); pub static MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES: LazyLock = LazyLock::new(|| { BuiltinTable { name: "mz_materialized_view_refresh_strategies", @@ -3750,7 +3820,7 @@ pub static MZ_AUDIT_EVENTS: LazyLock = LazyLock::new(|| BuiltinTab ), ( "object_type", - "The type of the affected object: `cluster`, `cluster-replica`, `connection`, `database`, `function`, `index`, `materialized-view`, `role`, `schema`, `secret`, `sink`, `source`, `table`, `type`, or `view`.", + "The type of the affected object: `cluster`, `cluster-replica`, `connection`, `database`, `function`, `index`, `materialized-view`, `role`, `schema`, `secret`, `sink`, `source`, `table`, `type`, `view`, or `replacement`.", ), ( "details", @@ -5730,7 +5800,8 @@ pub static MZ_OBJECTS_ID_NAMESPACE_TYPES: LazyLock = LazyLock::new( ('connection'), ('type'), ('function'), - ('secret') + ('secret'), + ('replacement') ) AS _ (object_type)"#, access: vec![PUBLIC_SELECT], @@ -5756,6 +5827,7 @@ pub static MZ_OBJECT_OID_ALIAS: LazyLock = LazyLock::new(|| Builtin ('source', 'regclass'), ('view', 'regclass'), ('materialized-view', 'regclass'), + ('replacement', 'regclass'), ('index', 'regclass'), ('type', 'regtype'), ('function', 'regproc') @@ -11127,6 +11199,41 @@ FROM access: vec![PUBLIC_SELECT], }); +pub static MZ_SHOW_REPLACEMENTS: LazyLock = LazyLock::new(|| BuiltinView { + name: "mz_show_replacements", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::VIEW_MZ_SHOW_REPLACEMENTS_OID, + desc: RelationDesc::builder() + .with_column("id", SqlScalarType::String.nullable(false)) + .with_column("name", SqlScalarType::String.nullable(false)) + .with_column("replaces", SqlScalarType::String.nullable(false)) + .with_column("cluster", SqlScalarType::String.nullable(false)) + .with_column("schema_id", SqlScalarType::String.nullable(false)) + .with_column("cluster_id", SqlScalarType::String.nullable(false)) + .with_column("comment", SqlScalarType::String.nullable(false)) + .finish(), + column_comments: BTreeMap::new(), + sql: " +WITH comments AS ( + SELECT id, comment + FROM mz_internal.mz_comments + WHERE object_type = 'replacement' AND object_sub_id IS NULL +) +SELECT + mviews.id as id, + mviews.name, + mviews.replaces, + clusters.name AS cluster, + schema_id, + cluster_id, + COALESCE(comments.comment, '') as comment +FROM + mz_internal.mz_replacement_materialized_views AS mviews + JOIN mz_catalog.mz_clusters AS clusters ON clusters.id = mviews.cluster_id + LEFT JOIN comments ON mviews.id = comments.id", + access: vec![PUBLIC_SELECT], +}); + pub static MZ_SHOW_INDEXES: LazyLock = LazyLock::new(|| BuiltinView { name: "mz_show_indexes", schema: MZ_INTERNAL_SCHEMA, @@ -12739,6 +12846,15 @@ ON mz_internal.mz_show_materialized_views (schema_id)", is_retained_metrics_object: false, }; +pub const MZ_SHOW_REPLACEMENTS_IND: BuiltinIndex = BuiltinIndex { + name: "mz_show_replacements_ind", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::INDEX_MZ_SHOW_REPLACEMENTS_IND_OID, + sql: "IN CLUSTER mz_catalog_server +ON mz_internal.mz_show_replacements (schema_id)", + is_retained_metrics_object: false, +}; + pub const MZ_SHOW_SINKS_IND: BuiltinIndex = BuiltinIndex { name: "mz_show_sinks_ind", schema: MZ_INTERNAL_SCHEMA, @@ -13795,6 +13911,7 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::Table(&MZ_VIEWS), Builtin::Table(&MZ_MATERIALIZED_VIEWS), Builtin::Table(&MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES), + Builtin::Table(&MZ_REPLACEMENT_MATERIALIZED_VIEWS), Builtin::Table(&MZ_TYPES), Builtin::Table(&MZ_TYPE_PG_METADATA), Builtin::Table(&MZ_ARRAY_TYPES), @@ -13905,6 +14022,7 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::View(&MZ_SHOW_SOURCES), Builtin::View(&MZ_SHOW_SINKS), Builtin::View(&MZ_SHOW_MATERIALIZED_VIEWS), + Builtin::View(&MZ_SHOW_REPLACEMENTS), Builtin::View(&MZ_SHOW_INDEXES), Builtin::View(&MZ_SHOW_CONTINUAL_TASKS), Builtin::View(&MZ_CLUSTER_REPLICA_HISTORY), @@ -14055,6 +14173,7 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::Index(&MZ_SHOW_SOURCES_IND), Builtin::Index(&MZ_SHOW_VIEWS_IND), Builtin::Index(&MZ_SHOW_MATERIALIZED_VIEWS_IND), + Builtin::Index(&MZ_SHOW_REPLACEMENTS_IND), Builtin::Index(&MZ_SHOW_SINKS_IND), Builtin::Index(&MZ_SHOW_TYPES_IND), Builtin::Index(&MZ_SHOW_ALL_OBJECTS_IND), diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index 4256bc99a9cf5..85f5b1f296249 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -398,6 +398,9 @@ pub(crate) async fn initialize( ObjectType::Func => mz_audit_log::ObjectType::Func, ObjectType::ContinualTask => mz_audit_log::ObjectType::ContinualTask, ObjectType::NetworkPolicy => mz_audit_log::ObjectType::NetworkPolicy, + ObjectType::ReplacementMaterializedView => { + mz_audit_log::ObjectType::ReplacementMaterializedView + } }; audit_events.push(( mz_audit_log::EventType::Grant, diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 428c8d3efe26d..9dbfc309750ca 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -1350,6 +1350,17 @@ fn item_type(create_sql: &str) -> CatalogItemType { Some("FUNCTION") => CatalogItemType::Func, Some("SECRET") => CatalogItemType::Secret, Some("CONNECTION") => CatalogItemType::Connection, + Some("REPLACEMENT") => { + let _name = tokens.next(); + assert_eq!(tokens.next(), Some("FOR")); + match tokens.next() { + Some("MATERIALIZED") => { + assert_eq!(tokens.next(), Some("VIEW")); + CatalogItemType::ReplacementMaterializedView + } + other => panic!("unexpected replacement target: {:?}", other), + } + } _ => panic!("unexpected create sql: {}", create_sql), } } diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index d06c6031f4e24..cc88913de8f3e 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -188,7 +188,9 @@ macro_rules! objects { } } -objects!(v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78); +objects!( + v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79 +); /// The current version of the `Catalog`. pub use mz_catalog_protos::CATALOG_VERSION; @@ -211,6 +213,7 @@ mod v74_to_v75; mod v75_to_v76; mod v76_to_v77; mod v77_to_v78; +mod v78_to_v79; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -392,6 +395,15 @@ async fn run_upgrade( ) .await } + 78 => { + run_versioned_upgrade( + unopened_catalog_state, + version, + commit_ts, + v78_to_v79::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok((CATALOG_VERSION, commit_ts)), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v79.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v79.txt new file mode 100644 index 0000000000000..33a4615580035 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v79.txt @@ -0,0 +1,100 @@ +CkUKQ7oBQAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCicKBXZhbHVlEh66ARsKGQoFc2hhcmQSEEIOJu+/vU7CpSLwkYqKQFs= +CpABCo0BugGJAQocCgNrZXkSFboBEgoQCgRuYW1lEghCBlNgMD5QcgodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KSgoFdmFsdWUSQboBPgo8CgV2YWx1ZRIzQjHwn4ezOmtcXPCeuLvwkauEbPCQo7F13aw94KGhX0dXyLpC4b2Z4YuMK/CQkqJPw596 +CkEKP7oBPAoUCgNrZXkSDboBCgoICgJpZBICCAQKFwoEa2luZBIPQg1OZXR3b3JrUG9saWN5CgsKBXZhbHVlEgIIBA== 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 +Ck8KTboBSgoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoXCgRraW5kEg9CDU5ldHdvcmtQb2xpY3kKCwoFdmFsdWUSAggE +Ck0KS7oBSAoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAooCgV2YWx1ZRIfugEcChoKB2NvbW1lbnQSD0IN4LOiJuCsiHzDricnLw== +CtICCs8CugHLAgqlAQoDa2V5Ep0BugGZAQo/CgtvYmplY3RfbmFtZRIwQi7RqOqUlntgLOCyse+5qFxc4K2HOC4vJtGo8J+VtOCriMKnMzfigYUmVPCRrIknChoKC29iamVjdF90eXBlEgvCAQgKBgGCVYKGXAo6CgtzY2hlbWFfbmFtZRIrQilvJSXIuiY/ay4j6p2g8JCLpu+4kS7itbA44aSlJDw/JTzwnZKifiJ0JwoUCgRraW5kEgxCCkdpZE1hcHBpbmcKigEKBXZhbHVlEoABugF9CiwKC2ZpbmdlcnByaW50Eh1CGyQiJ/CRsIQ44Y+jyLowyLrhiqrwkJKp6qyLJQorCglnbG9iYWxfaWQSHroBGwoZCgV2YWx1ZRIQwgENCgsBeHYBk4BllwYJjAogCgJpZBIawgEXCgoDCTBxdiYxcwiMEP///////////wE= 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +ClQKUroBTwoxCgNrZXkSKroBJwolCgVzaGFyZBIcQho9IPCRoqkl8JCMi+CmrjzwnrqbKiQv77+9NwoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CnYKdLoBcQpGCgNrZXkSP7oBPAo6CgZzb3VyY2USMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBaZRxdINzU4ApTAoaCgRraW5kEhJCEFNvdXJjZVJlZmVyZW5jZXMKCwoFdmFsdWUSAggE +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CkkKR7oBRAojCgNrZXkSHLoBGQoXCgNrZXkSEEIOXFU1L057bEQkKuG/syIKEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE 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 +CnMKcboBbgoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQo8CgV2YWx1ZRIzugEwCi4KBXNoYXJkEiVCIyZ9WCZJ8JGkjfCRo7DwpK6WKS3hiZhCPHEmfOCuhnvwn5W0 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 +CmMKYboBXgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkUKBXZhbHVlEjy6ATkKNwoFc2hhcmQSLkIs8J+VtPCfopbwkIGXS/CwraBBfCTitrlHOvCehLLguohg77+98J+gpmDqqZU= +CmUKY7oBYAo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKColycQQxRRaViYwKEQoEa2luZBIJQgdDbHVzdGVyCgsKBXZhbHVlEgIIBA== +CmgKZroBYwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgo3CgV2YWx1ZRIuugErCikKBXZhbHVlEiBCHi/wkYu0J8KlfeC7k0Bf8J2UqPCRj4jihYgv4aqFZg== +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CuUCCuICugHeAgoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCp0CCgV2YWx1ZRKTAroBjwIKEAoKY2x1c3Rlcl9pZBICCAQKxgEKBmNvbmZpZxK7AboBtwEKpQEKCGxvY2F0aW9uEpgBugGUAQqRAQoHTWFuYWdlZBKFAboBgQEKFwoRYXZhaWxhYmlsaXR5X3pvbmUSAggECi8KCWJpbGxlZF9hcxIiQiDwn5W08J+VtCYvPPCTkZNQPTQi4aqVJEfigbtP4ZKIMQoOCghpbnRlcm5hbBICCAIKDQoHcGVuZGluZxICCAIKFgoEc2l6ZRIOQgwkXkE/XfCeuqI/PVIKDQoHbG9nZ2luZxICCAQKIgoEbmFtZRIaQhgmJi/vuanwkbCCLyfwn4e2T+CskPCQtIgKDgoIb3duZXJfaWQSAggE +CkoKSLoBRQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoSCgRraW5kEgpCCERhdGFiYXNlCgsKBXZhbHVlEgIIBA== +CloKWLoBVQonCgNrZXkSILoBHQobCgRuYW1lEhNCEcKlPTxpTDU/KnJX8K6tlnspCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +Cm8KbboBagpICgNrZXkSQboBPgonCgZvYmplY3QSHboBGgoYCgRUeXBlEhC6AQ0KCwoFdmFsdWUSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= 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 +CloKWLoBVQoVCgRraW5kEg1CC1R4bldhbFNoYXJkCjwKBXZhbHVlEjO6ATAKLgoFc2hhcmQSJUIjX++/vUo3cm3wnrmfJsKlduGkpiY/77+KR/CQnoHDk2RewqQ= +CnoKeLoBdQpUCgNrZXkSTboBSgpICgNrZXkSQUI/JistJvCdi4Mke9Go8J+GmjU2eybCqVzwnZOCJOG/nyomwrPgoJzwn5W0w5vwnZK/8J+gvOC1hzwoYfCcvLkvChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CkIKQLoBPQoVCgRraW5kEg1CC1R4bldhbFNoYXJkCiQKBXZhbHVlEhu6ARgKFgoFc2hhcmQSDUIL8J6Eu9GoPfCRjIM= +CjwKOroBNwoUCgNrZXkSDboBCgoICgJpZBICCAQKEgoEa2luZBIKQghSb2xlQXV0aAoLCgV2YWx1ZRICCAQ= +CsA2Cr02ugG5NgoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQqSNgoFdmFsdWUSiDa6AYQ2Ci4KBG5hbWUSJkIk8J+VtGN78JCysn4g77uYPS5oIEIu4b+48J+crvCQtYokN2YqChwKA29pZBIVwgESCgUCMGQZPBD///////////8BCg4KCG93bmVyX2lkEgIIBAqrJAoKcHJpdmlsZWdlcxKcJLIBmCQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwERWFc4cANDEFGMCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKhwG6AYMBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWmIlEYnUHlUJpwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCoYweHcRgAg1IYwKWroBVwoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBA0QHZjYQJnInPApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASJiKGBkcJQZR3wKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKeLoBdQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkdFGYNYVUkiJRwKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBd1I4kjZYEyQlnAoNCgdncmFudG9yEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKd5WIlBNFEWBRHAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp3ugF0CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKEBeWNEJ3ZVJkjAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCkKCh4gSEnkxWIwKDQoHZ3JhbnRvchICCAQKiQG6AYUBCg4KCGFjbF9tb2RlEgIIBAo8CgdncmFudGVlEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEwYUkIkTVZVwKcCjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKI2Z0BClUMEU2PApaugFXCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKEWmUVwRAgjFBnBD///////////8BCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpgBjA3FlSVYlGcCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgojk3QXSDNUiRCMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKDgoIYWNsX21vZGUSAggECisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACg0KB2dyYW50b3ISAggECmy6AWkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBAEUiRzaJMFRALAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKlwG6AZMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKCCAVBFJSdwaYXAo2CgdncmFudGVlEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEkRVBxeDl1N0KcCisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBKUNQYkM2JnmXHAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKBiFFZmI2QyMgHAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBKCQphzmTKAYxHAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp5ugF2Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASliB0ByWGg5dGwKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBEnABgFcnhUcDfAoNCgdncmFudG9yEgIIBApPugFMCg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBAp7ugF4CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKM1mSBgIVhmBDbAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXboBWgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAqlAboBoQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBFnR3EpJ0UIOCPAo4CgdncmFudGVlEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLASkIU4NjU4BBQmwKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBBEYgloZjU3cwHApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKigG6AYYBCg4KCGFjbF9tb2RlEgIIBAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpBzWUBCAlBwFkwKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCmcDY2CXYYmAkowKTboBSgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECm26AWoKDgoIYWNsX21vZGUSAggECisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpUFWhEVxcVITBcCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmC6AV0KDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAROJgYZ5kZU1Q1wKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoRiBSeTQwUEYXwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKTboBSgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKW7oBWAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCjOEFUVyh1Y0AZwKiAG6AYQBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUVDmWiUJ5hxAVwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwF3gQM4hSSQYAJcCm66AWsKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKPAoHZ3JhbnRvchIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBZYgxUmZGgWMGjApaugFXCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKEIkHkWVVYYBznBD///////////8BCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBdFGWFVdnB3JZLAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFHhZIwZQWDVhE8Cg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECn66AXsKDgoIYWNsX21vZGUSAggECjwKB2dyYW50ZWUSMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASZkclRiIjVnBDwKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAK9RAKBXJ1bGVzEusQsgHnEAqpAboBpQEKDAoGYWN0aW9uEgIIBAooCgdhZGRyZXNzEh1CG+GKvuCsvW5v0ajgqoHgsYLhnInDgtGo77+9JQogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKSQoEbmFtZRJBQj/wnLmS8J+IgHs8XTwu8J+sm+C1h+C+pibwkY2XPVzgsZV24KGeJvCflbRnwqXirpEx8JGFtVLwkY2MMfCRkaAKbboBagobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACh8KB2FkZHJlc3MSFEISIlhz4rSTZ2zwlr+wX++ssM6tCg8KCWRpcmVjdGlvbhICCAQKGQoEbmFtZRIRQg87OvCdhKPwkLaBPTrgppUKXLoBWQoMCgZhY3Rpb24SAggECg4KB2FkZHJlc3MSA0IBdAogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKFwoEbmFtZRIPQg3wn5W0LvCcs58kOsO4CqsBugGnAQoMCgZhY3Rpb24SAggECi4KB2FkZHJlc3MSI0Ih8J6fquGlgPCQqLXhv7ngs69eJCTwkKC8dFzwnoS2IsKlCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAApFCgRuYW1lEj1CO/CQs7vwkYy2e2IuLtu+PeGDhyTgq4zwnY2WOfCdlJrwn5W08JGkieCqni8mZ+KSr/CRmZM98JK+q9GoCoIBugF/CgwKBmFjdGlvbhICCAQKQQoHYWRkcmVzcxI2QjThp5k6KuCmuC4vZygl8JGSlcOZaGHwnoSz4b2d4Le0OeCvgkBcavCRtaPgvK5geSpM44WyCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoKCgRuYW1lEgJCAAqmAboBogEKDAoGYWN0aW9uEgIIBAo+CgdhZGRyZXNzEjNCMSbwkZibJOC2lVzwn5W08J6XuvCQh7Jt4KuMXTwqPGgzTyYqPOOEuTxBJOChmMi6UlwKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACjAKBG5hbWUSKEImePCWv6AofEZ7XPCQqYE9dfCflbQz8JCetTolfVRJYO+/vfCxrpgKtwG6AbMBCgwKBmFjdGlvbhICCAQKSQoHYWRkcmVzcxI+Qjzhio1A8J+VtFQp8J+VtFIi8JCNuGDzoIaJ8J64pGh7Ke+vl+GqtiLwkIyRJz8/8JGklvCflbR2L/CRjZAKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACjYKBG5hbWUSLkIsePCeubrvv4c4PM26JCrfqmRCLHvvrYHhqonwkLOiXjLwkbS6IvCfq6LRqGAKgQG6AX4KDAoGYWN0aW9uEgIIBAozCgdhZGRyZXNzEihCJsKle2VhI1okft2CYUB38J+VtPCQoIjwkY+Q77+98J64uT3gsrIuCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoXCgRuYW1lEg9CDV8vJVLwmr++WOK2jTwKtAG6AbABChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKQwoHYWRkcmVzcxI4QjbDlH7RqPCQir/RqGElX2Bce2zgt50mPSQiJvCwu4bwkJaVNHwu4K+H8JCAmOGKivCRtL3gu4AKDwoJZGlyZWN0aW9uEgIIBAo7CgRuYW1lEjNCMSXwkKi4c/CQq59FTyI/4Z2LVsKlPfCcvLDCpSbwkIagaOCvjDxhJlzwkKiFPSfIumIKfroBewobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACiIKB2FkZHJlc3MSF0IV8JGruFwkyLrgrpPwkLyg4LaK0ag+Cg8KCWRpcmVjdGlvbhICCAQKJwoEbmFtZRIfQh3gtI894KGe17HvrJbgr7dlXPCdkLY/4LGWXVxuJgp4ugF1ChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKNAoHYWRkcmVzcxIpQicmRfCeo4nhoJlsyLp7YC/wnrmJIvCeuaHwnrm7SFbRqPCRmZLIuj0KDwoJZGlyZWN0aW9uEgIIBAoPCgRuYW1lEgdCBSTwn5unCqQBugGgAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACkMKB2FkZHJlc3MSOEI28Ja/sUnwkY2LUTXwnbyncC/jgIglJy7wkJeHP++/vSYkamgp8JGKlSI8PVwlJPCeuZs9S1R5CiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoaCgRuYW1lEhJCEPCel5Y6IsK68JGOsmTvv70Kf7oBfAobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACi8KB2FkZHJlc3MSJEIiL+qhpUnwkYigY/CQnrfwnoCf4LK8PfCeupbhv4g9Jz1cYgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKCgoEbmFtZRICQgAKfroBewobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChcKB2FkZHJlc3MSDEIKfPCeuYtjUsi6RQogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKIQoEbmFtZRIZQhdVP+CxneCqinfwkIaFQS5k8JCepSImfgp5ugF2ChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKHwoHYWRkcmVzcxIUQhLgoJbgprJ68JGHr3vhrrTgpqQKDwoJZGlyZWN0aW9uEgIIBAolCgRuYW1lEh1CG+Csg0Jtbe+yjdGo8J64u+CuksKl8JCEgiLCpQ== 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== +CpkBCpYBugGSAQpVCgNrZXkSTroBSwpJCgNrZXkSQkJAZzUkcfCbi4vRqPCepJku8JGMs0BK76irwrQ9wqVg8J2VhHs8XGA64Z6s8Jajuj3vv5pjJzzwkYy48JGOi+2fjAoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwFUhnWUZgJGh3d8 +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CmkKZ7oBZAooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKHAoFdmFsdWUSE7oBEAoOCghhY2xfbW9kZRICCAQ= +CoUCCoICugH+AQo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCpaIcjQEBpaIYWwKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQqhAQoFdmFsdWUSlwG6AZMBCh4KCmNsdXN0ZXJfaWQSELoBDQoLCgV2YWx1ZRICCAQKDAoGY29uZmlnEgIIBApTCgRuYW1lEktCScKlKOCqrTw18Jy+oPCRqJLvv73grYMm8JC0uMOL4K6f8JGDpvCQqZPwlqy/aDo78J2FqlPwkJa8yLrRqPCdh5Tgp53IuvCflbQKDgoIb3duZXJfaWQSAggE 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 +ClUKU7oBUAoyCgNrZXkSK7oBKAomCgVzaGFyZBIdQhvwkbyAWSfwkaS3JT9sYvCRgZZu77+9w5E9yLoKGgoEa2luZBISQhBVbmZpbmFsaXplZFNoYXJk +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CvcCCvQCugHwAgrZAgoDa2V5EtECugHNAgrKAgoFZXZlbnQSwAK6AbwCCrkCCgJWMRKyAroBrgIKvQEKB2RldGFpbHMSsQG6Aa0BCqoBChFBbHRlclNvdXJjZVNpbmtWMRKUAboBkAEKKQoCaWQSI0Ih8JG2kTciXuK7nOGmuuCumfCRpJE/ZPCehJXwnYSL4LOMCgoKBG5hbWUSAggECg4KCG5ld19zaXplEgIIBApHCghvbGRfc2l6ZRI7ugE4CjYKBWlubmVyEi1CKy8nJEVHPXx3XPCei7/wkIGD8JCegGYkPPCQoJrvv5TwkLaO8J65vuC+oCIKGQoKZXZlbnRfdHlwZRILwgEICgYBh5CBYIwKFgoCaWQSEMIBDQoLASABBVkpmRZzkjwKGgoLb2JqZWN0X3R5cGUSC8IBCAoGAQJ1MnMsChEKC29jY3VycmVkX2F0EgIIBAoKCgR1c2VyEgIIBAoSCgRraW5kEgpCCEF1ZGl0TG9n +CqoBCqcBugGjAQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKWAoFdmFsdWUST7oBTApKCgVzaGFyZBJBQj/wkI+OJlxfLsKlJiTwnpexbPCWhKXhr7xbMy/wkb+R4LGo4bywL1fgqpXwn5u0LsKn8JGcpfCbspXgr67vv70= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CnQKcroBbwpECgNrZXkSPboBOgobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCgsKBXZhbHVlEgIIBA== +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CvYDCvMDugHvAwoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKzQMKBXZhbHVlEsMDugG/Awo1CgRuYW1lEi1CK8Kl8JGOjmzgrIvwkJaC4LOeKl/hn7lc77+9OvCflbRI77mqRFx7R/CeiqwKEgoDb2lkEgvCAQgKBgM3gGUlnAocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBArTAgoKcHJpdmlsZWdlcxLEArIBwAIKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKhgG6AYIBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKCBMxZwKCZyMBnAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKlSEgkoZXJDhHPApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKSSAldpZTEEEWXAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBA== +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +Cl8KXboBWgo4CgNrZXkSMboBLgosCgRuYW1lEiRCIuCunHs64Kyu4LC+8J65h+CxjfCusawr8JGZpNGoND1ZKnMKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== 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 +CpABCo0BugGJAQpeCgNrZXkSV7oBVAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCjEEIgV3VZUoh0wKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CmsKaboBZgosCgNrZXkSJboBIgoQCgpjbHVzdGVyX2lkEgIIBAoOCgRuYW1lEgZCBPCQkagKKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CgsKBXZhbHVlEgIIBA== +Co4BCosBugGHAQoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCkoKBXZhbHVlEkG6AT4KPAoFc2hhcmQSM0Ix8JCTi2Q78J+Ip2BZP0rwn5y4IuGJnOC7l/CRl4NiKTwkJuqZhWrclfCRoIpy8JCouQ== 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 +ClQKUroBTwotCgNrZXkSJroBIwoMCgZvYmplY3QSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= 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 +CpsBCpgBugGUAQpyCgNrZXkSa7oBaAonCgZvYmplY3QSHboBGgoYCgRTaW5rEhC6AQ0KCwoFdmFsdWUSAggECj0KDXN1Yl9jb21wb25lbnQSLLoBKQonCglDb2x1bW5Qb3MSGsIBFwoKCRFwklcUcVmDTBD///////////8BChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= 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 +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIUm9sZUF1dGgKCwoFdmFsdWUSAggE +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoJUnWSBgEFkVRMChgKBWVwb2NoEg/CAQwKChZREyRTeRVmkB0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CmkKZ7oBZAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo7CgV2YWx1ZRIyugEvCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXNHOERolGcHhnw= +CnIKcLoBbQoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApNCgV2YWx1ZRJEugFBCj8KB2NvbW1lbnQSNEIy8JGPmOCpnuK6jMKpyLrwkbaV4Ki1w6EqXOCun3jwkJavV++/vWbikYU/KTNoV37hv5M= +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +CqMBCqABugGcAQoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwp5CgV2YWx1ZRJwugFtCigKC2ZpbmdlcnByaW50EhlCF+CyqsO78JGLs2DwnrKS8JarhGros6VcCioKCWdsb2JhbF9pZBIdugEaChgKBXZhbHVlEg/CAQwKCmA2RniESRdlkDwKFQoCaWQSD8IBDAoKYUWXdWB3hYk3XA== +CsUBCsIBugG+AQqDAQoDa2V5Eny6AXkKOAoKY2x1c3Rlcl9pZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgqEknN1JFCCVWc8Cj0KBG5hbWUSNUIzX/CRsrHwn6yA4raJ77+D8J+VtMOR4KyPevCRr7figb0qU1rwkIev8J+VtFnhv4Av4LqtCikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpQEoNwJQFDJhEcChgKBWVwb2NoEg/CAQwKCghJQ2SBUheVkG0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cl4KXLoBWQo4CgNrZXkSMboBLgosCgNrZXkSJUIjIuqvsu+/vWjIuvCRr7RF8JColyQ9Isi6Zjrgp5d7aOGwrmsKEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CowBCokBugGFAQo7CgNrZXkSNLoBMQovCgRuYW1lEidCJT3wnYy98JC5reC2vSXiqZw64Y6Zw5HwkKO1LibCpeCovFxtXHEKEQoEa2luZBIJQgdTZXR0aW5nCjMKBXZhbHVlEiq6AScKJQoFdmFsdWUSHEIa8JCTreGetyI7duCwh8i6VSbwn5W08J65qj0= +ClAKTroBSwotCgNrZXkSJroBIwohCgVzaGFyZBIYQhYvOuCwj+Cpni8mXnnwkICLLsO/b1h5ChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CqgBCqUBugGhAQpnCgNrZXkSYLoBXQo5CgpjbHVzdGVyX2lkEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEEFXkWWRlwBmRcCiAKBG5hbWUSGEIWwqglPPCcvKEk4Ki88Jq/vuC1s+CqsgopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE +CmsKaboBZgoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKciKCN0Yxg3FobA== +CmEKX7oBXAo9CgNrZXkSNroBMwoxCgJpZBIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBMDZlNhYyIDR1bAoOCgRraW5kEgZCBFJvbGUKCwoFdmFsdWUSAggE +CnIKcLoBbQpPCgNrZXkSSLoBRQpDCgVzaGFyZBI6QjhLdeGghfCRtqXRqHJKJU08PfCRtYUl4bOC8JaujdaP4aS6fCRc4K6G8J65oSfwnpebJFRILkrRqAoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CmgKZroBYwoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKNFcRhAAGMENDjA== +CjoKOLoBNQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CkgKRroBQwoYCgNrZXkSEboBDgoMCgZzb3VyY2USAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CmQKYroBXwo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKChcRZCMlQhMQJIwKEAoEa2luZBIIQgZTY2hlbWEKCwoFdmFsdWUSAggE +CoQBCoEBugF+ClAKA2tleRJJugFGCkQKBG5hbWUSPEI677+9JuC0iMKlJPCRjLZUP/CbgbRteyp58J6fpnDwkJa4OHPwq52V4KiwYfCflbQ0w6/wn5W0Ki9HIAodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +CmYKZLoBYQokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgo3mWlWYWAWliAcCiMKBWVwb2NoEhrCARcKCgRBRJUDZQZQZH0Q////////////AQoUCgRraW5kEgxCCkZlbmNlVG9rZW4= +CsYCCsMCugG/Agq6AQoDa2V5ErIBugGuAQpKCgtvYmplY3RfbmFtZRI7QjlX4LCi8JG0iyrwnoWGyLoi8J2bkn7IuvCflbTigpfCpfCdvIHiurvwkYa58J65m3tnPMKl8J2AuCQKGQoLb2JqZWN0X3R5cGUSCsIBBwoFl3E0NW0KRQoLc2NoZW1hX25hbWUSNkI04reWyLpxL/CWvJLwn6m0JCZOIj3XtHZV4Kiz8JuFpvCQoIXwkJamYu+/vSrwn5W08J2qogoUCgRraW5kEgxCCkdpZE1hcHBpbmcKagoFdmFsdWUSYboBXgozCgtmaW5nZXJwcmludBIkQiLCpci6JWwu8J6AhO+mjuGngj128JGFhnTgu4Hjhrt74LaFCg8KCWdsb2JhbF9pZBICCAQKFgoCaWQSEMIBDQoLAReZgocAFBKGSTw= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= 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 +CmwKaroBZwo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCgGBMCIpMVZlMYwKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +Cuo9Cuc9ugHjPQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQq8PQoFdmFsdWUSsj26Aa49CjEKBG5hbWUSKUInWD/jh7PhvZkuw7smYOG/gvCRvrBKe8Kl8J+VtGYuO/CegKTwlr+wChEKA29pZBIKwgEHCgUpkBZGnAocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBAr3GwoKcHJpdmlsZWdlcxLoG7IB5BsKaLoBZQoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEENQCWeQkQB3UcCl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqUhQJ3ZpOHYJmcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjVGQHKYZwZ2dEwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKhgG6AYIBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKgFM3kHKVNpQljAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCikSNWKINGmGB2wKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAqGAboBggEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBaDOHNmcBAZNCXAoNCgdncmFudGVlEgIIBApCCgdncmFudG9yEje6ATQKMgoFdmFsdWUSKboBJgokCgZTeXN0ZW0SGsIBFwoKEzUhYkIAQnZnPBD///////////8BClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBVxU2hCY3eDgkLAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAptugFqCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKAVmHlZNHlGg3LAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJUIhUzFUVUdUbAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQWTIBkUQIRpWZwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKhgG6AYIBCjYKCGFjbF9tb2RlEiq6AScKJQoIYml0ZmxhZ3MSGcIBFgoJkzeGVHgTlVccEP///////////wEKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApPugFMCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQZTIUQjlnYXUYwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKXLoBWQoOCghhY2xfbW9kZRICCAQKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwF4iQIHAIBFYRmMCg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXboBWgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASEiUgeGFlcgJXwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKXboBWgoOCghhY2xfbW9kZRICCAQKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKeLoBdQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE0EGEhMVQkgQIsCg0KB2dyYW50ZWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKc0EmASAgNWEXnAp7ugF4CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKUSMUFYEpQwRZfAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKW7oBWAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCoN1diUIl0mXIXwKiAG6AYQBCg4KCGFjbF9tb2RlEgIIBAo4CgdncmFudGVlEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAYJXUAcnIwNxRmwKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEVFmFBMVUWVDY8Cne6AXQKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoQCIUjcgVURpEcCjUKB2dyYW50ZWUSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKQ2aTCAdkFACSPAoNCgdncmFudG9yEgIIBApougFlCg4KCGFjbF9tb2RlEgIIBAo2CgdncmFudGVlEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFHeEAmlFCZOQWcChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpclF0iSY2GSAEwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAp3ugF0CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMzgolJBYYZRZbAoNCgdncmFudGVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCliCBxcmZmUjlhwKiAG6AYQBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKRUEEeGMXdhFQLAo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKE2hhAGSYOQaZnAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECpQBugGQAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgcHeRgJkGEDgSwQ////////////AQpGCgdncmFudGVlEju6ATgKNgoFdmFsdWUSLboBKgooCgpQcmVkZWZpbmVkEhrCARcKChdIBzdiFgGCM0wQ////////////AQoNCgdncmFudG9yEgIIBAqIAboBhAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBMpNXdTFgFlSSLAo2CgdncmFudGVlEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFSKZUwhllThwCMChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKeroBdwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClEUZIAQMmWRASwKDQoHZ3JhbnRlZRICCAQKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFkNRQglXWJSFGcCn26AXoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpAIHEAlAaWRSVsCg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKmEORczeTFJByjAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECs0gCgVydWxlcxLDILIBvyAKY7oBYAobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChgKB2FkZHJlc3MSDUILLDxAJz8qPOCstiAKDwoJZGlyZWN0aW9uEgIIBAoWCgRuYW1lEg5CDOGJmDpa4KCwZUXCpQpbugFYCgwKBmFjdGlvbhICCAQKFgoHYWRkcmVzcxILQgk9P/CdlJLitqIKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACg4KBG5hbWUSBkIE4b+sdQqVAboBkQEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAoPCgdhZGRyZXNzEgRCAkcvCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAo/CgRuYW1lEjdCNSbCpS7IuiTwkYyz4KKN8J+bsHDwnL6aL8Oq4K+QJ+Gjq+OHgyJI8JCgiOCxo/CflbR74b2hCme6AWQKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAoNCgdhZGRyZXNzEgJCAAogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKFAoEbmFtZRIMQgo5MUdc4LGHYC8uCli6AVUKDAoGYWN0aW9uEgIIBAooCgdhZGRyZXNzEh1CG++zgS8lwqUmKntRPyQmXCJb0ajDqfCeuLV4OgoPCglkaXJlY3Rpb24SAggECgoKBG5hbWUSAkIACp4BugGaAQoMCgZhY3Rpb24SAggECj4KB2FkZHJlc3MSM0Ixw6HgqI8xWfCeubzwn5W0w5/grpzwn6m54LqI0bfwkJueeu+/vfCflbQ/77+9YEbRqAogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKKAoEbmFtZRIgQh7wkKCILiZ4OvCQl6FjJe+/vXt+LSjwkYqS8J2cj2AKfboBegobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACi0KB2FkZHJlc3MSIkIgPSXhi6fwkZa/Pybvv70jzpjwnrmC8J+VtE4wNOC7nCIKDwoJZGlyZWN0aW9uEgIIBAobCgRuYW1lEhNCEfCdi5HhpKvgr7Q877+977+9CqgBugGkAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjkKB2FkZHJlc3MSLkIsSC9s8J2LkCvgqofwn6CdJlzwn5W0XjV3OuCznvCQpIrwkbG+LmtjKiY8L1IKDwoJZGlyZWN0aW9uEgIIBAo5CgRuYW1lEjFCLyZIXGM8ePCQp4zwnZS0LkRMQPCRi7kuY++zkUcn8JC1sD/grqQ6yLpSXS8qPSY9CsoBugHGAQoMCgZhY3Rpb24SAggECkYKB2FkZHJlc3MSO0I56p+QeUHwkbKD77+98J2LqnvIunXwkbGhKvCQtoXCpfCWrZLqlIrgvJU077+9MGAqOsKlyLrhs5M/CiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAApMCgRuYW1lEkRCQk014L+OWPCQloHqpKzwkY+H8J+YsTk/4LGH8JCCuT8mYPCfqLYuJChgZic6S++/veC3mlnwn5W08J+VtPCRkq9XXQqGAboBggEKDAoGYWN0aW9uEgIIBAoeCgdhZGRyZXNzEhNCEWNsPe+/vS4lbXvgp7rgsZUmCg8KCWRpcmVjdGlvbhICCAQKQQoEbmFtZRI5QjfgtaPgqbVVevCetK3wkJWfXGw24L+KPPCesoPvv70qJWBDR++/vTUkIFHhqqTwnYi+ZSUkLzokCnW6AXIKDAoGYWN0aW9uEgIIBAoZCgdhZGRyZXNzEg5CDO+/vSbgr4htJuGKsgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKJQoEbmFtZRIdQhtBb/Cfh6jgp6LCpMi60ahQIiYsYPCehYPDkU0KX7oBXAobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChEKB2FkZHJlc3MSBkIEIXttLgoPCglkaXJlY3Rpb24SAggEChkKBG5hbWUSEUIPL+C7nSxCJmhG8JCoklZxCmC6AV0KDAoGYWN0aW9uEgIIBAoVCgdhZGRyZXNzEgpCCGDgp4tO762DCg8KCWRpcmVjdGlvbhICCAQKJQoEbmFtZRIdQhvhnI4iQfCflbQk8JahtOqfvO+/vfCen7Hgro8KeroBdwobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACicKB2FkZHJlc3MSHEIaMu+/lfCRpIk/LtGoYC/vv73wnZKsJz8kJCIKDwoJZGlyZWN0aW9uEgIIBAoeCgRuYW1lEhZCFOCohkjDguCmnWYk8J+JkCfwkY+ICpwBugGYAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACkAKB2FkZHJlc3MSNUIzWmngpodpdcK1P+GLji7wq72tYEk0TeCqgkwk8JG0pFp7TfCQtZlTZFNg4LCSeFrwkYyMCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoVCgRuYW1lEg1CC/CRtpAiJPCWraU8CnW6AXIKDAoGYWN0aW9uEgIIBAoxCgdhZGRyZXNzEiZCJC9Q4Kej77+9MSVt4LqEJeCyuS/gr5fwkKmAYWXwn4mF8J+ghAoPCglkaXJlY3Rpb24SAggECh4KBG5hbWUSFkIULuGnk++5tPCQm5ngvK4/OHteV0UKuAG6AbQBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKSwoHYWRkcmVzcxJAQj7gt5bwn5W08J2QoWAqJD1cJvCdkqIrZ+GgiiJs4KiP8J2SpT8kZfCRjaLhvIvgqLk8yLrhvZDwkJOa4aCUIgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKJgoEbmFtZRIeQhzqrIY5P1k6d1oi4Y2sfDXwkY+FeW/WjfCflbRgCmK6AV8KGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAodCgdhZGRyZXNzEhJCECF78J+VtC/wkYeP8JC8lTQKDwoJZGlyZWN0aW9uEgIIBAoQCgRuYW1lEghCBvCvo7vRqAqmAboBogEKDAoGYWN0aW9uEgIIBAo6CgdhZGRyZXNzEi9CLSIxUfCeuqPit5FIV/CflbTwlr6dKvCRsqrDr2AlWi4vPOqpsPCQpL988Ja1igogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKNAoEbmFtZRIsQipb4K6cL/CeuaQ9LPCeuY/wkaCUJ1hcdCVRwqU+w6olPFZSJS/wkYGZPV8Kf7oBfAobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjkKB2FkZHJlc3MSLkIs8J2etOGwhvCflbQk4Y2nezfwn4Co772S6pyQ8Ja6mPCfiJnirbvwkY2QU0UKDwoJZGlyZWN0aW9uEgIIBAoRCgRuYW1lEglCBzo68JCpu0oKiAG6AYQBCgwKBmFjdGlvbhICCAQKQAoHYWRkcmVzcxI1QjMzRfCfiZAtNWjwnpOZ4ZyR4Ymb4KuQJtGo8KuclWo/XC/CpT/wroS177+90ajgt6knJiUKDwoJZGlyZWN0aW9uEgIIBAohCgRuYW1lEhlCF/CeubY64aSI4LGiyLrhiZ3gs5Xwn5W0Cm+6AWwKDAoGYWN0aW9uEgIIBAovCgdhZGRyZXNzEiRCIjM5M1l74b29YC/wn6ucLvCQo6UnPVE0ROC/k+qjk+C9lSUKDwoJZGlyZWN0aW9uEgIIBAoaCgRuYW1lEhJCEOKBm08vJi7wn6qG8JingScKZLoBYQoMCgZhY3Rpb24SAggECjMKB2FkZHJlc3MSKEImauG1jDzgr5c3PVkwYDgsyLrRqOqpjdGo4KmHXTB7JyLgqrLgpooKDwoJZGlyZWN0aW9uEgIIBAoLCgRuYW1lEgNCAVAKjwG6AYsBCgwKBmFjdGlvbhICCAQKPgoHYWRkcmVzcxIzQjHjgKcyOC/wlqu1c/CRhZ/gsZUvOifWjyJUYCnIuj1g8JCVmCTgrpMlyLpkL/CfoZVwCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoZCgRuYW1lEhFCD21z1LnwrrWsYyXwkJaBYApougFlCgwKBmFjdGlvbhICCAQKGgoHYWRkcmVzcxIPQg3RqEt20ajgu5hcJjZeCg8KCWRpcmVjdGlvbhICCAQKKAoEbmFtZRIgQh7itK3vv709Ij9cPU8k8JCNkFrwkbaRJMKle/CeuqEKTLoBSQoMCgZhY3Rpb24SAggEChcKB2FkZHJlc3MSDEIKPe+qquCvkC8uJwoPCglkaXJlY3Rpb24SAggECg8KBG5hbWUSB0IFOeK2pi4K0gG6Ac4BCgwKBmFjdGlvbhICCAQKWgoHYWRkcmVzcxJPQk0uKvCRjLXwkJa58J+vpPCflbRwyLrDnXbwkKC8aO+/vfCRjovwn6Ks4Kqy8J+VtPCQlqnvv73wkKywPzzwnrmbYCU/QEzRqDVq8LGSmgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKQAoEbmFtZRI4QjZc8JG9kC4m8JuynvCdkZAnQHs48Ja+lPCeubvqqYTCuz/wkZquPci6Ij/vv73wkZyRKPCQprAKWboBVgobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChMKB2FkZHJlc3MSCEIG8J6AkWMkCg8KCWRpcmVjdGlvbhICCAQKEQoEbmFtZRIJQgc3e/CRgIE5CqwBugGoAQoMCgZhY3Rpb24SAggECigKB2FkZHJlc3MSHUIbLsOFJjzwkaS38JGEumwlaT57UipxwqXqn5FXCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAApMCgRuYW1lEkRCQiY6OkvqrIzgs7Pwn6m08J6kmC7wnrmfPeCoueC2qCLjgKheM8OTJdGowqXCtdaHP/CfnKHwn5W0JuCqi/CeuaQnIgq2AboBsgEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAApQCgdhZGRyZXNzEkVCQ1dUaD/igILvv73wnZWLdvCbsbLvrpvwkbCH4K6C8J6ApPCdlL57w517JOK3lvCeuKnwn5W00ahEPfCeooXCpfCRkqkKDwoJZGlyZWN0aW9uEgIIBAowCgRuYW1lEihCJvCdlIgm4Y+74rWG4LKO8JuynlFkJy0kXPCwvJx4JfCfhJ1RKiI6CqUBugGhAQoMCgZhY3Rpb24SAggECkcKB2FkZHJlc3MSPEI676yW8J+VtPCQgL1b77ar4K2BJTDDmMKl4LOW4L+Y8JCWisKo4YyUP9Go4LipKsOuXOCwkOGdi0o/JQoPCglkaXJlY3Rpb24SAggECjcKBG5hbWUSL0ItW/CflbQqJsKlXCRCLjHwkbyPKnJH4aiDYF48JFzwkYqMRCXgr4xcM/CflbQv +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= diff --git a/src/catalog/src/durable/upgrade/v78_to_v79.rs b/src/catalog/src/durable/upgrade/v78_to_v79.rs new file mode 100644 index 0000000000000..cf98452289515 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v78_to_v79.rs @@ -0,0 +1,18 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v78 as v78, objects_v79 as v79}; + +/// In v79, we added the replacement catalog item. +pub fn upgrade( + _snapshot: Vec, +) -> Vec> { + Vec::new() +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 6a92d741b25fc..d774af50a59bd 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -56,6 +56,7 @@ use mz_sql::plan::{ }; use mz_sql::rbac; use mz_sql::session::vars::OwnedVarInput; +use mz_sql_parser::ast::CreateMaterializedViewStatement; use mz_storage_client::controller::IntrospectionType; use mz_storage_types::connections::inline::ReferencedConnection; use mz_storage_types::sinks::{SinkEnvelope, StorageSinkConnection}; @@ -822,6 +823,10 @@ impl mz_sql::catalog::CatalogItem for CatalogCollectionEntry { fn latest_version(&self) -> Option { self.entry.latest_version() } + + fn replaces_item(&self) -> Option { + self.entry.replaces_item() + } } #[derive(Debug, Clone, Serialize)] @@ -838,6 +843,7 @@ pub enum CatalogItem { Secret(Secret), Connection(Connection), ContinualTask(ContinualTask), + ReplacementMaterializedView(ReplacementMaterializedView), } impl From for durable::Item { @@ -1446,6 +1452,112 @@ impl MaterializedView { } } +#[derive(Debug, Clone, Serialize)] +pub struct ReplacementMaterializedView { + /// Parse-able SQL that defines this replacement materialized view. + pub create_sql: String, + /// [`GlobalId`] used to reference this replacement materialized view from outside the catalog. + pub global_id: GlobalId, + /// The item this replacement materialized view replaces. + pub replaces: CatalogItemId, + /// Raw high-level expression from planning, derived from the `create_sql`. + pub raw_expr: Arc, + /// Optimized mid-level expression, derived from the `raw_expr`. + pub optimized_expr: Arc, + /// Columns for this materialized view. + pub desc: RelationDesc, + /// Other catalog items that this replacement materialized view references, determined at name resolution. + pub resolved_ids: ResolvedIds, + /// All of the catalog objects that are referenced by this view. + pub dependencies: DependencyIds, + /// Cluster that this replacement materialized view runs on. + pub cluster_id: ClusterId, + /// Column indexes that we assert are not `NULL`. + /// + /// TODO(parkmycar): Switch this to use the `ColumnIdx` type. + pub non_null_assertions: Vec, + /// Custom compaction window, e.g. set via `ALTER RETAIN HISTORY`. + pub custom_logical_compaction_window: Option, + /// Schedule to refresh this replacement materialized view, e.g. set via `REFRESH EVERY` option. + pub refresh_schedule: Option, + /// The initial `as_of` of the storage collection associated with the replacement materialized view. + /// + /// Note: This doesn't change upon restarts. + /// (The dataflow's initial `as_of` can be different.) + pub initial_as_of: Option>, +} + +impl ReplacementMaterializedView { + /// The single [`GlobalId`] this [`ReplacementMaterializedView`] can be referenced by. + pub fn global_id(&self) -> GlobalId { + self.global_id + } + + /// Merge the definition of the replacement into an existing materialized view. + pub fn merge_into(&self, mv: &MaterializedView) -> MaterializedView { + let replacement_create_stmt = mz_sql::parse::parse(&self.create_sql) + .unwrap_or_else(|e| { + panic!( + "create_sql cannot be invalid: `{}` --- error: `{}`", + self.create_sql, e + ) + }) + .into_element() + .ast; + let mv_create_stmt = mz_sql::parse::parse(&mv.create_sql) + .unwrap_or_else(|e| { + panic!( + "create_sql cannot be invalid: `{}` --- error: `{}`", + self.create_sql, e + ) + }) + .into_element() + .ast; + let create_sql = match (replacement_create_stmt, mv_create_stmt) { + ( + Statement::CreateReplacementMaterializedView(rmv_stmt), + Statement::CreateMaterializedView(mut mv_stmt), + ) => { + let CreateMaterializedViewStatement { + if_exists: _, + name: _, + columns, + in_cluster, + query, + as_of, + with_options, + } = &mut mv_stmt; + columns.clone_from(&rmv_stmt.columns); + in_cluster.clone_from(&rmv_stmt.in_cluster); + query.clone_from(&rmv_stmt.query); + as_of.clone_from(&rmv_stmt.as_of); + with_options.clone_from(&rmv_stmt.with_options); + + mv_stmt.to_ast_string_stable() + } + _ => unreachable!(), + }; + let latest_version = mv.desc.latest_version(); + let version = latest_version.bump(); + let mut new = MaterializedView { + create_sql, + collections: mv.collections.clone(), + raw_expr: Arc::clone(&self.raw_expr), + optimized_expr: Arc::clone(&self.optimized_expr), + desc: VersionedRelationDesc::new(self.desc.clone()), + resolved_ids: self.resolved_ids.clone(), + dependencies: self.dependencies.clone(), + cluster_id: self.cluster_id, + non_null_assertions: self.non_null_assertions.clone(), + custom_logical_compaction_window: self.custom_logical_compaction_window, + refresh_schedule: self.refresh_schedule.clone(), + initial_as_of: self.initial_as_of.clone(), + }; + new.collections.insert(version, self.global_id()); + new + } +} + #[derive(Debug, Clone, Serialize)] pub struct Index { /// Parse-able SQL that defines this table. @@ -1642,6 +1754,9 @@ impl CatalogItem { CatalogItem::Secret(_) => CatalogItemType::Secret, CatalogItem::Connection(_) => CatalogItemType::Connection, CatalogItem::ContinualTask(_) => CatalogItemType::ContinualTask, + CatalogItem::ReplacementMaterializedView(_) => { + CatalogItemType::ReplacementMaterializedView + } } } @@ -1659,6 +1774,7 @@ impl CatalogItem { CatalogItem::Index(index) => index.global_id, CatalogItem::Func(func) => func.global_id, CatalogItem::Type(ty) => ty.global_id, + CatalogItem::ReplacementMaterializedView(mv) => mv.global_id, CatalogItem::Secret(secret) => secret.global_id, CatalogItem::Connection(conn) => conn.global_id, CatalogItem::Table(table) => { @@ -1685,6 +1801,7 @@ impl CatalogItem { CatalogItem::Secret(secret) => secret.global_id, CatalogItem::Connection(conn) => conn.global_id, CatalogItem::Table(table) => table.global_id_writes(), + CatalogItem::ReplacementMaterializedView(mv) => mv.global_id, } } @@ -1695,7 +1812,8 @@ impl CatalogItem { | CatalogItem::Source(_) | CatalogItem::MaterializedView(_) | CatalogItem::Sink(_) - | CatalogItem::ContinualTask(_) => true, + | CatalogItem::ContinualTask(_) + | Self::ReplacementMaterializedView(_) => true, CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Index(_) @@ -1734,6 +1852,7 @@ impl CatalogItem { | CatalogItem::Sink(_) | CatalogItem::Secret(_) | CatalogItem::Connection(_) => None, + Self::ReplacementMaterializedView(_mv) => None, } } @@ -1800,6 +1919,7 @@ impl CatalogItem { CatalogItem::Secret(_) => &*EMPTY, CatalogItem::Connection(connection) => &connection.resolved_ids, CatalogItem::ContinualTask(ct) => &ct.resolved_ids, + Self::ReplacementMaterializedView(mv) => &mv.resolved_ids, } } @@ -1827,6 +1947,7 @@ impl CatalogItem { CatalogItem::ContinualTask(ct) => uses.extend(ct.dependencies.0.iter().copied()), CatalogItem::Secret(_) => {} CatalogItem::Connection(_) => {} + Self::ReplacementMaterializedView(mv) => uses.extend(mv.dependencies.0.iter().copied()), } uses } @@ -1846,7 +1967,8 @@ impl CatalogItem { | CatalogItem::Type(_) | CatalogItem::Func(_) | CatalogItem::Connection(_) - | CatalogItem::ContinualTask(_) => None, + | CatalogItem::ContinualTask(_) + | Self::ReplacementMaterializedView(_) => None, } } @@ -1931,6 +2053,11 @@ impl CatalogItem { i.create_sql = do_rewrite(i.create_sql)?; Ok(CatalogItem::ContinualTask(i)) } + Self::ReplacementMaterializedView(i) => { + let mut i = i.clone(); + i.create_sql = do_rewrite(i.create_sql)?; + Ok(CatalogItem::ReplacementMaterializedView(i)) + } } } @@ -2006,6 +2133,11 @@ impl CatalogItem { i.create_sql = do_rewrite(i.create_sql)?; Ok(CatalogItem::ContinualTask(i)) } + Self::ReplacementMaterializedView(i) => { + let mut i = i.clone(); + i.create_sql = do_rewrite(i.create_sql)?; + Ok(CatalogItem::ReplacementMaterializedView(i)) + } } } @@ -2133,6 +2265,9 @@ impl CatalogItem { | CatalogItem::Secret(Secret { create_sql, .. }) | CatalogItem::Connection(Connection { create_sql, .. }) | CatalogItem::ContinualTask(ContinualTask { create_sql, .. }) => Some(create_sql), + Self::ReplacementMaterializedView(ReplacementMaterializedView { + create_sql, .. + }) => Some(create_sql), CatalogItem::Func(_) | CatalogItem::Log(_) => None, }; let Some(create_sql) = create_sql else { @@ -2168,7 +2303,8 @@ impl CatalogItem { | CatalogItem::Func(_) | CatalogItem::Secret(_) | CatalogItem::Connection(_) - | CatalogItem::ContinualTask(_) => None, + | CatalogItem::ContinualTask(_) + | Self::ReplacementMaterializedView(_) => None, } } @@ -2195,6 +2331,7 @@ impl CatalogItem { | CatalogItem::Func(_) | CatalogItem::Secret(_) | CatalogItem::Connection(_) => None, + Self::ReplacementMaterializedView(mv) => Some(mv.cluster_id), } } @@ -2214,6 +2351,7 @@ impl CatalogItem { | CatalogItem::Secret(_) | CatalogItem::Connection(_) | CatalogItem::ContinualTask(_) => None, + Self::ReplacementMaterializedView(mv) => mv.custom_logical_compaction_window, } } @@ -2236,6 +2374,7 @@ impl CatalogItem { | CatalogItem::Secret(_) | CatalogItem::Connection(_) | CatalogItem::ContinualTask(_) => return None, + Self::ReplacementMaterializedView(mv) => &mut mv.custom_logical_compaction_window, }; Some(cw) } @@ -2253,7 +2392,8 @@ impl CatalogItem { | CatalogItem::Source(_) | CatalogItem::Index(_) | CatalogItem::MaterializedView(_) - | CatalogItem::ContinualTask(_) => self.custom_logical_compaction_window(), + | CatalogItem::ContinualTask(_) + | Self::ReplacementMaterializedView(_) => self.custom_logical_compaction_window(), CatalogItem::Log(_) | CatalogItem::View(_) | CatalogItem::Sink(_) @@ -2281,7 +2421,8 @@ impl CatalogItem { | CatalogItem::Func(_) | CatalogItem::Secret(_) | CatalogItem::Connection(_) - | CatalogItem::ContinualTask(_) => false, + | CatalogItem::ContinualTask(_) + | Self::ReplacementMaterializedView(_) => false, } } @@ -2341,6 +2482,9 @@ impl CatalogItem { CatalogItem::ContinualTask(ct) => { (ct.create_sql.clone(), ct.global_id, BTreeMap::new()) } + CatalogItem::ReplacementMaterializedView(mview) => { + (mview.create_sql.clone(), mview.global_id, BTreeMap::new()) + } } } @@ -2387,6 +2531,9 @@ impl CatalogItem { } CatalogItem::Func(_) => unreachable!("cannot serialize functions yet"), CatalogItem::ContinualTask(ct) => (ct.create_sql, ct.global_id, BTreeMap::new()), + CatalogItem::ReplacementMaterializedView(mview) => { + (mview.create_sql, mview.global_id, BTreeMap::new()) + } } } @@ -2406,6 +2553,7 @@ impl CatalogItem { CatalogItem::Secret(secret) => return Some(secret.global_id), CatalogItem::Connection(conn) => return Some(conn.global_id), CatalogItem::ContinualTask(ct) => return Some(ct.global_id), + CatalogItem::ReplacementMaterializedView(rmv) => return Some(rmv.global_id), }; match version { RelationVersionSelector::Latest => collections.values().last().copied(), @@ -2458,6 +2606,14 @@ impl CatalogEntry { } } + /// Returns the inner [`ReplacementMaterializedView`] if this entry is a materialized view, else `None`. + pub fn replacement_materialized_view(&self) -> Option<&ReplacementMaterializedView> { + match self.item() { + CatalogItem::ReplacementMaterializedView(rmv) => Some(rmv), + _ => None, + } + } + /// Returns the inner [`Table`] if this entry is a table, else `None`. pub fn table(&self) -> Option<&Table> { match self.item() { @@ -2616,7 +2772,8 @@ impl CatalogEntry { | CatalogItem::Func(_) | CatalogItem::Secret(_) | CatalogItem::Connection(_) - | CatalogItem::ContinualTask(_) => None, + | CatalogItem::ContinualTask(_) + | CatalogItem::ReplacementMaterializedView(_) => None, } } @@ -3340,6 +3497,10 @@ impl mz_sql::catalog::CatalogItem for CatalogEntry { CatalogItem::Func(_) => "", CatalogItem::Log(_) => "", CatalogItem::ContinualTask(ContinualTask { create_sql, .. }) => create_sql, + CatalogItem::ReplacementMaterializedView(ReplacementMaterializedView { + create_sql, + .. + }) => create_sql, } } @@ -3441,6 +3602,13 @@ impl mz_sql::catalog::CatalogItem for CatalogEntry { fn latest_version(&self) -> Option { self.table().map(|t| t.desc.latest_version()) } + + fn replaces_item(&self) -> Option { + match &self.item() { + CatalogItem::ReplacementMaterializedView(rmv) => Some(rmv.replaces), + _ => None, + } + } } /// A single update to the catalog state. diff --git a/src/environmentd/src/http/sql.rs b/src/environmentd/src/http/sql.rs index 764a579b0be68..fc9e7d23977c1 100644 --- a/src/environmentd/src/http/sql.rs +++ b/src/environmentd/src/http/sql.rs @@ -1475,6 +1475,7 @@ async fn execute_stmt( | ExecuteResponse::CreatedContinualTask { .. } | ExecuteResponse::CreatedType | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedReplacementMaterializedView | ExecuteResponse::Comment | ExecuteResponse::Deleted(_) | ExecuteResponse::DiscardedTemp diff --git a/src/environmentd/tests/testdata/http/ws b/src/environmentd/tests/testdata/http/ws index 82dc90999937d..2d97e0eff03f6 100644 --- a/src/environmentd/tests/testdata/http/ws +++ b/src/environmentd/tests/testdata/http/ws @@ -402,7 +402,7 @@ ws-text ws-text {"query": "SELECT 1 FROM mz_sources LIMIT 1"} ---- -{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"data\": [\n 45,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t80:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t79\\n\\nt79:\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t80\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 79\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": [\n 0,\n null\n ]\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t79\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 752\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 45,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n →Map/Filter/Project\\n Project: #15\\n Map: 1\\n →Indexed mz_catalog.mz_sources (using mz_catalog.mz_sources_ind)\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 469\n },\n {\n \"System\": 752\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 45,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s752\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' FROM [s469 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} +{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"data\": [\n 45,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t80:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t79\\n\\nt79:\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t80\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 79\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": [\n 0,\n null\n ]\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t79\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 755\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 45,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n →Map/Filter/Project\\n Project: #15\\n Map: 1\\n →Indexed mz_catalog.mz_sources (using mz_catalog.mz_sources_ind)\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 469\n },\n {\n \"System\": 755\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 45,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s755\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' FROM [s469 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} {"type":"CommandStarting","payload":{"has_rows":true,"is_streaming":false}} {"type":"Rows","payload":{"columns":[{"name":"?column?","type_oid":23,"type_len":4,"type_mod":-1}]}} {"type":"Row","payload":["1"]} @@ -412,7 +412,7 @@ ws-text ws-text {"query": "SELECT 1 / 0 FROM mz_sources LIMIT 1"} ---- -{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map ((1 / 0))\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"CallBinary\": {\n \"func\": {\n \"DivInt32\": null\n },\n \"expr1\": {\n \"Literal\": [\n {\n \"data\": [\n 45,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n },\n \"expr2\": {\n \"Literal\": [\n {\n \"data\": [\n 44\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n },\n \"name\": null\n }\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t83:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t82\\n\\nt82:\\n Project (#15)\\n Map (error(\\\"division by zero\\\"))\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t83\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 82\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": [\n 0,\n null\n ]\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t82\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 752\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n →Map/Filter/Project\\n Project: #15\\n Map: error(\\\"division by zero\\\")\\n →Indexed mz_catalog.mz_sources (using mz_catalog.mz_sources_ind)\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 469\n },\n {\n \"System\": 752\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s752\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' / '' FROM [s469 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} +{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map ((1 / 0))\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"CallBinary\": {\n \"func\": {\n \"DivInt32\": null\n },\n \"expr1\": {\n \"Literal\": [\n {\n \"data\": [\n 45,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n },\n \"expr2\": {\n \"Literal\": [\n {\n \"data\": [\n 44\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n },\n null\n ]\n },\n \"name\": null\n }\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t83:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t82\\n\\nt82:\\n Project (#15)\\n Map (error(\\\"division by zero\\\"))\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t83\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 82\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": [\n 0,\n null\n ]\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t82\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 469\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 755\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n →Map/Filter/Project\\n Project: #15\\n Map: error(\\\"division by zero\\\")\\n →Indexed mz_catalog.mz_sources (using mz_catalog.mz_sources_ind)\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 469\n },\n {\n \"System\": 755\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s755\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' / '' FROM [s469 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} {"type":"CommandStarting","payload":{"has_rows":false,"is_streaming":false}} {"type":"Error","payload":{"message":"division by zero","code":"XX000"}} {"type":"ReadyForQuery","payload":"I"} diff --git a/src/pgrepr-consts/src/oid.rs b/src/pgrepr-consts/src/oid.rs index bd4c3f6189001..f62e516f2837b 100644 --- a/src/pgrepr-consts/src/oid.rs +++ b/src/pgrepr-consts/src/oid.rs @@ -437,6 +437,7 @@ pub const TABLE_MZ_SOURCES_OID: u32 = 16710; pub const TABLE_MZ_SINKS_OID: u32 = 16711; pub const TABLE_MZ_VIEWS_OID: u32 = 16712; pub const TABLE_MZ_MATERIALIZED_VIEWS_OID: u32 = 16713; +pub const TABLE_MZ_REPLACEMENT_MATERIALIZED_VIEWS_OID: u32 = 16732; pub const TABLE_MZ_TYPES_OID: u32 = 16714; pub const TABLE_MZ_TYPE_PG_METADATA_OID: u32 = 16715; pub const TABLE_MZ_ARRAY_TYPES_OID: u32 = 16716; @@ -600,6 +601,7 @@ pub const VIEW_PG_EXTENSION_OID: u32 = 16875; pub const VIEW_MZ_SHOW_SOURCES_OID: u32 = 16876; pub const VIEW_MZ_SHOW_SINKS_OID: u32 = 16877; pub const VIEW_MZ_SHOW_MATERIALIZED_VIEWS_OID: u32 = 16878; +pub const VIEW_MZ_SHOW_REPLACEMENTS_OID: u32 = 17062; pub const VIEW_MZ_SHOW_INDEXES_OID: u32 = 16879; pub const VIEW_MZ_SHOW_CLUSTER_REPLICAS_OID: u32 = 16880; pub const VIEW_MZ_SHOW_ROLE_MEMBERS_OID: u32 = 16881; @@ -628,6 +630,7 @@ pub const INDEX_MZ_SHOW_TABLES_IND_OID: u32 = 16903; pub const INDEX_MZ_SHOW_SOURCES_IND_OID: u32 = 16904; pub const INDEX_MZ_SHOW_VIEWS_IND_OID: u32 = 16905; pub const INDEX_MZ_SHOW_MATERIALIZED_VIEWS_IND_OID: u32 = 16906; +pub const INDEX_MZ_SHOW_REPLACEMENTS_IND_OID: u32 = 17063; pub const INDEX_MZ_SHOW_SINKS_IND_OID: u32 = 16907; pub const INDEX_MZ_SHOW_TYPES_IND_OID: u32 = 16908; pub const INDEX_MZ_SHOW_ALL_OBJECTS_IND_OID: u32 = 16909; diff --git a/src/pgwire/src/protocol.rs b/src/pgwire/src/protocol.rs index c396cd614cecf..a73d3c049380b 100644 --- a/src/pgwire/src/protocol.rs +++ b/src/pgwire/src/protocol.rs @@ -2104,6 +2104,7 @@ where | ExecuteResponse::CreatedView { .. } | ExecuteResponse::CreatedViews { .. } | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedReplacementMaterializedView | ExecuteResponse::Comment | ExecuteResponse::Deallocate { .. } | ExecuteResponse::Deleted(..) diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index e126ccd581f50..babb47acd8f83 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -40,6 +40,7 @@ Analysis Analyze And Any +Apply Arity Arn Arranged @@ -390,6 +391,8 @@ Rename Reoptimize Repeatable Replace +Replacement +Replacements Replan Replica Replicas diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index 22cb27da9ea26..6addd5972a0f6 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -65,12 +65,14 @@ pub enum Statement { CreateClusterReplica(CreateClusterReplicaStatement), CreateSecret(CreateSecretStatement), CreateNetworkPolicy(CreateNetworkPolicyStatement), + CreateReplacementMaterializedView(CreateReplacementMaterializedViewStatement), AlterCluster(AlterClusterStatement), AlterOwner(AlterOwnerStatement), AlterObjectRename(AlterObjectRenameStatement), AlterObjectSwap(AlterObjectSwapStatement), AlterRetainHistory(AlterRetainHistoryStatement), AlterIndex(AlterIndexStatement), + AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementStatement), AlterSecret(AlterSecretStatement), AlterSetCluster(AlterSetClusterStatement), AlterSink(AlterSinkStatement), @@ -143,6 +145,7 @@ impl AstDisplay for Statement { Statement::CreateCluster(stmt) => f.write_node(stmt), Statement::CreateClusterReplica(stmt) => f.write_node(stmt), Statement::CreateNetworkPolicy(stmt) => f.write_node(stmt), + Statement::CreateReplacementMaterializedView(stmt) => f.write_node(stmt), Statement::AlterCluster(stmt) => f.write_node(stmt), Statement::AlterNetworkPolicy(stmt) => f.write_node(stmt), Statement::AlterOwner(stmt) => f.write_node(stmt), @@ -150,6 +153,7 @@ impl AstDisplay for Statement { Statement::AlterRetainHistory(stmt) => f.write_node(stmt), Statement::AlterObjectSwap(stmt) => f.write_node(stmt), Statement::AlterIndex(stmt) => f.write_node(stmt), + Statement::AlterMaterializedViewApplyReplacement(stmt) => f.write_node(stmt), Statement::AlterSetCluster(stmt) => f.write_node(stmt), Statement::AlterSecret(stmt) => f.write_node(stmt), Statement::AlterSink(stmt) => f.write_node(stmt), @@ -224,11 +228,15 @@ pub fn statement_kind_label_value(kind: StatementKind) -> &'static str { StatementKind::CreateClusterReplica => "create_cluster_replica", StatementKind::CreateSecret => "create_secret", StatementKind::CreateNetworkPolicy => "create_network_policy", + StatementKind::CreateReplacementMaterializedView => "create_replacement_materialized_view", StatementKind::AlterCluster => "alter_cluster", StatementKind::AlterObjectRename => "alter_object_rename", StatementKind::AlterRetainHistory => "alter_retain_history", StatementKind::AlterObjectSwap => "alter_object_swap", StatementKind::AlterIndex => "alter_index", + StatementKind::AlterMaterializedViewApplyReplacement => { + "alter_materialized_view_apply_replacement" + } StatementKind::AlterNetworkPolicy => "alter_network_policy", StatementKind::AlterRole => "alter_role", StatementKind::AlterSecret => "alter_secret", @@ -1432,6 +1440,53 @@ impl AstDisplay for CreateMaterializedViewStatement { } impl_display_t!(CreateMaterializedViewStatement); +/// `CREATE REPLACEMENT .. FOR MATERIALIZED VIEW` +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateReplacementMaterializedViewStatement { + pub name: UnresolvedItemName, + pub target_name: T::ItemName, + pub columns: Vec, + pub in_cluster: Option, + pub query: Query, + pub as_of: Option, + pub with_options: Vec>, +} + +impl AstDisplay for CreateReplacementMaterializedViewStatement { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("CREATE REPLACEMENT "); + f.write_node(&self.name); + f.write_str(" FOR MATERIALIZED VIEW "); + f.write_node(&self.target_name); + + if !self.columns.is_empty() { + f.write_str(" ("); + f.write_node(&display::comma_separated(&self.columns)); + f.write_str(")"); + } + + if let Some(cluster) = &self.in_cluster { + f.write_str(" IN CLUSTER "); + f.write_node(cluster); + } + + if !self.with_options.is_empty() { + f.write_str(" WITH ("); + f.write_node(&display::comma_separated(&self.with_options)); + f.write_str(")"); + } + + f.write_str(" AS "); + f.write_node(&self.query); + + if let Some(time) = &self.as_of { + f.write_str(" AS OF "); + f.write_str(time); + } + } +} +impl_display_t!(CreateReplacementMaterializedViewStatement); + /// `CREATE CONTINUAL TASK` #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct CreateContinualTaskStatement { @@ -2822,6 +2877,23 @@ impl AstDisplay for AlterIndexStatement { impl_display_t!(AlterIndexStatement); +/// `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT ..` +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AlterMaterializedViewApplyReplacementStatement { + pub materialized_view_name: T::ItemName, + pub replacement_name: T::ItemName, +} + +impl AstDisplay for AlterMaterializedViewApplyReplacementStatement { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("ALTER MATERIALIZED VIEW "); + f.write_node(&self.materialized_view_name); + f.write_str(" APPLY REPLACEMENT "); + f.write_node(&self.replacement_name); + } +} +impl_display_t!(AlterMaterializedViewApplyReplacementStatement); + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum AlterSinkAction { SetOptions(Vec>), @@ -3428,6 +3500,9 @@ pub enum ShowObjectType { in_cluster: Option, }, NetworkPolicy, + Replacement { + in_cluster: Option, + }, } /// `SHOW S` /// @@ -3471,6 +3546,7 @@ impl AstDisplay for ShowObjectsStatement { ShowObjectType::RoleMembership { .. } => "ROLE MEMBERSHIP", ShowObjectType::ContinualTask { .. } => "CONTINUAL TASKS", ShowObjectType::NetworkPolicy => "NETWORK POLICIES", + ShowObjectType::Replacement { .. } => "REPLACEMENTS", }); if let ShowObjectType::Index { on_object, .. } = &self.object_type { @@ -3496,7 +3572,8 @@ impl AstDisplay for ShowObjectsStatement { | ShowObjectType::Index { in_cluster, .. } | ShowObjectType::Sink { in_cluster } | ShowObjectType::Source { in_cluster } - | ShowObjectType::ContinualTask { in_cluster } => { + | ShowObjectType::ContinualTask { in_cluster } + | ShowObjectType::Replacement { in_cluster } => { if let Some(cluster) = in_cluster { f.write_str(" IN CLUSTER "); f.write_node(cluster); @@ -3621,6 +3698,25 @@ impl AstDisplay for ShowCreateMaterializedViewStatement { } impl_display_t!(ShowCreateMaterializedViewStatement); +/// `SHOW [REDACTED] CREATE REPLACEMENT ` +#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct ShowCreateReplacementStatement { + pub replacement_name: T::ItemName, + pub redacted: bool, +} + +impl AstDisplay for ShowCreateReplacementStatement { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("SHOW "); + if self.redacted { + f.write_str("REDACTED "); + } + f.write_str("CREATE REPLACEMENT "); + f.write_node(&self.replacement_name); + } +} +impl_display_t!(ShowCreateReplacementStatement); + /// `SHOW [REDACTED] CREATE SOURCE ` #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct ShowCreateSourceStatement { @@ -4225,6 +4321,7 @@ pub enum ObjectType { Subsource, ContinualTask, NetworkPolicy, + Replacement, } impl ObjectType { @@ -4241,7 +4338,8 @@ impl ObjectType { | ObjectType::Connection | ObjectType::Func | ObjectType::Subsource - | ObjectType::ContinualTask => true, + | ObjectType::ContinualTask + | ObjectType::Replacement => true, ObjectType::Database | ObjectType::Schema | ObjectType::Cluster @@ -4273,6 +4371,7 @@ impl AstDisplay for ObjectType { ObjectType::Subsource => "SUBSOURCE", ObjectType::ContinualTask => "CONTINUAL TASK", ObjectType::NetworkPolicy => "NETWORK POLICY", + ObjectType::Replacement => "REPLACEMENT", }) } } @@ -5132,6 +5231,7 @@ pub enum ShowStatement { ShowColumns(ShowColumnsStatement), ShowCreateView(ShowCreateViewStatement), ShowCreateMaterializedView(ShowCreateMaterializedViewStatement), + ShowCreateReplacement(ShowCreateReplacementStatement), ShowCreateSource(ShowCreateSourceStatement), ShowCreateTable(ShowCreateTableStatement), ShowCreateSink(ShowCreateSinkStatement), @@ -5150,6 +5250,7 @@ impl AstDisplay for ShowStatement { ShowStatement::ShowColumns(stmt) => f.write_node(stmt), ShowStatement::ShowCreateView(stmt) => f.write_node(stmt), ShowStatement::ShowCreateMaterializedView(stmt) => f.write_node(stmt), + ShowStatement::ShowCreateReplacement(stmt) => f.write_node(stmt), ShowStatement::ShowCreateSource(stmt) => f.write_node(stmt), ShowStatement::ShowCreateTable(stmt) => f.write_node(stmt), ShowStatement::ShowCreateSink(stmt) => f.write_node(stmt), diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index 32c71f4ac5f61..4d9ab82e4aa38 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -20,6 +20,8 @@ //! SQL Parser +mod replace; + use std::collections::BTreeMap; use std::error::Error; use std::fmt; @@ -1982,6 +1984,8 @@ impl<'a> Parser<'a> { } else if self.peek_keywords(&[NETWORK, POLICY]) { self.parse_create_network_policy() .map_parser_err(StatementKind::CreateNetworkPolicy) + } else if self.peek_one_of_keywords(&[REPLACE, REPLACEMENT]) { + self.parse_create_replace() } else { let index = self.index; @@ -4892,7 +4896,8 @@ impl<'a> Parser<'a> { | ObjectType::Type | ObjectType::Secret | ObjectType::Connection - | ObjectType::ContinualTask => { + | ObjectType::ContinualTask + | ObjectType::Replacement => { let names = self.parse_comma_separated(|parser| { Ok(UnresolvedObjectName::Item(parser.parse_item_name()?)) })?; @@ -5608,7 +5613,8 @@ impl<'a> Parser<'a> { ObjectType::View | ObjectType::MaterializedView | ObjectType::Table - | ObjectType::ContinualTask => self.parse_alter_views(object_type), + | ObjectType::ContinualTask + | ObjectType::Replacement => self.parse_alter_views(object_type), ObjectType::Type => { let if_exists = self .parse_if_exists() @@ -6432,10 +6438,10 @@ impl<'a> Parser<'a> { ) -> Result, ParserStatementError> { let if_exists = self.parse_if_exists().map_no_statement_parser_err()?; let name = self.parse_item_name().map_no_statement_parser_err()?; - let keywords = if object_type == ObjectType::Table { - [SET, RENAME, OWNER, RESET, ADD].as_slice() - } else { - [SET, RENAME, OWNER, RESET].as_slice() + let keywords = match object_type { + ObjectType::Table => [SET, RENAME, OWNER, RESET, ADD].as_slice(), + ObjectType::MaterializedView => [SET, RENAME, OWNER, RESET, APPLY].as_slice(), + _ => [SET, RENAME, OWNER, RESET].as_slice(), }; let action = self @@ -6526,6 +6532,27 @@ impl<'a> Parser<'a> { }, )) } + APPLY => { + assert_eq!( + object_type, + ObjectType::MaterializedView, + "checked object_type above" + ); + + self.expect_keyword(REPLACEMENT) + .map_parser_err(StatementKind::AlterMaterializedViewApplyReplacement)?; + + let replacement_name = self + .parse_raw_name() + .map_parser_err(StatementKind::AlterMaterializedViewApplyReplacement)?; + + Ok(Statement::AlterMaterializedViewApplyReplacement( + AlterMaterializedViewApplyReplacementStatement { + materialized_view_name: RawItemName::Name(name), + replacement_name, + }, + )) + } _ => unreachable!(), } } @@ -7240,7 +7267,8 @@ impl<'a> Parser<'a> { | ObjectType::Secret | ObjectType::Connection | ObjectType::Func - | ObjectType::ContinualTask => UnresolvedObjectName::Item(self.parse_item_name()?), + | ObjectType::ContinualTask + | ObjectType::Replacement => UnresolvedObjectName::Item(self.parse_item_name()?), ObjectType::Role => UnresolvedObjectName::Role(self.parse_identifier()?), ObjectType::Cluster => UnresolvedObjectName::Cluster(self.parse_identifier()?), ObjectType::ClusterReplica => { @@ -8071,6 +8099,10 @@ impl<'a> Parser<'a> { format!("Unsupported SHOW on {object_type}") ); } + ObjectType::Replacement => { + let in_cluster = self.parse_optional_in_cluster()?; + ShowObjectType::Replacement { in_cluster } + } }; Ok(ShowStatement::ShowObjects(ShowObjectsStatement { object_type: show_object_type, @@ -8109,6 +8141,13 @@ impl<'a> Parser<'a> { redacted, }, )) + } else if self.parse_keywords(&[CREATE, REPLACEMENT]) { + Ok(ShowStatement::ShowCreateReplacement( + ShowCreateReplacementStatement { + replacement_name: self.parse_raw_name()?, + redacted, + }, + )) } else if self.parse_keywords(&[CREATE, SOURCE]) { Ok(ShowStatement::ShowCreateSource(ShowCreateSourceStatement { source_name: self.parse_raw_name()?, @@ -9516,7 +9555,8 @@ impl<'a> Parser<'a> { | ObjectType::ClusterReplica | ObjectType::Role | ObjectType::Func - | ObjectType::Subsource => { + | ObjectType::Subsource + | ObjectType::Replacement => { parser_err!( self, self.peek_prev_pos(), @@ -9555,6 +9595,7 @@ impl<'a> Parser<'a> { FUNCTION, CONTINUAL, NETWORK, + REPLACEMENT, ])? { TABLE => ObjectType::Table, VIEW => ObjectType::View, @@ -9596,6 +9637,7 @@ impl<'a> Parser<'a> { } ObjectType::NetworkPolicy } + REPLACEMENT => ObjectType::Replacement, _ => unreachable!(), }, ) @@ -9728,6 +9770,7 @@ impl<'a> Parser<'a> { SUBSOURCES, CONTINUAL, NETWORK, + REPLACEMENTS, ])? { TABLES => ObjectType::Table, VIEWS => ObjectType::View, @@ -9774,6 +9817,7 @@ impl<'a> Parser<'a> { return None; } } + REPLACEMENTS => ObjectType::Replacement, _ => unreachable!(), }, ) diff --git a/src/sql-parser/src/parser/replace.rs b/src/sql-parser/src/parser/replace.rs new file mode 100644 index 0000000000000..2350c9ea7b503 --- /dev/null +++ b/src/sql-parser/src/parser/replace.rs @@ -0,0 +1,82 @@ +// Copyright 2018 sqlparser-rs contributors. All rights reserved. +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// This file is derived from the sqlparser-rs project, available at +// https://github.com/andygrove/sqlparser-rs. It was incorporated +// directly into Materialize on December 21, 2019. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License in the LICENSE file at the +// root of this repository, or online at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! SQL Parser for REPLACE statements. + +use mz_sql_lexer::keywords::*; +use mz_sql_lexer::lexer::Token; + +use crate::ast::*; +use crate::parser::IsOptional::Optional; +use crate::parser::{Parser, ParserError, ParserStatementError, ParserStatementErrorMapper}; + +impl<'a> Parser<'a> { + /// Parse a SQL CREATE REPLACEMENT statement + pub(super) fn parse_create_replace(&mut self) -> Result, ParserStatementError> { + self.expect_one_of_keywords(&[REPLACE, REPLACEMENT]) + .map_no_statement_parser_err()?; + let name = self.parse_item_name().map_no_statement_parser_err()?; + self.expect_keyword(FOR).map_no_statement_parser_err()?; + if self.peek_keywords(&[MATERIALIZED, VIEW]) { + self.parse_replace_materialized_view(name) + .map_parser_err(StatementKind::CreateReplacementMaterializedView) + } else { + let expected_msg = { "MATERIALIZED VIEW after REPLACEMENT .. FOR" }; + self.expected(self.peek_pos(), expected_msg, self.peek_token()) + .map_no_statement_parser_err() + } + } + + fn parse_replace_materialized_view( + &mut self, + name: UnresolvedItemName, + ) -> Result, ParserError> { + self.expect_keywords(&[MATERIALIZED, VIEW])?; + + let target_name = self.parse_raw_name()?; + let columns = self.parse_parenthesized_column_list(Optional)?; + let in_cluster = self.parse_optional_in_cluster()?; + + let with_options = if self.parse_keyword(WITH) { + self.expect_token(&Token::LParen)?; + let options = self.parse_comma_separated(Parser::parse_materialized_view_option)?; + self.expect_token(&Token::RParen)?; + options + } else { + vec![] + }; + + self.expect_keyword(AS)?; + let query = self.parse_query()?; + let as_of = self.parse_optional_internal_as_of()?; + + Ok(Statement::CreateReplacementMaterializedView( + CreateReplacementMaterializedViewStatement { + name, + target_name, + columns, + in_cluster, + query, + as_of, + with_options, + }, + )) + } +} diff --git a/src/sql-parser/tests/testdata/alter b/src/sql-parser/tests/testdata/alter index c2c9b4a20ef09..649e621065d32 100644 --- a/src/sql-parser/tests/testdata/alter +++ b/src/sql-parser/tests/testdata/alter @@ -131,3 +131,17 @@ ALTER TABLE IF EXISTS t1 ADD COLUMN IF NOT EXISTS bar text ALTER TABLE IF EXISTS t1 ADD COLUMN IF NOT EXISTS bar text => AlterTableAddColumn(AlterTableAddColumnStatement { if_exists: true, name: UnresolvedItemName([Ident("t1")]), if_col_not_exist: true, column_name: Ident("bar"), data_type: Other { name: Name(UnresolvedItemName([Ident("text")])), typ_mod: [] } }) + +parse-statement +ALTER MATERIALIZED VIEW mv1 APPLY REPLACEMENT rp1 +---- +ALTER MATERIALIZED VIEW mv1 APPLY REPLACEMENT rp1 +=> +AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementStatement { materialized_view_name: Name(UnresolvedItemName([Ident("mv1")])), replacement_name: Name(UnresolvedItemName([Ident("rp1")])) }) + +parse-statement +ALTER MATERIALIZED VIEW mv1 APPLY REPLACEMENT rp1 rp2 +---- +error: Expected end of statement, found identifier "rp2" +ALTER MATERIALIZED VIEW mv1 APPLY REPLACEMENT rp1 rp2 + ^ diff --git a/src/sql-parser/tests/testdata/create b/src/sql-parser/tests/testdata/create index 105fa9eb8f282..98b5db69d203b 100644 --- a/src/sql-parser/tests/testdata/create +++ b/src/sql-parser/tests/testdata/create @@ -717,3 +717,38 @@ CREATE TABLE t (x int, y text VERSION ADDED '10000') error: Expected literal unsigned integer, found string literal "10000" CREATE TABLE t (x int, y text VERSION ADDED '10000') ^ + +parse-statement +CREATE REPLACEMENT IF NOT EXISTS rp1 FOR MATERIALIZED VIEW mv AS SELECT 1; +---- +error: Expected FOR, found NOT +CREATE REPLACEMENT IF NOT EXISTS rp1 FOR MATERIALIZED VIEW mv AS SELECT 1; + ^ + +parse-statement +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT 1; +---- +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT 1 +=> +CreateReplacementMaterializedView(CreateReplacementMaterializedViewStatement { name: UnresolvedItemName([Ident("rp1")]), target_name: Name(UnresolvedItemName([Ident("mv")])), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) + +parse-statement +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) AS SELECT 1; +---- +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) AS SELECT 1 +=> +CreateReplacementMaterializedView(CreateReplacementMaterializedViewStatement { name: UnresolvedItemName([Ident("rp1")]), target_name: Name(UnresolvedItemName([Ident("mv")])), columns: [Ident("a")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) + +parse-statement +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) IN CLUSTER t AS SELECT 1; +---- +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) IN CLUSTER t AS SELECT 1 +=> +CreateReplacementMaterializedView(CreateReplacementMaterializedViewStatement { name: UnresolvedItemName([Ident("rp1")]), target_name: Name(UnresolvedItemName([Ident("mv")])), columns: [Ident("a")], in_cluster: Some(Unresolved(Ident("t"))), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) + +parse-statement +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) IN CLUSTER t WITH (ASSERT NOT NULL a) AS SELECT 1; +---- +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a) IN CLUSTER t WITH (ASSERT NOT NULL = a) AS SELECT 1 +=> +CreateReplacementMaterializedView(CreateReplacementMaterializedViewStatement { name: UnresolvedItemName([Ident("rp1")]), target_name: Name(UnresolvedItemName([Ident("mv")])), columns: [Ident("a")], in_cluster: Some(Unresolved(Ident("t"))), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: AssertNotNull, value: Some(UnresolvedItemName(UnresolvedItemName([Ident("a")]))) }] }) diff --git a/src/sql-parser/tests/testdata/show b/src/sql-parser/tests/testdata/show index 06bfe779f6d91..5d67ac886349b 100644 --- a/src/sql-parser/tests/testdata/show +++ b/src/sql-parser/tests/testdata/show @@ -994,3 +994,32 @@ SHOW REDACTED MATERIALIZED error: SHOW REDACTED is only supported for SHOW REDACTED CREATE ... SHOW REDACTED MATERIALIZED ^ + +parse-statement +SHOW REPLACEMENTS +---- +SHOW REPLACEMENTS +=> +Show(ShowObjects(ShowObjectsStatement { object_type: Replacement { in_cluster: None }, from: None, filter: None })) + + +parse-statement +SHOW REPLACEMENTS FROM abc IN CLUSTER my_cluster +---- +SHOW REPLACEMENTS FROM abc IN CLUSTER my_cluster +=> +Show(ShowObjects(ShowObjectsStatement { object_type: Replacement { in_cluster: Some(Unresolved(Ident("my_cluster"))) }, from: Some(UnresolvedSchemaName([Ident("abc")])), filter: None })) + +parse-statement +SHOW REPLACEMENTS FROM abc IN CLUSTER my_cluster WHERE true +---- +SHOW REPLACEMENTS FROM abc IN CLUSTER my_cluster WHERE true +=> +Show(ShowObjects(ShowObjectsStatement { object_type: Replacement { in_cluster: Some(Unresolved(Ident("my_cluster"))) }, from: Some(UnresolvedSchemaName([Ident("abc")])), filter: Some(Where(Value(Boolean(true)))) })) + +parse-statement +SHOW REDACTED REPLACEMENTS +---- +error: SHOW REDACTED is only supported for SHOW REDACTED CREATE ... +SHOW REDACTED REPLACEMENTS + ^ diff --git a/src/sql/src/catalog.rs b/src/sql/src/catalog.rs index 404eaa0cea063..6ede3abfa9605 100644 --- a/src/sql/src/catalog.rs +++ b/src/sql/src/catalog.rs @@ -855,6 +855,9 @@ pub trait CatalogItem { /// The latest version of this item, if it's version-able. fn latest_version(&self) -> Option; + + /// The item this catalog item replaces, if any. + fn replaces_item(&self) -> Option; } /// An item in a [`SessionCatalog`] and the specific "collection"/pTVC that it @@ -895,6 +898,8 @@ pub enum CatalogItemType { Connection, /// A continual task. ContinualTask, + /// A replacement materialized view. + ReplacementMaterializedView, } impl CatalogItemType { @@ -929,6 +934,8 @@ impl CatalogItemType { CatalogItemType::Secret => false, CatalogItemType::Connection => false, CatalogItemType::ContinualTask => true, + // TODO(alter-mv): Determine if replacement materialized views should conflict with types. + CatalogItemType::ReplacementMaterializedView => false, } } } @@ -947,6 +954,9 @@ impl fmt::Display for CatalogItemType { CatalogItemType::Secret => f.write_str("secret"), CatalogItemType::Connection => f.write_str("connection"), CatalogItemType::ContinualTask => f.write_str("continual task"), + CatalogItemType::ReplacementMaterializedView => { + f.write_str("replacement materialized view") + } } } } @@ -965,6 +975,7 @@ impl From for ObjectType { CatalogItemType::Secret => ObjectType::Secret, CatalogItemType::Connection => ObjectType::Connection, CatalogItemType::ContinualTask => ObjectType::ContinualTask, + CatalogItemType::ReplacementMaterializedView => ObjectType::ReplacementMaterializedView, } } } @@ -983,6 +994,9 @@ impl From for mz_audit_log::ObjectType { CatalogItemType::Secret => mz_audit_log::ObjectType::Secret, CatalogItemType::Connection => mz_audit_log::ObjectType::Connection, CatalogItemType::ContinualTask => mz_audit_log::ObjectType::ContinualTask, + CatalogItemType::ReplacementMaterializedView => { + mz_audit_log::ObjectType::ReplacementMaterializedView + } } } } @@ -1518,6 +1532,7 @@ pub enum ObjectType { Func, ContinualTask, NetworkPolicy, + ReplacementMaterializedView, } impl ObjectType { @@ -1541,6 +1556,8 @@ impl ObjectType { | ObjectType::ClusterReplica | ObjectType::Role | ObjectType::NetworkPolicy => false, + // TODO(alter-mv): Determine if replacement MVs should be treated as relations. + ObjectType::ReplacementMaterializedView => false, } } } @@ -1566,6 +1583,8 @@ impl From for ObjectType { mz_sql_parser::ast::ObjectType::Func => ObjectType::Func, mz_sql_parser::ast::ObjectType::ContinualTask => ObjectType::ContinualTask, mz_sql_parser::ast::ObjectType::NetworkPolicy => ObjectType::NetworkPolicy, + // TODO(alter-mv): If we want to replace other objects, this needs to distinguish them. + mz_sql_parser::ast::ObjectType::Replacement => ObjectType::ReplacementMaterializedView, } } } @@ -1590,6 +1609,9 @@ impl From for ObjectType { CommentObjectId::ClusterReplica(_) => ObjectType::ClusterReplica, CommentObjectId::ContinualTask(_) => ObjectType::ContinualTask, CommentObjectId::NetworkPolicy(_) => ObjectType::NetworkPolicy, + CommentObjectId::ReplacementMaterializedView(_) => { + ObjectType::ReplacementMaterializedView + } } } } @@ -1614,6 +1636,7 @@ impl Display for ObjectType { ObjectType::Func => "FUNCTION", ObjectType::ContinualTask => "CONTINUAL TASK", ObjectType::NetworkPolicy => "NETWORK POLICY", + ObjectType::ReplacementMaterializedView => "REPLACEMENT MATERIALIZED VIEW", }) } } diff --git a/src/sql/src/names.rs b/src/sql/src/names.rs index 75ac0a4692131..2db6ac99fff7e 100644 --- a/src/sql/src/names.rs +++ b/src/sql/src/names.rs @@ -1188,7 +1188,8 @@ impl From for ObjectId { | CommentObjectId::Connection(item_id) | CommentObjectId::Type(item_id) | CommentObjectId::Secret(item_id) - | CommentObjectId::ContinualTask(item_id) => ObjectId::Item(item_id), + | CommentObjectId::ContinualTask(item_id) + | CommentObjectId::ReplacementMaterializedView(item_id) => ObjectId::Item(item_id), CommentObjectId::Role(id) => ObjectId::Role(id), CommentObjectId::Database(id) => ObjectId::Database(id), CommentObjectId::Schema(id) => ObjectId::Schema(id), @@ -1250,6 +1251,7 @@ pub enum CommentObjectId { Cluster(ClusterId), ClusterReplica((ClusterId, ReplicaId)), NetworkPolicy(NetworkPolicyId), + ReplacementMaterializedView(CatalogItemId), } /// Whether to resolve an name in the types namespace, the functions namespace, diff --git a/src/sql/src/normalize.rs b/src/sql/src/normalize.rs index 250b47077da60..94a9f892441ac 100644 --- a/src/sql/src/normalize.rs +++ b/src/sql/src/normalize.rs @@ -23,11 +23,12 @@ use mz_sql_parser::ast::visit_mut::{self, VisitMut}; use mz_sql_parser::ast::{ ContinualTaskStmt, CreateConnectionStatement, CreateContinualTaskStatement, CreateContinualTaskSugar, CreateIndexStatement, CreateMaterializedViewStatement, - CreateSecretStatement, CreateSinkStatement, CreateSourceStatement, CreateSubsourceStatement, - CreateTableFromSourceStatement, CreateTableStatement, CreateTypeStatement, CreateViewStatement, - CreateWebhookSourceStatement, CteBlock, Function, FunctionArgs, Ident, IfExistsBehavior, - MutRecBlock, Op, Query, Statement, TableFactor, TableFromSourceColumns, UnresolvedItemName, - UnresolvedSchemaName, Value, ViewDefinition, + CreateReplacementMaterializedViewStatement, CreateSecretStatement, CreateSinkStatement, + CreateSourceStatement, CreateSubsourceStatement, CreateTableFromSourceStatement, + CreateTableStatement, CreateTypeStatement, CreateViewStatement, CreateWebhookSourceStatement, + CteBlock, Function, FunctionArgs, Ident, IfExistsBehavior, MutRecBlock, Op, Query, Statement, + TableFactor, TableFromSourceColumns, UnresolvedItemName, UnresolvedSchemaName, Value, + ViewDefinition, }; use crate::names::{Aug, FullItemName, PartialItemName, PartialSchemaName, RawDatabaseSpecifier}; @@ -419,6 +420,28 @@ pub fn create_statement( *if_exists = IfExistsBehavior::Error; } + Statement::CreateReplacementMaterializedView( + CreateReplacementMaterializedViewStatement { + name, + target_name, + columns: _, + in_cluster: _, + query, + with_options: _, + as_of: _, + }, + ) => { + *name = allocate_name(name)?; + { + let mut normalizer = QueryNormalizer::new(); + normalizer.visit_item_name_mut(target_name); + normalizer.visit_query_mut(query); + if let Some(err) = normalizer.err { + return Err(err); + } + } + } + Statement::CreateContinualTask(CreateContinualTaskStatement { name, columns: _, @@ -506,7 +529,67 @@ pub fn create_statement( .retain(|o| o.name != mz_sql_parser::ast::CreateConnectionOptionName::Validate); } - _ => unreachable!(), + Statement::Select(_) + | Statement::Insert(_) + | Statement::Copy(_) + | Statement::Update(_) + | Statement::Delete(_) + | Statement::CreateDatabase(_) + | Statement::CreateSchema(_) + | Statement::CreateRole(_) + | Statement::CreateCluster(_) + | Statement::CreateClusterReplica(_) + | Statement::CreateNetworkPolicy(_) + | Statement::AlterCluster(_) + | Statement::AlterOwner(_) + | Statement::AlterObjectRename(_) + | Statement::AlterObjectSwap(_) + | Statement::AlterRetainHistory(_) + | Statement::AlterIndex(_) + | Statement::AlterMaterializedViewApplyReplacement(_) + | Statement::AlterSecret(_) + | Statement::AlterSetCluster(_) + | Statement::AlterSink(_) + | Statement::AlterSource(_) + | Statement::AlterSystemSet(_) + | Statement::AlterSystemReset(_) + | Statement::AlterSystemResetAll(_) + | Statement::AlterConnection(_) + | Statement::AlterNetworkPolicy(_) + | Statement::AlterRole(_) + | Statement::AlterTableAddColumn(_) + | Statement::Discard(_) + | Statement::DropObjects(_) + | Statement::DropOwned(_) + | Statement::SetVariable(_) + | Statement::ResetVariable(_) + | Statement::Show(_) + | Statement::StartTransaction(_) + | Statement::SetTransaction(_) + | Statement::Commit(_) + | Statement::Rollback(_) + | Statement::Subscribe(_) + | Statement::ExplainAnalyzeCluster(_) + | Statement::ExplainAnalyzeObject(_) + | Statement::ExplainPlan(_) + | Statement::ExplainPushdown(_) + | Statement::ExplainTimestamp(_) + | Statement::ExplainSinkSchema(_) + | Statement::Declare(_) + | Statement::Fetch(_) + | Statement::Close(_) + | Statement::Prepare(_) + | Statement::Execute(_) + | Statement::Deallocate(_) + | Statement::Raise(_) + | Statement::GrantRole(_) + | Statement::RevokeRole(_) + | Statement::GrantPrivileges(_) + | Statement::RevokePrivileges(_) + | Statement::AlterDefaultPrivileges(_) + | Statement::ReassignOwned(_) + | Statement::ValidateConnection(_) + | Statement::Comment(_) => unreachable!(), } Ok(stmt.to_ast_string_stable()) diff --git a/src/sql/src/plan.rs b/src/sql/src/plan.rs index 799648108b609..fa92de9089964 100644 --- a/src/sql/src/plan.rs +++ b/src/sql/src/plan.rs @@ -148,6 +148,7 @@ pub enum Plan { CreateNetworkPolicy(CreateNetworkPolicyPlan), CreateIndex(CreateIndexPlan), CreateType(CreateTypePlan), + CreateReplacementMaterializedView(CreateReplacementMaterializedViewPlan), Comment(CommentPlan), DiscardTemp, DiscardAll, @@ -183,6 +184,7 @@ pub enum Plan { AlterClusterRename(AlterClusterRenamePlan), AlterClusterReplicaRename(AlterClusterReplicaRenamePlan), AlterItemRename(AlterItemRenamePlan), + AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementPlan), AlterSchemaRename(AlterSchemaRenamePlan), AlterSchemaSwap(AlterSchemaSwapPlan), AlterSecret(AlterSecretPlan), @@ -222,6 +224,9 @@ impl Plan { StatementKind::AlterConnection => &[PlanKind::AlterNoop, PlanKind::AlterConnection], StatementKind::AlterDefaultPrivileges => &[PlanKind::AlterDefaultPrivileges], StatementKind::AlterIndex => &[PlanKind::AlterRetainHistory, PlanKind::AlterNoop], + StatementKind::AlterMaterializedViewApplyReplacement => { + &[PlanKind::AlterMaterializedViewApplyReplacement] + } StatementKind::AlterObjectRename => &[ PlanKind::AlterClusterRename, PlanKind::AlterClusterReplicaRename, @@ -282,6 +287,9 @@ impl Plan { StatementKind::CreateTableFromSource => &[PlanKind::CreateTable], StatementKind::CreateType => &[PlanKind::CreateType], StatementKind::CreateView => &[PlanKind::CreateView], + StatementKind::CreateReplacementMaterializedView => { + &[PlanKind::CreateReplacementMaterializedView] + } StatementKind::Deallocate => &[PlanKind::Deallocate], StatementKind::Declare => &[PlanKind::Declare], StatementKind::Delete => &[PlanKind::ReadThenWrite], @@ -325,7 +333,7 @@ impl Plan { } } - /// Returns a human readable name of the plan. Meant for use in messages sent back to a user. + /// Returns a human-readable name of the plan. Meant for use in messages sent back to a user. pub fn name(&self) -> &str { match self { Plan::CreateConnection(_) => "create connection", @@ -345,6 +353,7 @@ impl Plan { Plan::CreateIndex(_) => "create index", Plan::CreateType(_) => "create type", Plan::CreateNetworkPolicy(_) => "create network policy", + Plan::CreateReplacementMaterializedView(_) => "create replacement materialized view", Plan::Comment(_) => "comment", Plan::DiscardTemp => "discard temp", Plan::DiscardAll => "discard all", @@ -366,6 +375,7 @@ impl Plan { ObjectType::Func => "drop function", ObjectType::ContinualTask => "drop continual task", ObjectType::NetworkPolicy => "drop network policy", + ObjectType::ReplacementMaterializedView => "drop replacement materialized view", }, Plan::DropOwned(_) => "drop owned", Plan::EmptyQuery => "do nothing", @@ -407,6 +417,7 @@ impl Plan { ObjectType::Func => "alter function", ObjectType::ContinualTask => "alter continual task", ObjectType::NetworkPolicy => "alter network policy", + ObjectType::ReplacementMaterializedView => "alter replacement materialized view", }, Plan::AlterCluster(_) => "alter cluster", Plan::AlterClusterRename(_) => "alter cluster rename", @@ -416,6 +427,9 @@ impl Plan { Plan::AlterConnection(_) => "alter connection", Plan::AlterSource(_) => "alter source", Plan::AlterItemRename(_) => "rename item", + Plan::AlterMaterializedViewApplyReplacement(_) => { + "alter materialized view apply replacement" + } Plan::AlterSchemaRename(_) => "alter rename schema", Plan::AlterSchemaSwap(_) => "alter swap schema", Plan::AlterSecret(_) => "alter secret", @@ -443,6 +457,9 @@ impl Plan { ObjectType::Func => "alter function owner", ObjectType::ContinualTask => "alter continual task owner", ObjectType::NetworkPolicy => "alter network policy owner", + ObjectType::ReplacementMaterializedView => { + "alter replacement materialized view owner" + } }, Plan::AlterTableAddColumn(_) => "alter table add column", Plan::Declare(_) => "declare", @@ -765,6 +782,19 @@ pub struct CreateNetworkPolicyPlan { pub rules: Vec, } +#[derive(Debug, Clone)] +pub struct CreateReplacementMaterializedViewPlan { + /// The name of this replacement. + pub name: QualifiedItemName, + /// The definition of the new materialized view to replace `replaces`. + pub materialized_view: MaterializedView, + /// The Catalog objects that this materialized view is replacing, if any. + pub replaces: CatalogItemId, + /// True if the materialized view contains an expression that can make the exact column list + /// ambiguous. For example `NATURAL JOIN` or `SELECT *`. + pub ambiguous_columns: bool, +} + #[derive(Debug, Clone)] pub struct AlterNetworkPolicyPlan { pub id: NetworkPolicyId, @@ -1258,6 +1288,15 @@ pub struct AlterItemRenamePlan { pub object_type: ObjectType, } +/// A plan to apply a replacement to a materialized view. +#[derive(Debug)] +pub struct AlterMaterializedViewApplyReplacementPlan { + /// The identifier of the materialized view to update. + pub id: CatalogItemId, + /// The identifier of the replacement to apply on the materialized view. + pub replacement_id: CatalogItemId, +} + #[derive(Debug)] pub struct AlterSchemaRenamePlan { pub cur_schema_spec: (ResolvedDatabaseSpecifier, SchemaSpecifier), @@ -1820,6 +1859,25 @@ pub struct MaterializedView { pub as_of: Option, } +/// A replacement for a materialized view. +#[derive(Clone, Debug)] +pub struct ReplacementMaterializedView { + /// Parse-able SQL that is stored durably and defines this materialized view. + pub create_sql: String, + /// Unoptimized high-level expression from parsing the `create_sql`. + pub expr: HirRelationExpr, + /// All catalog objects that are referenced by this materialized view, according to the `expr`. + pub dependencies: DependencyIds, + /// Columns of this view. + pub column_names: Vec, + /// Cluster this materialized view will get installed on. + pub cluster_id: ClusterId, + pub non_null_assertions: Vec, + pub compaction_window: Option, + pub refresh_schedule: Option, + pub as_of: Option, +} + #[derive(Clone, Debug)] pub struct Index { /// Parse-able SQL that is stored durably and defines this index. diff --git a/src/sql/src/plan/query.rs b/src/sql/src/plan/query.rs index b8388d5d696be..1fd185f47e297 100644 --- a/src/sql/src/plan/query.rs +++ b/src/sql/src/plan/query.rs @@ -2066,6 +2066,10 @@ fn plan_set_expr( show::plan_show_create_materialized_view(qcx.scx, stmt.clone())?, show::describe_show_create_materialized_view(qcx.scx, stmt)?, ), + ShowStatement::ShowCreateReplacement(stmt) => to_hirscope( + show::plan_show_create_replacement(qcx.scx, stmt.clone())?, + show::describe_show_create_replacement(qcx.scx, stmt)?, + ), ShowStatement::ShowCreateType(stmt) => to_hirscope( show::plan_show_create_type(qcx.scx, stmt.clone())?, show::describe_show_create_type(qcx.scx, stmt)?, diff --git a/src/sql/src/plan/statement.rs b/src/sql/src/plan/statement.rs index a013fd153f074..c5c5384939a4c 100644 --- a/src/sql/src/plan/statement.rs +++ b/src/sql/src/plan/statement.rs @@ -33,9 +33,9 @@ use crate::catalog::{ }; use crate::names::{ self, Aug, DatabaseId, FullItemName, ItemQualifiers, ObjectId, PartialItemName, - QualifiedItemName, RawDatabaseSpecifier, ResolvedColumnReference, ResolvedDataType, - ResolvedDatabaseSpecifier, ResolvedIds, ResolvedItemName, ResolvedSchemaName, SchemaSpecifier, - SystemObjectId, + QualifiedItemName, RawDatabaseSpecifier, ResolvedClusterName, ResolvedColumnReference, + ResolvedDataType, ResolvedDatabaseSpecifier, ResolvedIds, ResolvedItemName, ResolvedSchemaName, + SchemaSpecifier, SystemObjectId, }; use crate::normalize; use crate::plan::error::PlanError; @@ -126,6 +126,9 @@ pub fn describe( Statement::AlterCluster(stmt) => ddl::describe_alter_cluster_set_options(&scx, stmt)?, Statement::AlterConnection(stmt) => ddl::describe_alter_connection(&scx, stmt)?, Statement::AlterIndex(stmt) => ddl::describe_alter_index_options(&scx, stmt)?, + Statement::AlterMaterializedViewApplyReplacement(stmt) => { + ddl::describe_alter_materialized_view_apply_replacement(&scx, stmt)? + } Statement::AlterObjectRename(stmt) => ddl::describe_alter_object_rename(&scx, stmt)?, Statement::AlterObjectSwap(stmt) => ddl::describe_alter_object_swap(&scx, stmt)?, Statement::AlterRetainHistory(stmt) => ddl::describe_alter_retain_history(&scx, stmt)?, @@ -163,6 +166,9 @@ pub fn describe( } Statement::CreateContinualTask(stmt) => ddl::describe_create_continual_task(&scx, stmt)?, Statement::CreateNetworkPolicy(stmt) => ddl::describe_create_network_policy(&scx, stmt)?, + Statement::CreateReplacementMaterializedView(stmt) => { + ddl::describe_create_replacement_materialized_view(&scx, stmt)? + } Statement::DropObjects(stmt) => ddl::describe_drop_objects(&scx, stmt)?, Statement::DropOwned(stmt) => ddl::describe_drop_owned(&scx, stmt)?, @@ -205,6 +211,9 @@ pub fn describe( Statement::Show(ShowStatement::ShowCreateMaterializedView(stmt)) => { show::describe_show_create_materialized_view(&scx, stmt)? } + Statement::Show(ShowStatement::ShowCreateReplacement(stmt)) => { + show::describe_show_create_replacement(&scx, stmt)? + } Statement::Show(ShowStatement::ShowCreateType(stmt)) => { show::describe_show_create_type(&scx, stmt)? } @@ -322,6 +331,9 @@ pub fn plan( Statement::AlterCluster(stmt) => ddl::plan_alter_cluster(scx, stmt), Statement::AlterConnection(stmt) => ddl::plan_alter_connection(scx, stmt), Statement::AlterIndex(stmt) => ddl::plan_alter_index_options(scx, stmt), + Statement::AlterMaterializedViewApplyReplacement(stmt) => { + ddl::plan_alter_materialized_view_apply_replacement(scx, stmt) + } Statement::AlterObjectRename(stmt) => ddl::plan_alter_object_rename(scx, stmt), Statement::AlterObjectSwap(stmt) => ddl::plan_alter_object_swap(scx, stmt), Statement::AlterRetainHistory(stmt) => ddl::plan_alter_retain_history(scx, stmt), @@ -355,6 +367,9 @@ pub fn plan( Statement::CreateMaterializedView(stmt) => ddl::plan_create_materialized_view(scx, stmt), Statement::CreateContinualTask(stmt) => ddl::plan_create_continual_task(scx, stmt), Statement::CreateNetworkPolicy(stmt) => ddl::plan_create_network_policy(scx, stmt), + Statement::CreateReplacementMaterializedView(stmt) => { + ddl::plan_create_replacement_materialized_view(scx, stmt) + } Statement::DropObjects(stmt) => ddl::plan_drop_objects(scx, stmt), Statement::DropOwned(stmt) => ddl::plan_drop_owned(scx, stmt), @@ -411,6 +426,9 @@ pub fn plan( Statement::Show(ShowStatement::ShowCreateMaterializedView(stmt)) => { show::plan_show_create_materialized_view(scx, stmt).map(Plan::ShowCreate) } + Statement::Show(ShowStatement::ShowCreateReplacement(stmt)) => { + show::plan_show_create_replacement(scx, stmt).map(Plan::ShowCreate) + } Statement::Show(ShowStatement::ShowCreateType(stmt)) => { show::plan_show_create_type(scx, stmt).map(Plan::ShowCreate) } @@ -1012,11 +1030,18 @@ impl<'a> StatementContext<'a> { } } -pub fn resolve_cluster_for_materialized_view<'a>( - catalog: &'a dyn SessionCatalog, +pub fn resolve_cluster_for_materialized_view( + catalog: &dyn SessionCatalog, stmt: &CreateMaterializedViewStatement, ) -> Result { - Ok(match &stmt.in_cluster { + resolve_cluster(catalog, stmt.in_cluster.as_ref()) +} + +pub fn resolve_cluster( + catalog: &dyn SessionCatalog, + in_cluster: Option<&ResolvedClusterName>, +) -> Result { + Ok(match in_cluster { None => catalog.resolve_cluster(None)?.id(), Some(in_cluster) => in_cluster.id, }) @@ -1049,6 +1074,7 @@ impl From<&Statement> for StatementClassifica Statement::AlterCluster(_) => DDL, Statement::AlterConnection(_) => DDL, Statement::AlterIndex(_) => DDL, + Statement::AlterMaterializedViewApplyReplacement(_) => DDL, Statement::AlterObjectRename(_) => DDL, Statement::AlterObjectSwap(_) => DDL, Statement::AlterNetworkPolicy(_) => DDL, @@ -1082,6 +1108,7 @@ impl From<&Statement> for StatementClassifica Statement::CreateView(_) => DDL, Statement::CreateMaterializedView(_) => DDL, Statement::CreateNetworkPolicy(_) => DDL, + Statement::CreateReplacementMaterializedView(_) => DDL, Statement::DropObjects(_) => DDL, Statement::DropOwned(_) => DDL, @@ -1118,6 +1145,7 @@ impl From<&Statement> for StatementClassifica Statement::Show(ShowStatement::ShowCreateTable(_)) => Show, Statement::Show(ShowStatement::ShowCreateView(_)) => Show, Statement::Show(ShowStatement::ShowCreateMaterializedView(_)) => Show, + Statement::Show(ShowStatement::ShowCreateReplacement(_)) => Show, Statement::Show(ShowStatement::ShowCreateType(_)) => Show, Statement::Show(ShowStatement::ShowObjects(_)) => Show, diff --git a/src/sql/src/plan/statement/acl.rs b/src/sql/src/plan/statement/acl.rs index 7cfbade73ecf7..d08d29cb64ac9 100644 --- a/src/sql/src/plan/statement/acl.rs +++ b/src/sql/src/plan/statement/acl.rs @@ -629,7 +629,8 @@ pub fn plan_alter_default_privileges( ObjectType::View | ObjectType::MaterializedView | ObjectType::Source - | ObjectType::ContinualTask => sql_bail!( + | ObjectType::ContinualTask + | ObjectType::ReplacementMaterializedView => sql_bail!( "{object_type}S is not valid for ALTER DEFAULT PRIVILEGES, use TABLES instead" ), ObjectType::Sink | ObjectType::ClusterReplica | ObjectType::Role | ObjectType::Func => { diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index e327b98bb148d..b43bf55fcbf6b 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -14,9 +14,9 @@ use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write; -use std::iter; use std::num::NonZeroU32; use std::time::Duration; +use std::{fmt, iter}; use itertools::{Either, Itertools}; use mz_adapter_types::compaction::{CompactionWindow, DEFAULT_LOGICAL_COMPACTION_WINDOW_DURATION}; @@ -45,21 +45,22 @@ use mz_repr::{ use mz_sql_parser::ast::{ self, AlterClusterAction, AlterClusterStatement, AlterConnectionAction, AlterConnectionOption, AlterConnectionOptionName, AlterConnectionStatement, AlterIndexAction, AlterIndexStatement, - AlterNetworkPolicyStatement, AlterObjectRenameStatement, AlterObjectSwapStatement, - AlterRetainHistoryStatement, AlterRoleOption, AlterRoleStatement, AlterSecretStatement, - AlterSetClusterStatement, AlterSinkAction, AlterSinkStatement, AlterSourceAction, - AlterSourceAddSubsourceOption, AlterSourceAddSubsourceOptionName, AlterSourceStatement, - AlterSystemResetAllStatement, AlterSystemResetStatement, AlterSystemSetStatement, - AlterTableAddColumnStatement, AvroSchema, AvroSchemaOption, AvroSchemaOptionName, - ClusterAlterOption, ClusterAlterOptionName, ClusterAlterOptionValue, - ClusterAlterUntilReadyOption, ClusterAlterUntilReadyOptionName, ClusterFeature, - ClusterFeatureName, ClusterOption, ClusterOptionName, ClusterScheduleOptionValue, ColumnDef, - ColumnOption, CommentObjectType, CommentStatement, ConnectionOption, ConnectionOptionName, - ContinualTaskOption, ContinualTaskOptionName, CreateClusterReplicaStatement, - CreateClusterStatement, CreateConnectionOption, CreateConnectionOptionName, - CreateConnectionStatement, CreateConnectionType, CreateContinualTaskStatement, - CreateDatabaseStatement, CreateIndexStatement, CreateMaterializedViewStatement, - CreateNetworkPolicyStatement, CreateRoleStatement, CreateSchemaStatement, + AlterMaterializedViewApplyReplacementStatement, AlterNetworkPolicyStatement, + AlterObjectRenameStatement, AlterObjectSwapStatement, AlterRetainHistoryStatement, + AlterRoleOption, AlterRoleStatement, AlterSecretStatement, AlterSetClusterStatement, + AlterSinkAction, AlterSinkStatement, AlterSourceAction, AlterSourceAddSubsourceOption, + AlterSourceAddSubsourceOptionName, AlterSourceStatement, AlterSystemResetAllStatement, + AlterSystemResetStatement, AlterSystemSetStatement, AlterTableAddColumnStatement, AvroSchema, + AvroSchemaOption, AvroSchemaOptionName, ClusterAlterOption, ClusterAlterOptionName, + ClusterAlterOptionValue, ClusterAlterUntilReadyOption, ClusterAlterUntilReadyOptionName, + ClusterFeature, ClusterFeatureName, ClusterOption, ClusterOptionName, + ClusterScheduleOptionValue, ColumnDef, ColumnOption, CommentObjectType, CommentStatement, + ConnectionOption, ConnectionOptionName, ContinualTaskOption, ContinualTaskOptionName, + CreateClusterReplicaStatement, CreateClusterStatement, CreateConnectionOption, + CreateConnectionOptionName, CreateConnectionStatement, CreateConnectionType, + CreateContinualTaskStatement, CreateDatabaseStatement, CreateIndexStatement, + CreateMaterializedViewStatement, CreateNetworkPolicyStatement, + CreateReplacementMaterializedViewStatement, CreateRoleStatement, CreateSchemaStatement, CreateSecretStatement, CreateSinkConnection, CreateSinkOption, CreateSinkOptionName, CreateSinkStatement, CreateSourceConnection, CreateSourceOption, CreateSourceOptionName, CreateSourceStatement, CreateSubsourceOption, CreateSubsourceOptionName, @@ -74,7 +75,7 @@ use mz_sql_parser::ast::{ MaterializedViewOptionName, MySqlConfigOption, MySqlConfigOptionName, NetworkPolicyOption, NetworkPolicyOptionName, NetworkPolicyRuleDefinition, NetworkPolicyRuleOption, NetworkPolicyRuleOptionName, PgConfigOption, PgConfigOptionName, ProtobufSchema, - QualifiedReplica, RefreshAtOptionValue, RefreshEveryOptionValue, RefreshOptionValue, + QualifiedReplica, Query, RefreshAtOptionValue, RefreshEveryOptionValue, RefreshOptionValue, ReplicaDefinition, ReplicaOption, ReplicaOptionName, RoleAttribute, SetRoleVar, SourceErrorPolicy, SourceIncludeMetadata, SqlServerConfigOption, SqlServerConfigOptionName, Statement, TableConstraint, TableFromSourceColumns, TableFromSourceOption, @@ -148,21 +149,22 @@ use crate::plan::with_options::{OptionalDuration, OptionalString, TryFromValue}; use crate::plan::{ AlterClusterPlan, AlterClusterPlanStrategy, AlterClusterRenamePlan, AlterClusterReplicaRenamePlan, AlterClusterSwapPlan, AlterConnectionPlan, AlterItemRenamePlan, - AlterNetworkPolicyPlan, AlterNoopPlan, AlterOptionParameter, AlterRetainHistoryPlan, - AlterRolePlan, AlterSchemaRenamePlan, AlterSchemaSwapPlan, AlterSecretPlan, - AlterSetClusterPlan, AlterSinkPlan, AlterSystemResetAllPlan, AlterSystemResetPlan, - AlterSystemSetPlan, AlterTablePlan, ClusterSchedule, CommentPlan, ComputeReplicaConfig, - ComputeReplicaIntrospectionConfig, ConnectionDetails, CreateClusterManagedPlan, - CreateClusterPlan, CreateClusterReplicaPlan, CreateClusterUnmanagedPlan, CreateClusterVariant, - CreateConnectionPlan, CreateContinualTaskPlan, CreateDatabasePlan, CreateIndexPlan, - CreateMaterializedViewPlan, CreateNetworkPolicyPlan, CreateRolePlan, CreateSchemaPlan, - CreateSecretPlan, CreateSinkPlan, CreateSourcePlan, CreateTablePlan, CreateTypePlan, - CreateViewPlan, DataSourceDesc, DropObjectsPlan, DropOwnedPlan, HirRelationExpr, Index, - MaterializedView, NetworkPolicyRule, NetworkPolicyRuleAction, NetworkPolicyRuleDirection, Plan, - PlanClusterOption, PlanNotice, PolicyAddress, QueryContext, ReplicaConfig, Secret, Sink, - Source, Table, TableDataSource, Type, VariableValue, View, WebhookBodyFormat, - WebhookHeaderFilters, WebhookHeaders, WebhookValidation, literal, plan_utils, query, - transform_ast, + AlterMaterializedViewApplyReplacementPlan, AlterNetworkPolicyPlan, AlterNoopPlan, + AlterOptionParameter, AlterRetainHistoryPlan, AlterRolePlan, AlterSchemaRenamePlan, + AlterSchemaSwapPlan, AlterSecretPlan, AlterSetClusterPlan, AlterSinkPlan, + AlterSystemResetAllPlan, AlterSystemResetPlan, AlterSystemSetPlan, AlterTablePlan, + ClusterSchedule, CommentPlan, ComputeReplicaConfig, ComputeReplicaIntrospectionConfig, + ConnectionDetails, CreateClusterManagedPlan, CreateClusterPlan, CreateClusterReplicaPlan, + CreateClusterUnmanagedPlan, CreateClusterVariant, CreateConnectionPlan, + CreateContinualTaskPlan, CreateDatabasePlan, CreateIndexPlan, CreateMaterializedViewPlan, + CreateNetworkPolicyPlan, CreateReplacementMaterializedViewPlan, CreateRolePlan, + CreateSchemaPlan, CreateSecretPlan, CreateSinkPlan, CreateSourcePlan, CreateTablePlan, + CreateTypePlan, CreateViewPlan, DataSourceDesc, DropObjectsPlan, DropOwnedPlan, + HirRelationExpr, Index, MaterializedView, NetworkPolicyRule, NetworkPolicyRuleAction, + NetworkPolicyRuleDirection, Plan, PlanClusterOption, PlanNotice, PolicyAddress, QueryContext, + ReplicaConfig, Secret, Sink, Source, Table, TableDataSource, Type, VariableValue, View, + WebhookBodyFormat, WebhookHeaderFilters, WebhookHeaders, WebhookValidation, literal, + plan_utils, query, transform_ast, }; use crate::session::vars::{ self, ENABLE_CLUSTER_SCHEDULE_REFRESH, ENABLE_COLLECTION_PARTITION_BY, @@ -2695,6 +2697,13 @@ pub fn describe_create_materialized_view( Ok(StatementDesc::new(None)) } +pub fn describe_create_replacement_materialized_view( + _: &StatementContext, + _: CreateReplacementMaterializedViewStatement, +) -> Result { + Ok(StatementDesc::new(None)) +} + pub fn describe_create_continual_task( _: &StatementContext, _: CreateContinualTaskStatement, @@ -2727,18 +2736,115 @@ pub fn plan_create_materialized_view( print_name: None, }); - let create_sql = - normalize::create_statement(scx, Statement::CreateMaterializedView(stmt.clone()))?; + // Override the statement-level IfExistsBehavior with Skip if this is + // explicitly requested in the PlanContext (the default is `false`). + let if_exists = match scx.pcx().map(|pcx| pcx.ignore_if_exists_errors) { + Ok(true) => IfExistsBehavior::Skip, + _ => stmt.if_exists, + }; - let partial_name = normalize::unresolved_item_name(stmt.name)?; + let partial_name = normalize::unresolved_item_name(stmt.name.clone())?; let name = scx.allocate_qualified_name(partial_name.clone())?; + let materialized_view = plan_create_materialized_view_inner( + scx, + Statement::CreateMaterializedView(stmt.clone()), + &stmt.columns, + stmt.query, + stmt.as_of, + cluster_id, + stmt.with_options, + format!("materialized view {}", scx.catalog.resolve_full_name(&name)), + )?; + + let mut replace = None; + let mut if_not_exists = false; + match if_exists { + IfExistsBehavior::Replace => { + let if_exists = true; + let cascade = false; + let replace_id = plan_drop_item( + scx, + ObjectType::MaterializedView, + if_exists, + partial_name.into(), + cascade, + )?; + + // Check if the new Materialized View depends on the item that we would be replacing. + if let Some(id) = replace_id { + let dependencies = materialized_view.expr.depends_on(); + let invalid_drop = scx + .get_item(&id) + .global_ids() + .any(|gid| dependencies.contains(&gid)); + if invalid_drop { + let item = scx.catalog.get_item(&id); + sql_bail!( + "cannot replace materialized view {0}: depended upon by new {0} definition", + scx.catalog.resolve_full_name(item.name()) + ); + } + replace = Some(id); + } + } + IfExistsBehavior::Skip => if_not_exists = true, + IfExistsBehavior::Error => (), + } + let drop_ids = replace + .map(|id| { + scx.catalog + .item_dependents(id) + .into_iter() + .map(|id| id.unwrap_item_id()) + .collect() + }) + .unwrap_or_default(); + + // Check for an object in the catalog with this same name + let full_name = scx.catalog.resolve_full_name(&name); + let partial_name = PartialItemName::from(full_name.clone()); + // For PostgreSQL compatibility, we need to prevent creating materialized + // views when there is an existing object *or* type of the same name. + if let (IfExistsBehavior::Error, Ok(item)) = + (if_exists, scx.catalog.resolve_item_or_type(&partial_name)) + { + return Err(PlanError::ItemAlreadyExists { + name: full_name.to_string(), + item_type: item.item_type(), + }); + } + + Ok(Plan::CreateMaterializedView(CreateMaterializedViewPlan { + name, + materialized_view, + replace, + drop_ids, + if_not_exists, + ambiguous_columns: *scx.ambiguous_columns.borrow(), + })) +} + +/// Plans the inner parts of a CREATE MATERIALIZED VIEW statement, returning a +/// materialized view definition. Shared for materialized views and their replacements. +fn plan_create_materialized_view_inner( + scx: &StatementContext, + stmt: Statement, + columns: &[Ident], + query: Query, + as_of: Option, + cluster_id: ClusterId, + with_options: Vec>, + context: impl fmt::Display, +) -> Result { + let create_sql = normalize::create_statement(scx, stmt)?; + let query::PlannedRootQuery { expr, mut desc, finishing, scope: _, - } = query::plan_root_query(scx, stmt.query, QueryLifetime::MaterializedView)?; + } = query::plan_root_query(scx, query, QueryLifetime::MaterializedView)?; // We get back a trivial finishing, see comment in `plan_view`. assert!(HirRelationExpr::is_trivial_row_set_finishing_hir( &finishing, @@ -2750,11 +2856,7 @@ pub fn plan_create_materialized_view( )); } - plan_utils::maybe_rename_columns( - format!("materialized view {}", scx.catalog.resolve_full_name(&name)), - &mut desc, - &stmt.columns, - )?; + plan_utils::maybe_rename_columns(context, &mut desc, columns)?; let column_names: Vec = desc.iter_names().cloned().collect(); let MaterializedViewOptionExtracted { @@ -2763,7 +2865,7 @@ pub fn plan_create_materialized_view( retain_history, refresh, seen: _, - }: MaterializedViewOptionExtracted = stmt.with_options.try_into()?; + }: MaterializedViewOptionExtracted = with_options.try_into()?; if let Some(partition_by) = partition_by { scx.require_feature_flag(&ENABLE_COLLECTION_PARTITION_BY)?; @@ -2885,7 +2987,7 @@ pub fn plan_create_materialized_view( } }; - let as_of = stmt.as_of.map(Timestamp::from); + let as_of = as_of.map(Timestamp::from); let compaction_window = plan_retain_history_option(scx, retain_history)?; let mut non_null_assertions = assert_not_null .into_iter() @@ -2912,103 +3014,127 @@ pub fn plan_create_materialized_view( sql_bail!("column {} specified more than once", dup.quoted()); } - // Override the statement-level IfExistsBehavior with Skip if this is - // explicitly requested in the PlanContext (the default is `false`). - let if_exists = match scx.pcx().map(|pcx| pcx.ignore_if_exists_errors) { - Ok(true) => IfExistsBehavior::Skip, - _ => stmt.if_exists, - }; - - let mut replace = None; - let mut if_not_exists = false; - match if_exists { - IfExistsBehavior::Replace => { - let if_exists = true; - let cascade = false; - let replace_id = plan_drop_item( - scx, - ObjectType::MaterializedView, - if_exists, - partial_name.into(), - cascade, - )?; - - // Check if the new Materialized View depends on the item that we would be replacing. - if let Some(id) = replace_id { - let dependencies = expr.depends_on(); - let invalid_drop = scx - .get_item(&id) - .global_ids() - .any(|gid| dependencies.contains(&gid)); - if invalid_drop { - let item = scx.catalog.get_item(&id); - sql_bail!( - "cannot replace materialized view {0}: depended upon by new {0} definition", - scx.catalog.resolve_full_name(item.name()) - ); - } - replace = Some(id); - } - } - IfExistsBehavior::Skip => if_not_exists = true, - IfExistsBehavior::Error => (), - } - let drop_ids = replace - .map(|id| { - scx.catalog - .item_dependents(id) - .into_iter() - .map(|id| id.unwrap_item_id()) - .collect() - }) - .unwrap_or_default(); let dependencies = expr .depends_on() .into_iter() .map(|gid| scx.catalog.resolve_item_id(&gid)) .collect(); + Ok(MaterializedView { + create_sql, + expr, + dependencies, + column_names, + cluster_id, + non_null_assertions, + compaction_window, + refresh_schedule, + as_of, + }) +} + +generate_extracted_config!( + MaterializedViewOption, + (AssertNotNull, Ident, AllowMultiple), + (PartitionBy, Vec), + (RetainHistory, OptionalDuration), + (Refresh, RefreshOptionValue, AllowMultiple) +); + +pub fn plan_create_replacement_materialized_view( + scx: &StatementContext, + mut stmt: CreateReplacementMaterializedViewStatement, +) -> Result { + scx.require_feature_flag(&vars::ENABLE_REPLACEMENT_MATERIALIZED_VIEWS)?; + + let target_item = scx.get_item_by_resolved_name(&stmt.target_name)?; + + if target_item.id().is_system() { + sql_bail!( + "cannot replace {} {} because it is required by the database system", + target_item.item_type(), + scx.catalog.minimal_qualification(target_item.name()), + ); + } + if !matches!(target_item.item_type(), CatalogItemType::MaterializedView) { + sql_bail!( + "cannot replace {} {} because it is not a materialized view", + target_item.item_type(), + scx.catalog.minimal_qualification(target_item.name()), + ); + } + let replaces = target_item.id(); + + let cluster_id = + crate::plan::statement::resolve_cluster(scx.catalog, stmt.in_cluster.as_ref())?; + stmt.in_cluster = Some(ResolvedClusterName { + id: cluster_id, + print_name: None, + }); + + let partial_name = normalize::unresolved_item_name(stmt.name.clone())?; + let name = scx.allocate_qualified_name(partial_name.clone())?; + // Check for an object in the catalog with this same name let full_name = scx.catalog.resolve_full_name(&name); let partial_name = PartialItemName::from(full_name.clone()); // For PostgreSQL compatibility, we need to prevent creating materialized // views when there is an existing object *or* type of the same name. - if let (IfExistsBehavior::Error, Ok(item)) = - (if_exists, scx.catalog.resolve_item_or_type(&partial_name)) - { + if let Ok(item) = scx.catalog.resolve_item_or_type(&partial_name) { return Err(PlanError::ItemAlreadyExists { name: full_name.to_string(), item_type: item.item_type(), }); } - Ok(Plan::CreateMaterializedView(CreateMaterializedViewPlan { - name, - materialized_view: MaterializedView { - create_sql, - expr, - dependencies, - column_names, - cluster_id, - non_null_assertions, - compaction_window, - refresh_schedule, - as_of, + let materialized_view = plan_create_materialized_view_inner( + scx, + Statement::CreateReplacementMaterializedView(stmt.clone()), + &stmt.columns, + stmt.query, + stmt.as_of, + cluster_id, + stmt.with_options, + format!( + "replacement materialized view {}", + scx.catalog.minimal_qualification(target_item.name()) + ), + )?; + + Ok(Plan::CreateReplacementMaterializedView( + CreateReplacementMaterializedViewPlan { + name, + materialized_view, + replaces, + ambiguous_columns: *scx.ambiguous_columns.borrow(), }, - replace, - drop_ids, - if_not_exists, - ambiguous_columns: *scx.ambiguous_columns.borrow(), - })) + )) } -generate_extracted_config!( - MaterializedViewOption, - (AssertNotNull, Ident, AllowMultiple), - (PartitionBy, Vec), - (RetainHistory, OptionalDuration), - (Refresh, RefreshOptionValue, AllowMultiple) -); +pub fn plan_alter_materialized_view_apply_replacement( + scx: &StatementContext, + stmt: AlterMaterializedViewApplyReplacementStatement, +) -> Result { + let mv = scx.get_item_by_resolved_name(&stmt.materialized_view_name)?; + let replacement = scx.get_item_by_resolved_name(&stmt.replacement_name)?; + + if replacement.replaces_item() != Some(mv.id()) { + sql_bail!( + "{} {} does not replace {} {}", + replacement.item_type(), + scx.catalog.minimal_qualification(replacement.name()), + mv.item_type(), + scx.catalog.minimal_qualification(mv.name()), + ); + } + + Ok(Plan::AlterMaterializedViewApplyReplacement( + AlterMaterializedViewApplyReplacementPlan { + id: mv.id(), + replacement_id: replacement.id(), + }, + )) +} pub fn plan_create_continual_task( scx: &StatementContext, @@ -3071,7 +3197,8 @@ pub fn plan_create_continual_task( | CatalogItemType::Type | CatalogItemType::Func | CatalogItemType::Secret - | CatalogItemType::Connection => { + | CatalogItemType::Connection + | CatalogItemType::ReplacementMaterializedView => { sql_bail!( "CONTINUAL TASK cannot use {} as an input", input.item_type() @@ -5615,7 +5742,8 @@ fn dependency_prevents_drop(object_type: ObjectType, dep: &dyn CatalogItem) -> b | CatalogItemType::Type | CatalogItemType::Secret | CatalogItemType::Connection - | CatalogItemType::ContinualTask => true, + | CatalogItemType::ContinualTask + | CatalogItemType::ReplacementMaterializedView => true, CatalogItemType::Index => false, }, } @@ -5628,6 +5756,13 @@ pub fn describe_alter_index_options( Ok(StatementDesc::new(None)) } +pub fn describe_alter_materialized_view_apply_replacement( + _: &StatementContext, + _: AlterMaterializedViewApplyReplacementStatement, +) -> Result { + Ok(StatementDesc::new(None)) +} + pub fn describe_drop_owned( _: &StatementContext, _: DropOwnedStatement, @@ -6720,6 +6855,7 @@ fn alter_retain_history( history: Option>, ) -> Result { let name = match (object_type, name) { + // TODO(alter-mv): Consider allowing ALTER RETAIN HISTORY on replacement MVs. ( // View gets a special error below. ObjectType::View diff --git a/src/sql/src/plan/statement/show.rs b/src/sql/src/plan/statement/show.rs index 405d56fc1bd91..f069539eea30e 100644 --- a/src/sql/src/plan/statement/show.rs +++ b/src/sql/src/plan/statement/show.rs @@ -23,8 +23,8 @@ use mz_sql_parser::ast::display::{AstDisplay, FormatMode}; use mz_sql_parser::ast::{ CreateSubsourceOptionName, ExternalReferenceExport, ExternalReferences, ObjectType, ShowCreateClusterStatement, ShowCreateConnectionStatement, ShowCreateMaterializedViewStatement, - ShowCreateTypeStatement, ShowObjectType, SqlServerConfigOptionName, SystemObjectType, - UnresolvedItemName, WithOptionValue, + ShowCreateReplacementStatement, ShowCreateTypeStatement, ShowObjectType, + SqlServerConfigOptionName, SystemObjectType, UnresolvedItemName, WithOptionValue, }; use mz_sql_pretty::PrettyConfig; use query::QueryContext; @@ -97,6 +97,34 @@ pub fn plan_show_create_materialized_view( ) } +pub fn describe_show_create_replacement( + _: &StatementContext, + _: ShowCreateReplacementStatement, +) -> Result { + Ok(StatementDesc::new(Some( + RelationDesc::builder() + .with_column("name", SqlScalarType::String.nullable(false)) + .with_column("create_sql", SqlScalarType::String.nullable(false)) + .finish(), + ))) +} + +pub fn plan_show_create_replacement( + scx: &StatementContext, + ShowCreateReplacementStatement { + replacement_name, + redacted, + }: ShowCreateReplacementStatement, +) -> Result { + // TODO(alter-mv): distinguish between replacement types + plan_show_create_item( + scx, + &replacement_name, + CatalogItemType::ReplacementMaterializedView, + redacted, + ) +} + pub fn describe_show_create_table( _: &StatementContext, _: ShowCreateTableStatement, @@ -429,6 +457,9 @@ pub fn show_objects<'a>( assert_none!(from, "parser should reject from"); show_network_policies(scx, filter) } + ShowObjectType::Replacement { in_cluster } => { + show_replacements(scx, from, in_cluster, filter) + } } } @@ -590,6 +621,35 @@ fn show_materialized_views<'a>( ) } +fn show_replacements<'a>( + scx: &'a StatementContext<'a>, + from: Option, + in_cluster: Option, + filter: Option>, +) -> Result, PlanError> { + let schema_spec = scx.resolve_optional_schema(&from)?; + let mut where_clause = format!("schema_id = '{schema_spec}'"); + + if let Some(cluster) = in_cluster { + write!(where_clause, " AND cluster_id = '{}'", cluster.id) + .expect("write on string cannot fail"); + } + + let query = format!( + "SELECT name, cluster, comment + FROM mz_internal.mz_show_replacements + WHERE {where_clause}" + ); + + ShowSelect::new( + scx, + query, + filter, + None, + Some(&["name", "cluster", "comment"]), + ) +} + fn show_sinks<'a>( scx: &'a StatementContext<'a>, from: Option, @@ -719,7 +779,9 @@ pub fn show_columns<'a>( | CatalogItemType::Table | CatalogItemType::View | CatalogItemType::MaterializedView - | CatalogItemType::ContinualTask => (), + | CatalogItemType::ContinualTask + // TODO(alter-mv): Decide if we support SHOW COLUMNS on replacement MVs. + | CatalogItemType::ReplacementMaterializedView => (), ty @ CatalogItemType::Connection | ty @ CatalogItemType::Index | ty @ CatalogItemType::Func diff --git a/src/sql/src/rbac.rs b/src/sql/src/rbac.rs index 07f8f2b85a9e9..60f46f5f5f1d4 100644 --- a/src/sql/src/rbac.rs +++ b/src/sql/src/rbac.rs @@ -668,6 +668,28 @@ fn generate_rbac_requirements( item_usage: &CREATE_ITEM_USAGE, ..Default::default() }, + Plan::CreateReplacementMaterializedView(plan::CreateReplacementMaterializedViewPlan { + name, + materialized_view, + replaces, + .. + }) => RbacRequirements { + ownership: vec![ObjectId::Item(*replaces)], + privileges: vec![ + ( + SystemObjectId::Object(name.qualifiers.clone().into()), + AclMode::CREATE, + role_id, + ), + ( + SystemObjectId::Object(materialized_view.cluster_id.into()), + AclMode::CREATE, + role_id, + ), + ], + item_usage: &CREATE_ITEM_USAGE, + ..Default::default() + }, Plan::Comment(plan::CommentPlan { object_id, sub_component: _, @@ -1054,6 +1076,13 @@ fn generate_rbac_requirements( ownership: vec![ObjectId::Item(*id)], ..Default::default() }, + Plan::AlterMaterializedViewApplyReplacement( + plan::AlterMaterializedViewApplyReplacementPlan { id, replacement_id }, + ) => RbacRequirements { + ownership: vec![ObjectId::Item(*id), ObjectId::Item(*replacement_id)], + item_usage: &CREATE_ITEM_USAGE, + ..Default::default() + }, Plan::AlterSource(plan::AlterSourcePlan { item_id, ingestion_id: _, @@ -1671,6 +1700,8 @@ fn generate_read_privileges_inner( privileges.push((SystemObjectId::Object(id.into()), AclMode::USAGE, role_id)); } CatalogItemType::Sink | CatalogItemType::Index | CatalogItemType::Func => {} + // TODO(alter-mv): Revisit if we want to read from replacement MVs. + CatalogItemType::ReplacementMaterializedView => {} } } } @@ -1792,6 +1823,8 @@ pub const fn all_object_privileges(object_type: SystemObjectType) -> AclMode { SystemObjectType::Object(ObjectType::Schema) => USAGE_CREATE_ACL_MODE, SystemObjectType::Object(ObjectType::Func) => EMPTY_ACL_MODE, SystemObjectType::Object(ObjectType::ContinualTask) => AclMode::SELECT, + // TODO(alter-mv): Check if this is correct for replacement MVs. + SystemObjectType::Object(ObjectType::ReplacementMaterializedView) => EMPTY_ACL_MODE, SystemObjectType::System => ALL_SYSTEM_PRIVILEGES, } } @@ -1821,7 +1854,8 @@ const fn default_builtin_object_acl_mode(object_type: ObjectType) -> AclMode { | ObjectType::Connection | ObjectType::Database | ObjectType::Func - | ObjectType::NetworkPolicy => AclMode::empty(), + | ObjectType::NetworkPolicy + | ObjectType::ReplacementMaterializedView => AclMode::empty(), } } diff --git a/src/sql/src/session/vars/definitions.rs b/src/sql/src/session/vars/definitions.rs index e061b7d0a7e10..026a13f430cc0 100644 --- a/src/sql/src/session/vars/definitions.rs +++ b/src/sql/src/session/vars/definitions.rs @@ -2224,6 +2224,12 @@ feature_flags!( default: false, enable_for_item_parsing: false, }, + { + name: enable_replacement_materialized_views, + desc: "Whether to enable replacement materialized views.", + default: false, + enable_for_item_parsing: true, + }, ); impl From<&super::SystemVars> for OptimizerFeatures { diff --git a/test/race-condition/mzcompose.py b/test/race-condition/mzcompose.py index 994e053a8bf92..872f5a30351ed 100644 --- a/test/race-condition/mzcompose.py +++ b/test/race-condition/mzcompose.py @@ -665,6 +665,35 @@ def verify(self) -> str: raise NotImplementedError +class ReplacementMaterializedView(Object): + def create(self) -> str: + select = ( + "* FROM " + self.references.name + if self.references + else "'foo' AS a, 'bar' AS b" + ) + return f"> CREATE MATERIALIZED VIEW {self.name} AS SELECT {select}" + + def destroy(self) -> str: + return f"> DROP MATERIALIZED VIEW {self.name} CASCADE" + + def manipulate(self, kind: int) -> str: + manipulations = [ + lambda: "", + lambda: dedent( + f""" + > DROP REPLACEMENT IF EXISTS {self.name}_replacement + > CREATE REPLACEMENT {self.name}_replacement FOR MATERIALIZED VIEW {self.name} AS SELECT {"* FROM " + self.references.name if self.references else "'foo' AS a, 'bar' AS b"} + > ALTER MATERIALIZED VIEW {self.name} APPLY REPLACEMENT {self.name}_replacement + """ + ), + ] + return manipulations[kind % len(manipulations)]() + + def verify(self) -> str: + raise NotImplementedError + + class DefaultIndex(Object): can_refer: bool = False diff --git a/test/sqllogictest/autogenerated/mz_internal.slt b/test/sqllogictest/autogenerated/mz_internal.slt index 3ef4129c0b173..6ac41d8d7bca6 100644 --- a/test/sqllogictest/autogenerated/mz_internal.slt +++ b/test/sqllogictest/autogenerated/mz_internal.slt @@ -751,6 +751,7 @@ mz_recent_activity_log_redacted mz_recent_activity_log_thinned mz_recent_sql_text mz_recent_sql_text_redacted +mz_replacement_materialized_views mz_session_history mz_sessions mz_show_all_my_privileges @@ -776,6 +777,7 @@ mz_show_my_schema_privileges mz_show_my_system_privileges mz_show_network_policies mz_show_object_privileges +mz_show_replacements mz_show_role_members mz_show_roles mz_show_schema_privileges diff --git a/test/sqllogictest/cluster.slt b/test/sqllogictest/cluster.slt index f8dae2e241fcc..415adf2ff00da 100644 --- a/test/sqllogictest/cluster.slt +++ b/test/sqllogictest/cluster.slt @@ -417,7 +417,7 @@ CREATE CLUSTER test REPLICAS (foo (SIZE 'scale=1,workers=1')); query I SELECT COUNT(name) FROM mz_indexes; ---- -295 +296 statement ok DROP CLUSTER test CASCADE @@ -425,7 +425,7 @@ DROP CLUSTER test CASCADE query T SELECT COUNT(name) FROM mz_indexes; ---- -263 +264 simple conn=mz_system,user=mz_system ALTER CLUSTER quickstart OWNER TO materialize diff --git a/test/sqllogictest/distinct_arrangements.slt b/test/sqllogictest/distinct_arrangements.slt index 179460d770d0d..4c601ce580980 100644 --- a/test/sqllogictest/distinct_arrangements.slt +++ b/test/sqllogictest/distinct_arrangements.slt @@ -1007,7 +1007,7 @@ ArrangeBy[[Column(0,␠"id"),␠Column(1,␠"replica_id")]] 3 ArrangeBy[[Column(0,␠"id"),␠Column(1,␠"replica_id")]]-errors 3 ArrangeBy[[Column(0,␠"id"),␠Column(2,␠"id")]] 1 ArrangeBy[[Column(0,␠"id"),␠Column(2,␠"position")]] 1 -ArrangeBy[[Column(0,␠"id")]] 86 +ArrangeBy[[Column(0,␠"id")]] 89 ArrangeBy[[Column(0,␠"id")]]-errors 17 ArrangeBy[[Column(0,␠"index_id")]] 1 ArrangeBy[[Column(0,␠"name")]] 3 @@ -1091,9 +1091,9 @@ ArrangeBy[[Column(3,␠"on_id")]] 2 ArrangeBy[[Column(3,␠"schema_id")]] 1 ArrangeBy[[Column(3,␠"schema_id")]]-errors 1 ArrangeBy[[Column(4)]] 1 -ArrangeBy[[Column(4,␠"cluster_id")]] 1 -ArrangeBy[[Column(4,␠"schema_id")]] 2 -ArrangeBy[[Column(4,␠"schema_id")]]-errors 2 +ArrangeBy[[Column(4,␠"cluster_id")]] 2 +ArrangeBy[[Column(4,␠"schema_id")]] 3 +ArrangeBy[[Column(4,␠"schema_id")]]-errors 3 ArrangeBy[[Column(5,␠"owner_id")]] 2 ArrangeBy[[Column(5,␠"type_oid")]] 1 ArrangeBy[[Column(6,␠"dropped_at")]] 1 @@ -1103,13 +1103,13 @@ ArrangeBy[[Column(6,␠"schema_id")]]-errors 1 ArrangeBy[[Column(7,␠"database_id")]] 1 ArrangeBy[[Column(9,␠"database_id")]] 1 ArrangeBy[[]] 11 -Arranged␠DistinctBy 49 +Arranged␠DistinctBy 50 Arranged␠MinsMaxesHierarchical␠input 14 Arranged␠ReduceInaccumulable 3 Arranged␠TopK␠input 111 Distinct␠recursive␠err 3 -DistinctBy 49 -DistinctByErrorCheck 49 +DistinctBy 50 +DistinctByErrorCheck 50 ReduceAccumulable 11 ReduceInaccumulable 3 ReduceInaccumulable␠Error␠Check 3 diff --git a/test/sqllogictest/information_schema_tables.slt b/test/sqllogictest/information_schema_tables.slt index 944ebfc2cf47d..909fdff482f3c 100644 --- a/test/sqllogictest/information_schema_tables.slt +++ b/test/sqllogictest/information_schema_tables.slt @@ -505,6 +505,10 @@ mz_recent_sql_text_redacted VIEW materialize mz_internal +mz_replacement_materialized_views +BASE TABLE +materialize +mz_internal mz_session_history SOURCE materialize @@ -605,6 +609,10 @@ mz_show_object_privileges VIEW materialize mz_internal +mz_show_replacements +VIEW +materialize +mz_internal mz_show_role_members VIEW materialize diff --git a/test/sqllogictest/mz_catalog_server_index_accounting.slt b/test/sqllogictest/mz_catalog_server_index_accounting.slt index 2fbc7a067aadf..bb17566d8d84b 100644 --- a/test/sqllogictest/mz_catalog_server_index_accounting.slt +++ b/test/sqllogictest/mz_catalog_server_index_accounting.slt @@ -37,40 +37,40 @@ mz_arrangement_heap_capacity_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangemen mz_arrangement_heap_size_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_heap_size_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_heap_size_raw"␠("operator_id",␠"worker_id") mz_arrangement_records_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_records_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_records_raw"␠("operator_id",␠"worker_id") mz_arrangement_sharing_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_sharing_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_sharing_raw"␠("operator_id",␠"worker_id") -mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s732␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") -mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s727␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") -mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") -mz_cluster_replica_metrics_history_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s501␠AS␠"mz_internal"."mz_cluster_replica_metrics_history"]␠("replica_id") -mz_cluster_replica_metrics_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s502␠AS␠"mz_internal"."mz_cluster_replica_metrics"]␠("replica_id") -mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s593␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") -mz_cluster_replica_sizes_ind CREATE␠INDEX␠"mz_cluster_replica_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s503␠AS␠"mz_catalog"."mz_cluster_replica_sizes"]␠("size") -mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s504␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") -mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s505␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") -mz_cluster_replicas_ind CREATE␠INDEX␠"mz_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s500␠AS␠"mz_catalog"."mz_cluster_replicas"]␠("id") -mz_clusters_ind CREATE␠INDEX␠"mz_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s494␠AS␠"mz_catalog"."mz_clusters"]␠("id") +mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s734␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") +mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s729␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") +mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s594␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") +mz_cluster_replica_metrics_history_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s502␠AS␠"mz_internal"."mz_cluster_replica_metrics_history"]␠("replica_id") +mz_cluster_replica_metrics_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s503␠AS␠"mz_internal"."mz_cluster_replica_metrics"]␠("replica_id") +mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s595␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") +mz_cluster_replica_sizes_ind CREATE␠INDEX␠"mz_cluster_replica_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s504␠AS␠"mz_catalog"."mz_cluster_replica_sizes"]␠("size") +mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s505␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") +mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s506␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") +mz_cluster_replicas_ind CREATE␠INDEX␠"mz_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s501␠AS␠"mz_catalog"."mz_cluster_replicas"]␠("id") +mz_clusters_ind CREATE␠INDEX␠"mz_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s495␠AS␠"mz_catalog"."mz_clusters"]␠("id") mz_columns_ind CREATE␠INDEX␠"mz_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s465␠AS␠"mz_catalog"."mz_columns"]␠("name") -mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s517␠AS␠"mz_internal"."mz_comments"]␠("id") +mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s518␠AS␠"mz_internal"."mz_comments"]␠("id") mz_compute_dataflow_global_ids_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_dataflow_global_ids_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_dataflow_global_ids_per_worker"␠("id",␠"worker_id") -mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s716␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") +mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s718␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") mz_compute_error_counts_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_error_counts_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_error_counts_raw"␠("export_id",␠"worker_id") mz_compute_exports_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_exports_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_exports_per_worker"␠("export_id",␠"worker_id") mz_compute_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_frontiers_per_worker"␠("export_id",␠"worker_id") -mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s723␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") +mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s725␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") mz_compute_hydration_times_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_hydration_times_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_hydration_times_per_worker"␠("export_id",␠"worker_id") mz_compute_import_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_import_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_import_frontiers_per_worker"␠("export_id",␠"import_id",␠"worker_id") mz_compute_lir_mapping_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_lir_mapping_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_lir_mapping_per_worker"␠("global_id",␠"lir_id",␠"worker_id") mz_compute_operator_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_durations_histogram_raw"␠("id",␠"worker_id",␠"duration_ns") mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_hydration_statuses_per_worker"␠("export_id",␠"lir_id") -mz_connections_ind CREATE␠INDEX␠"mz_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s498␠AS␠"mz_catalog"."mz_connections"]␠("schema_id") -mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s719␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") -mz_continual_tasks_ind CREATE␠INDEX␠"mz_continual_tasks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s520␠AS␠"mz_internal"."mz_continual_tasks"]␠("id") +mz_connections_ind CREATE␠INDEX␠"mz_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s499␠AS␠"mz_catalog"."mz_connections"]␠("schema_id") +mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s721␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") +mz_continual_tasks_ind CREATE␠INDEX␠"mz_continual_tasks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s521␠AS␠"mz_internal"."mz_continual_tasks"]␠("id") mz_databases_ind CREATE␠INDEX␠"mz_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s463␠AS␠"mz_catalog"."mz_databases"]␠("name") mz_dataflow_addresses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_addresses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_addresses_per_worker"␠("id",␠"worker_id") mz_dataflow_channels_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_channels_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_channels_per_worker"␠("id",␠"worker_id") mz_dataflow_operator_reachability_raw_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operator_reachability_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operator_reachability_raw"␠("id",␠"worker_id",␠"source",␠"port",␠"update_type",␠"time") mz_dataflow_operators_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operators_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operators_per_worker"␠("id",␠"worker_id") mz_dataflow_shutdown_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_shutdown_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_shutdown_durations_histogram_raw"␠("worker_id",␠"duration_ns") -mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s707␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") +mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s709␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") mz_indexes_ind CREATE␠INDEX␠"mz_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s466␠AS␠"mz_catalog"."mz_indexes"]␠("id") mz_kafka_sources_ind CREATE␠INDEX␠"mz_kafka_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s460␠AS␠"mz_catalog"."mz_kafka_sources"]␠("id") mz_materialized_views_ind CREATE␠INDEX␠"mz_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s478␠AS␠"mz_catalog"."mz_materialized_views"]␠("id") @@ -78,57 +78,58 @@ mz_message_batch_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_messag mz_message_batch_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_batch_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_batch_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_received_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_received_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") -mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s796␠AS␠"mz_internal"."mz_notices"]␠("id") +mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s799␠AS␠"mz_internal"."mz_notices"]␠("id") mz_object_dependencies_ind CREATE␠INDEX␠"mz_object_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s461␠AS␠"mz_internal"."mz_object_dependencies"]␠("object_id") -mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s529␠AS␠"mz_internal"."mz_object_history"]␠("id") -mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s530␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") -mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s545␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") -mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s526␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") +mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s530␠AS␠"mz_internal"."mz_object_history"]␠("id") +mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s531␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") +mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s546␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") +mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s527␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") mz_peek_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_peek_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_peek_durations_histogram_raw"␠("worker_id",␠"type",␠"duration_ns") -mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s691␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") -mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s687␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") -mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s791␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") -mz_roles_ind CREATE␠INDEX␠"mz_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s486␠AS␠"mz_catalog"."mz_roles"]␠("id") +mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s693␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") +mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s689␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") +mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s794␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") +mz_roles_ind CREATE␠INDEX␠"mz_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s487␠AS␠"mz_catalog"."mz_roles"]␠("id") mz_scheduling_elapsed_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_elapsed_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_elapsed_raw"␠("id",␠"worker_id") mz_scheduling_parks_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_parks_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_parks_histogram_raw"␠("worker_id",␠"slept_for_ns",␠"requested_ns") mz_schemas_ind CREATE␠INDEX␠"mz_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s464␠AS␠"mz_catalog"."mz_schemas"]␠("database_id") -mz_secrets_ind CREATE␠INDEX␠"mz_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s497␠AS␠"mz_catalog"."mz_secrets"]␠("name") -mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s576␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") -mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s730␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") -mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s578␠AS␠"mz_internal"."mz_show_clusters"]␠("name") -mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s577␠AS␠"mz_internal"."mz_show_columns"]␠("id") -mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s586␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") -mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s580␠AS␠"mz_internal"."mz_show_databases"]␠("name") -mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") -mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") -mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s585␠AS␠"mz_internal"."mz_show_roles"]␠("name") -mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s581␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") -mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s579␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") -mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") -mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") -mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s582␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") -mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s584␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") -mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s583␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") -mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s704␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") -mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s676␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") -mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s677␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") +mz_secrets_ind CREATE␠INDEX␠"mz_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s498␠AS␠"mz_catalog"."mz_secrets"]␠("name") +mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s577␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") +mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s732␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") +mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s579␠AS␠"mz_internal"."mz_show_clusters"]␠("name") +mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s578␠AS␠"mz_internal"."mz_show_columns"]␠("id") +mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") +mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s581␠AS␠"mz_internal"."mz_show_databases"]␠("name") +mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") +mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") +mz_show_replacements_ind CREATE␠INDEX␠"mz_show_replacements_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s591␠AS␠"mz_internal"."mz_show_replacements"]␠("schema_id") +mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s586␠AS␠"mz_internal"."mz_show_roles"]␠("name") +mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s582␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") +mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s580␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") +mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") +mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") +mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s583␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") +mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s585␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") +mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s584␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") +mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s706␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") +mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s678␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") +mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s679␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") mz_sinks_ind CREATE␠INDEX␠"mz_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s476␠AS␠"mz_catalog"."mz_sinks"]␠("id") -mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s702␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") -mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s700␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") -mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s678␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") -mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s695␠AS␠"mz_internal"."mz_source_statuses"]␠("id") +mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s704␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") +mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s702␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") +mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s680␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") +mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s697␠AS␠"mz_internal"."mz_source_statuses"]␠("id") mz_sources_ind CREATE␠INDEX␠"mz_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s469␠AS␠"mz_catalog"."mz_sources"]␠("id") mz_tables_ind CREATE␠INDEX␠"mz_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s468␠AS␠"mz_catalog"."mz_tables"]␠("schema_id") -mz_types_ind CREATE␠INDEX␠"mz_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s480␠AS␠"mz_catalog"."mz_types"]␠("schema_id") +mz_types_ind CREATE␠INDEX␠"mz_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s481␠AS␠"mz_catalog"."mz_types"]␠("schema_id") mz_views_ind CREATE␠INDEX␠"mz_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s477␠AS␠"mz_catalog"."mz_views"]␠("schema_id") -mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s711␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") -mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s518␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") -pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s618␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") -pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s611␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") -pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s599␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") -pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s608␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") -pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s596␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") -pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s605␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") +mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s713␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") +mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s519␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") +pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s620␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") +pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s613␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") +pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s601␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") +pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s610␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") +pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s598␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") +pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s607␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") # Record all transitive dependencies (tables, sources, views, mvs) of indexes on # the mz_catalog_server cluster. @@ -556,6 +557,17 @@ mz_relations owner_id mz_relations privileges mz_relations schema_id mz_relations type +mz_replacement_materialized_views cluster_id +mz_replacement_materialized_views create_sql +mz_replacement_materialized_views definition +mz_replacement_materialized_views id +mz_replacement_materialized_views name +mz_replacement_materialized_views oid +mz_replacement_materialized_views owner_id +mz_replacement_materialized_views privileges +mz_replacement_materialized_views redacted_create_sql +mz_replacement_materialized_views replaces +mz_replacement_materialized_views schema_id mz_roles id mz_roles inherit mz_roles name @@ -623,6 +635,13 @@ mz_show_materialized_views comment mz_show_materialized_views id mz_show_materialized_views name mz_show_materialized_views schema_id +mz_show_replacements cluster +mz_show_replacements cluster_id +mz_show_replacements comment +mz_show_replacements id +mz_show_replacements name +mz_show_replacements replaces +mz_show_replacements schema_id mz_show_roles comment mz_show_roles name mz_show_schemas comment diff --git a/test/sqllogictest/mzcompose.py b/test/sqllogictest/mzcompose.py index 7722aea2b3b9f..05f7679fd2b93 100644 --- a/test/sqllogictest/mzcompose.py +++ b/test/sqllogictest/mzcompose.py @@ -376,6 +376,7 @@ def compileFastSltConfig() -> SltRunConfig: "test/sqllogictest/managed_cluster.slt", "test/sqllogictest/map.slt", "test/sqllogictest/materialized_views.slt", + "test/sqllogictest/replacement_materialized_views.slt", "test/sqllogictest/mz_catalog_server_index_accounting.slt", "test/sqllogictest/mztimestamp.slt", "test/sqllogictest/name_resolution.slt", diff --git a/test/sqllogictest/oid.slt b/test/sqllogictest/oid.slt index 4b390792a97d2..7443b14596ecf 100644 --- a/test/sqllogictest/oid.slt +++ b/test/sqllogictest/oid.slt @@ -856,6 +856,7 @@ SELECT oid, name FROM mz_objects WHERE id LIKE 's%' AND oid < 20000 ORDER BY oid 16729 mz_internal_cluster_replicas 16730 mz_cluster_replica_statuses 16731 mz_cluster_replica_sizes +16732 mz_replacement_materialized_views 16733 mz_audit_events 16734 mz_source_status_history 16735 mz_aws_privatelink_connection_status_history @@ -1171,3 +1172,5 @@ SELECT oid, name FROM mz_objects WHERE id LIKE 's%' AND oid < 20000 ORDER BY oid 17059 mz_role_auth 17060 mz_iceberg_sinks 17061 mz_object_global_ids +17062 mz_show_replacements +17063 mz_show_replacements_ind diff --git a/test/sqllogictest/replacement_materialized_views.slt b/test/sqllogictest/replacement_materialized_views.slt new file mode 100644 index 0000000000000..c1dbb7d136b5b --- /dev/null +++ b/test/sqllogictest/replacement_materialized_views.slt @@ -0,0 +1,116 @@ +# Copyright Materialize, Inc. and contributors. All rights reserved. +# +# Use of this software is governed by the Business Source License +# included in the LICENSE file at the root of this repository. +# +# As of the Change Date specified in that file, in accordance with +# the Business Source License, use of this software will be governed +# by the Apache License, Version 2.0. + +mode cockroach + +# Setup + +statement ok +CREATE TABLE t (a int, b int) + +statement ok +INSERT INTO t VALUES (1, 2), (3, 4), (5, 6) + +statement ok +CREATE CLUSTER other REPLICAS (r1 (SIZE 'scale=1,workers=1'), r2 (SIZE 'scale=2,workers=2')) + + +# Test: Materialized view can be created. + +statement ok +CREATE MATERIALIZED VIEW mv AS SELECT a, b FROM t; + + +query II +SELECT * FROM mv +---- +1 2 +3 4 +5 6 + + +statement ok +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT a + b as a, b FROM t; + +query II +SELECT * FROM mv +---- +1 2 +3 4 +5 6 + +query TTT colnames,rowsort +SHOW REPLACEMENTS +---- +name cluster comment +rp1 quickstart (empty) + +statement ok +ALTER MATERIALIZED VIEW mv APPLY REPLACEMENT rp1; + +query TTT colnames,rowsort +SHOW REPLACEMENTS +---- +name cluster comment + + + +query II +SELECT * FROM mv +---- +3 2 +7 4 +11 6 + +statement ok +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT a, b FROM t; + +statement error db error: ERROR: replacement materialized view "materialize\.public\.rp1" already exists +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT a, b FROM t; + +statement ok +DROP REPLACEMENT rp1; + +statement error db error: ERROR: Schemas are incompatible +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv AS SELECT a, b, 1 FROM t; + + + +# Test: Explicit column names must have the right cardinality. + +statement error db error: ERROR: Schemas are incompatible +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv (a, b) AS SELECT a, b, 1 FROM t; + +# Test: Materialized view can be created in another cluster. + +statement ok +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv IN CLUSTER other AS SELECT a, b FROM t; + +query TTT colnames,rowsort +SHOW REPLACEMENTS +---- +name cluster comment +rp1 other (empty) + +statement ok +DROP REPLACEMENT rp1; + +# Test: Materialized view can not be created in a non-existing cluster. + +statement error unknown cluster 'doesnotexist' +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv IN CLUSTER doesnotexist AS SELECT a, b FROM t; + +statement ok +CREATE REPLACEMENT rp1 FOR MATERIALIZED VIEW mv IN CLUSTER other AS SELECT a, b FROM t; + +statement error db error: ERROR: cannot drop materialized view "mv": still depended upon by replacement materialized view "rp1" +DROP MATERIALIZED VIEW mv; + +statement ok +DROP MATERIALIZED VIEW mv CASCADE; diff --git a/test/testdrive/catalog.td b/test/testdrive/catalog.td index db5476e31d2d3..2dad9bae7ad14 100644 --- a/test/testdrive/catalog.td +++ b/test/testdrive/catalog.td @@ -289,7 +289,7 @@ public.bool > DROP DATABASE foo ! DROP OBJECT v1 -contains:Expected one of TABLE or VIEW or MATERIALIZED or SOURCE or SINK or INDEX or TYPE or ROLE or USER or CLUSTER or SECRET or CONNECTION or DATABASE or SCHEMA or FUNCTION or CONTINUAL or NETWORK, found identifier +contains:Expected one of TABLE or VIEW or MATERIALIZED or SOURCE or SINK or INDEX or TYPE or ROLE or USER or CLUSTER or SECRET or CONNECTION or DATABASE or SCHEMA or FUNCTION or CONTINUAL or NETWORK or REPLACEMENT, found identifier > SHOW OBJECTS name type comment @@ -616,6 +616,7 @@ mz_object_global_ids "" mz_optimizer_notices "" mz_postgres_sources "" mz_postgres_source_tables "" +mz_replacement_materialized_views "" mz_sessions "" mz_source_references "" mz_sql_server_source_tables "" @@ -678,6 +679,7 @@ mz_show_my_schema_privileges "" mz_show_my_system_privileges "" mz_show_network_policies "" mz_show_object_privileges "" +mz_show_replacements "" mz_show_role_members "" mz_show_roles "" mz_show_schema_privileges "" @@ -805,11 +807,11 @@ test_table "" # `SHOW TABLES` and `mz_tables` should agree. > SELECT COUNT(*) FROM mz_tables WHERE id LIKE 's%' -64 +65 # There is one entry in mz_indexes for each field_number/expression of the index. > SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%' -263 +264 # Create a second schema with the same table name as above > CREATE SCHEMA tester2 diff --git a/test/testdrive/indexes.td b/test/testdrive/indexes.td index 3d4dbc0ab3550..eff8d00fa6093 100644 --- a/test/testdrive/indexes.td +++ b/test/testdrive/indexes.td @@ -358,6 +358,7 @@ mz_show_connections_ind mz_show_connections mz_show_databases_ind mz_show_databases mz_catalog_server {name} "" mz_show_indexes_ind mz_show_indexes mz_catalog_server {schema_id} "" mz_show_materialized_views_ind mz_show_materialized_views mz_catalog_server {schema_id} "" +mz_show_replacements_ind mz_show_replacements mz_catalog_server {schema_id} "" mz_show_roles_ind mz_show_roles mz_catalog_server {name} "" mz_show_schemas_ind mz_show_schemas mz_catalog_server {database_id} "" mz_show_secrets_ind mz_show_secrets mz_catalog_server {schema_id} ""