From 8eb1bf314d4584c13710b77d9fd68bd809c5c177 Mon Sep 17 00:00:00 2001 From: Tim Meehan Date: Wed, 13 Aug 2025 23:12:44 -0400 Subject: [PATCH] Add materialized views RFC --- RFC-0017-materialized-views.md | 831 +++++++++++++ RFC-0017/current-vs-rfc-refresh.excalidraw | 869 +++++++++++++ RFC-0017/current-vs-rfc-refresh.png | Bin 0 -> 110970 bytes RFC-0017/current-vs-rfc-stitching.excalidraw | 1143 ++++++++++++++++++ RFC-0017/current-vs-rfc-stitching.png | Bin 0 -> 113793 bytes RFC-0017/mv-architecture-flow.excalidraw | 969 +++++++++++++++ 6 files changed, 3812 insertions(+) create mode 100644 RFC-0017-materialized-views.md create mode 100644 RFC-0017/current-vs-rfc-refresh.excalidraw create mode 100644 RFC-0017/current-vs-rfc-refresh.png create mode 100644 RFC-0017/current-vs-rfc-stitching.excalidraw create mode 100644 RFC-0017/current-vs-rfc-stitching.png create mode 100644 RFC-0017/mv-architecture-flow.excalidraw diff --git a/RFC-0017-materialized-views.md b/RFC-0017-materialized-views.md new file mode 100644 index 00000000..08be3ab6 --- /dev/null +++ b/RFC-0017-materialized-views.md @@ -0,0 +1,831 @@ +# **RFC-0017 for Presto: Materialized Views** + +## Materialized Views Architecture + +Proposers + +* Tim Meehan + +## Related Issues + +Related issues may include Github issues, PRs or other RFCs. + +* Existing Hive Materialized Views implementation in presto-hive module +* Proposed Iceberg Materialized Views support + +## Summary + +This RFC proposes a redesign of Presto's Materialized Views architecture. The current implementation has analysis-phase limitations that prevent proper MV-side filtering in UNION operations and requires expensive staleness computation during TableHandle creation. The proposed design moves stitching logic to the planning phase and allows connectors to compute staleness lazily when needed. + +## Background + +The current implementation was designed for Hive and has limitations that prevent other connectors from implementing materialized views effectively. + +### Goals + +* Connector-agnostic materialized views framework +* Move MV logic from analysis phase to planning phase +* Limit connector responsibilities to staleness detection only +* Planner handles all stitching logic using standard plan nodes +* Support incremental refresh patterns +* Iceberg connector implementation using snapshot-based change tracking + +### Non-goals + +* Major changes to existing user-facing APIs (the design reuses existing SPI methods) +* Automatic view selection/routing for arbitrary queries + +## Current Implementation and How It Works + +The existing materialized views implementation is located primarily in the presto-hive module and follows this flow: + +### 1. Metadata Storage +- MVs are stored as Hive tables with special properties +- View definition stored in table properties as serialized SQL +- Base table references tracked in metadata + +### 2. Query Analysis Phase + +#### Query-Time Analysis (SELECT from MV) +When querying a materialized view, the system: +- Recognizes the table as an MV during name resolution +- Calculates staleness by checking partition modification times +- Constructs a UNION query combining fresh MV data with stale data recomputed from base query + +#### Refresh-Time Analysis (REFRESH MATERIALIZED VIEW) +When refreshing a materialized view, the system: +- Parses the MV definition from metadata +- Constructs the refresh query by analyzing the stored view definition +- Determines partitioning alignment between MV and base tables +- Applies any user-specified WHERE predicates to limit refresh scope + +### 3. Refresh Execution (Hive-Specific) +- Full refresh: Drops and recreates the entire MV table +- Partial refresh: Attempts to update only modified partitions (detected via Hive partition modification timestamps) +- Uses Hive's partition replacement semantics + +### 4. Query Rewriting +- Simple pattern matching to detect if a query can use an MV +- Limited to exact matches or simple projections +- No cost-based selection between multiple MVs + +## Problems with Current Implementation + +### 1. Missing MV-Side Filtering in UNION + +The current UNION implementation can include duplicate data because staleness information cannot be embedded in TableHandles during analysis[^13]. The code assumes the materialized view TableHandle will filter stale partitions, but any open source implementation would require expensive metadata lookups on the dependent tables. TableHandles are intended to be lightweight, but staleness tracking requires expensive metadata operations that must be deferred until query planning. + +### 2. Manual WHERE Clauses in REFRESH MATERIALIZED VIEW + +The current `REFRESH MATERIALIZED VIEW WHERE ...` approach requires users to manually specify refresh predicates. This doesn't work with Iceberg's hidden partitions because users cannot reference partition transform functions like `bucket(16, customer_id)` or `year(order_date)` directly in WHERE clauses. Users are forced to understand internal partitioning schemes and translate them to source column predicates, making incremental refresh impractical for complex partitioning strategies. + +### 3. Analysis-Phase Early Binding + +Performing MV logic during analysis prevents cost-based decisions. Moving to the planner would enable cost-based decisions like when to refresh (based on rows rather than number of missing partitions), when to use base query vs. stitching, and future cost-based view selection. + +### 4. Inconsistent Access Control Model + +Views can use either definer rights (execute with creator's permissions) or invoker rights (execute with querying user's permissions). The current implementation mixes both models inconsistently. During creation, it checks if the creating user has access to base tables following an invoker rights pattern. During refresh, it checks if the MV owner has access (suggesting definer rights) but then executes with the invoker's identity (invoker rights), creating a confusing hybrid model. Users need SELECT permission on the MV itself for queries, which is standard. The problem is that the refresh operation validates against owner permissions but executes with invoker permissions. This creates security and operational issues where both the MV owner and the refresh invoker need base table permissions, making the permission check on the owner effectively meaningless since execution uses invoker's identity. There's no true definer rights support, preventing controlled access to aggregated data, and this differs from both regular Presto views (which properly support both modes) and industry standard (most analytical databases default to definer rights for MVs). + +## Existing Infrastructure + +Presto already has substantial materialized view infrastructure: + +Core SPI Methods (already implemented): +- `ConnectorMetadata.createMaterializedView()` - create MV metadata and storage +- `ConnectorMetadata.dropMaterializedView()` - remove MV and storage +- `ConnectorMetadata.getMaterializedView()` - retrieve MV definition +- `ConnectorMetadata.getMaterializedViewStatus()` - check freshness status +- `ConnectorMetadata.getReferencedMaterializedViews()` - discover MVs for tables + +Refresh Infrastructure: +- `TableWriterNode.RefreshMaterializedViewReference` - identifies refresh operations in the plan +- `ConnectorMetadata.beginRefreshMaterializedView()` - starts the refresh execution +- `ConnectorMetadata.finishRefreshMaterializedView()` - completes the refresh with connector-specific logic +- `LogicalPlanner.createRefreshMaterializedViewPlan()` - creates the execution plan + +Query-Time Infrastructure: +- `StatementAnalyzer` - handles MV stitching during analysis phase +- `PredicateStitcher` - combines fresh MV data with stale base table data +- `MaterializedViewColumnMappingExtractor` - maps columns between MV and base tables +- SQL parsing and validation for MV DDL statements + +Storage Classes: +- `MaterializedViewDefinition` - stores MV metadata and SQL definition +- `MaterializedViewStatus` - reports staleness information +- `MaterializedDataPredicates` - wraps staleness predicates + +## Proposed Changes + +### 1. SPI Interface for Materialized Views + +The approach reuses as much of the existing SPI as possible. Connectors detect staleness using the existing `getMaterializedViewStatus()` method, though the `MaterializedViewStatus` structure itself will be refactored to support the new functionality[^1]. + +Existing methods remain unchanged: +- `createMaterializedView()` / `dropMaterializedView()` - lifecycle operations +- `getMaterializedView()` - retrieve MV definition +- `getMaterializedViewStatus()` - the only method needed for stitching (with updated return structure) +- `beginRefreshMaterializedView()` / `finishRefreshMaterializedView()` - refresh execution + +New optional methods for native refresh delegation: +- `delegateMaterializedViewRefreshToConnector()` - returns true for native connectors (PostgreSQL, Snowflake) +- `refreshMaterializedView()` - performs native refresh when delegated + +The planner handles all stitching logic using staleness information from the refactored `MaterializedViewStatus`. + +### 2. MaterializedViewStatus Structure + +The MaterializedViewStatus reports base table staleness using pass-through columns, with the runtime deriving MV constraints using complement logic[^2]: + +MaterializedViewStatus fields: +- `fullyMaterialized`: boolean indicating if MV is completely fresh (other freshness states are inferred from the presence of predicates) +- `staleDataConstraints`: StaleDataConstraints containing base table constraints only +- `lastRefreshTimes`: Map for metadata tracking + +StaleDataConstraints structure (for examples of each predicate type being used, see Section 6 "Two Stitching Modes: Partition-Based and Filter-Based"): +- `dataDisjuncts`: Map>> - OR'd partition boundaries for base tables only (existing concept, used for bulk partition updates) +- `conjunctiveConstraints`: Map> - AND'd filtering within boundaries for base tables only (new concept, enables file-level or record-level precision)[^14] + +The connector reports staleness exclusively on base tables using pass-through columns, which are simplest to implement. The runtime derives fresh MV constraints as the complement of base stale constraints using the shared column semantics. Connectors signal their incremental scan capabilities through the granularity of conjunctive constraints. When base and MV data tables have aligned partitioning schemes, connectors provide specific predicates; when partitioning schemes differ, connectors return empty predicate lists to signal broader refresh boundaries are needed. This enables different strategies per base table in multi-table materialized views[^12]. + +### 3. Dynamic Connector-Driven Refresh Planning + +Transform refresh from static user-driven queries to dynamic connector-driven planning[^3]. Currently, users must manually specify WHERE predicates for incremental refresh, refresh queries are built during analysis without connector staleness input, and connectors have no way to signal what data is actually stale. + +![Refresh Flow Comparison](RFC-0017/current-vs-rfc-refresh.png) + +#### How Refresh Planning Works + +The refresh planning mechanism parallels the read-time stitching approach but generates write plans instead of read plans. During planning, the system has access to the MV definition query that defines what the MV should contain, staleness information from `getMaterializedViewStatus()` indicating which base table partitions have changed, and the MV storage table containing existing materialized data that needs updating. + +The planner in `LogicalPlanner.createRefreshMaterializedViewPlan()` gets staleness constraints from the connector, adds those constraints as filters to the base table scans in the MV definition query, and wraps the result in a TableWriterNode that writes to the MV storage table using either INSERT OVERWRITE for Phase 1 or MERGE for future Phase 2. The MV definition query itself remains unchanged except for the additional filters on base tables. + +For example, if a materialized view aggregates sales by region and date, and the connector indicates that only January 2024 US sales are stale, the refresh plan simply adds the filter `sale_date >= '2024-01-01' AND sale_date < '2024-02-01' AND customer_region = 'US'` to the sales table scan in the existing MV definition query. The rest of the query including its GROUP BY aggregation executes unchanged. + +This approach enables connectors to determine what needs refreshing based on actual data changes. Users no longer need to specify WHERE predicates for incremental refresh - the system automatically detects incrementality through connector staleness detection. The WHERE clause syntax in `REFRESH MATERIALIZED VIEW WHERE ...` will be deprecated in favor of automatic connector-driven staleness detection. + +### 4. MaterializedViewScan AST and Plan Nodes + +Instead of directly constructing UNION queries in the analyzer, introduce proper AST and plan nodes for materialized view scans that get optimized later[^4]: + +![Stitching Flow Comparison](RFC-0017/current-vs-rfc-stitching.png) + +New AST Node: MaterializedViewScan +- Left side of the AST node: Data table scan (storage table) +- Right side of the AST node: View query structure +- `MaterializedViewDefinition` + +Analysis Phase: Create MaterializedViewScan Node +- `StatementAnalyzer.visitTable()` checks if table is materialized view +- Creates `MaterializedViewScan` AST node with data table and view query +- Analyzes both sides normally using existing infrastructure + +Planning Phase: MaterializedViewScanNode +- Plan node containing data table plan and view query plan +- MV metadata and symbol mappings for optimization +- Standard `PlanNode` that integrates with existing infrastructure + +Optimization Phase: MaterializedViewOptimizer Rule (Default Implementation) +- Default optimizer rule converts `MaterializedViewScanNode` to UNION +- Gets staleness information from `MaterializedViewStatus` +- Fresh MV: returns data table scan directly +- Partially stale: builds UNION of filtered fresh data + recomputed stale data + +The planner constructs stitching plans by adding standard `UnionNode`, `TableScanNode`, and `FilterNode` nodes, then relies on existing planner rules for optimization. This design uses only the existing `MaterializedViewStatus` SPI method. Connectors only need to detect staleness and provide constraint information - they don't need to understand or implement stitching logic themselves. Filter nodes are pushed down by later planner rules through existing constraint pushdown mechanisms. + +Moving to the planner phase enables connector-specific optimizations when the default MaterializedViewOptimizer doesn't fully meet connector needs. Connectors can implement custom optimizer rules that work alongside or replace the default rule. + +### 5. Architecture and Responsibilities + +This approach provides separation of concerns: + +#### Architectural Principles + +1. Single staleness source: `MaterializedViewStatus` is the only source of staleness information +2. Direct constraint application: Stale constraints from status are applied directly to table handles +3. Standard plan construction: Base query is planned as any other query subtree, filters from connector are added to base table scans, UnionNode combines fresh MV data with filtered base query + +#### Separation of Responsibilities + +Presto runtime handles: +- SQL parsing and validation +- Query planning and general optimization (join reordering, predicate pushdown, etc.) +- ALL MV stitching logic using standard plan nodes +- Construction of union plans for combining fresh and stale data +- Converting MV predicates to base table constraints using column mappings + +Connector handles: +- MV metadata storage +- Staleness detection through partition-level tracking or snapshot-based change detection +- Signaling incremental scan capabilities through constraint granularity + +### 6. Pass-Through Column Constraint Handling + +The connector reports staleness on base tables using pass-through columns, and the runtime derives MV constraints using complement logic (similar to current implementation). This approach works for columns that appear unchanged in both base tables and materialized view data tables. + +#### Connector Responsibility: Base Table Staleness + +The connector detects and reports what data is stale on base tables. For example, a sales table might have stale partitions where `sale_date >= '2024-01-01'` and `customer_region = 'US'`. The connector populates the `StaleDataConstraints` structure with disjunctive constraints (OR'd partition boundaries) and conjunctive constraints (AND'd filtering within boundaries). If the connector can provide precise change tracking, it sets specific conjunctive predicates; otherwise it uses safe boundaries[^9]. + +#### Runtime Responsibility: MV Constraint Derivation + +The planner derives MV data table constraints using complement logic for pass-through columns (similar to current refresh implementation, but different from current query-time stitching which lacks proper MV-side filtering). The process involves: + +``` +1. Get staleness information from getMaterializedViewStatus() +2. Union all stale constraints from base tables +3. Derive fresh constraints using logic similar to MaterializedViewUtils.differenceDataPredicates +4. Build UNION plan: fresh MV data + recomputed stale base data +``` + +The constraint derivation handles constraint negation and boundary computation for pass-through columns[^10]. + +#### Pass-Through Column Requirements + +This approach works for columns that appear unchanged in both base tables and MV data tables: + +```sql +-- Example: pass-through columns work naturally +CREATE MATERIALIZED VIEW sales_summary AS +SELECT + customer_region, -- ✓ Pass-through: base.customer_region = mv.customer_region + sale_date, -- ✓ Pass-through: base.sale_date = mv.sale_date + SUM(amount) as total_sales -- Aggregated: constraints apply to grouping columns only +FROM sales +GROUP BY customer_region, sale_date +``` + +UNION Construction (similar to current implementation): +```sql +-- Fresh data: everything except stale groups +SELECT customer_region, sale_date, total_sales +FROM sales_summary +WHERE NOT (sale_date >= '2024-01-01' AND customer_region = 'US') + +UNION ALL + +-- Stale data: recompute affected groups +SELECT customer_region, sale_date, SUM(amount) +FROM sales +WHERE sale_date >= '2024-01-01' AND customer_region = 'US' +GROUP BY customer_region, sale_date +``` + +### 7. Consistent Access Control Model + +Align materialized views with regular views for access control[^5]: + +Access control mode determination: +- If MV has owner different from session user → definer mode (use owner's permissions) +- Otherwise → invoker mode (use session user's permissions) + +Implementation approach: +- Create appropriate identity and access control objects based on mode +- Build session with correct identity for refresh analysis +- Use `ViewAccessControl` wrapper for definer mode +- Analyze refresh query with appropriate permissions + +## How Iceberg Will Handle It + +### 1. Storage Model + +```java +public class IcebergMaterializedView { + // View component (stored in catalog) + private final String viewName; + private final String viewDefinition; + private final Schema schema; + + // Table component (Iceberg table) + private final Table storageTable; + + // Base table references and their snapshot IDs when MV was last fully refreshed + // Used for incremental change detection. This is stored as properties in + // the view. + private final Map baseTableSnapshots; +} +``` + +### 2. Partitioning Support + +Materialized views use the same `partitioning` property syntax as regular Iceberg tables, supporting partition transforms like `'year(ts)'`, `'bucket(N, col)'`, and `'truncate(N, str)'`. When MV and base table partitioning schemes differ, pass-through columns cannot participate in stitching and the system falls back to over-specification refresh boundaries. + +### 3. Staleness Detection through MaterializedViewStatus + +Iceberg implements staleness detection using snapshot-based change tracking[^6]: + +Non-partitioned tables: Simple snapshot ID comparison between base table and MV refresh snapshot +Partitioned tables: Use Iceberg's incremental scan to detect changed partitions between snapshots +Constraint conversion: Convert changed Iceberg partitions to `TupleDomain` constraints for planner use + +### 4. Iceberg Constraint Relationships and Column Mappings + +Iceberg's implementation of constraint relationships leverages snapshot-based change detection and hidden partitions to simplify the conversion between base table and MV data table constraints. + +#### Iceberg-Specific Constraint Processing + +Iceberg implements staleness detection using snapshot-based change tracking[^11]. The connector compares base table snapshots to detect changes since the last refresh, then identifies changed partitions when snapshots differ. Changed partition information is extracted from file scan tasks and converted to TupleDomain constraints that apply to base table columns using their raw names. The approach relies on Iceberg partition transform functions being available as `iceberg.system` functions, allowing constraints to use transform functions directly. + +#### Future: Advanced Constraint Mapping + +Complex constraint transformations between misaligned partitioning schemes remain a future enhancement. The initial implementation uses the over-specification approach described in the refresh implementation section, where connectors signal partition misalignment by returning empty predicate lists, triggering broader refresh boundaries along natural partition lines. + +### 5. Benefits of Iceberg's Snapshot-Based Approach + +Iceberg's snapshot-based approach provides accuracy based on actual data changes rather than metadata timestamps, works with both partitioned and non-partitioned tables, and can detect deletes and updates in addition to appends. + +#### Iceberg-Specific Refresh Implementation + +Phase 1: Partition Overwrite with Alignment Requirements +Iceberg initially implements refresh using INSERT OVERWRITE of whole partitions. When base and MV data tables have aligned partitioning schemes, the connector provides specific predicates in `StaleDataConstraints` enabling partition updates. When partitioning schemes differ, the connector omits predicates (returns empty predicate lists) to signal that broader refresh boundaries are needed. This approach uses over-specification at partition boundaries - if one bucket in a day changes, all buckets for that day are refreshed to maintain simplicity and correctness. + +Over-Specification Strategy: +To handle misaligned direct mapped columns that represent partitions but whose transforms differ, the system over-specifies refresh boundaries along natural partition lines. For example, if the base table is partitioned by `day(sale_date), bucket(16, customer_region)` and the MV is partitioned by `day(sale_date), bucket(30, customer_region)`, when bucket 5 changes in the base table for day '2024-01-15', the refresh recomputes all buckets for that entire day. This provides a simple, predictable refresh model at the cost of slightly higher recomputation for the initial phase. + +Phase 2: MERGE-Based Refresh for Aggregation Queries +Future implementation will use MERGE operations to enable fine-grained updates for aggregation queries with grouping keys. This approach works well for aggregated materialized views where specific groups can be identified and updated, but has limited applicability to non-aggregation queries (filters, joins, window functions) which still require partition-level refresh strategies. + +### 6. Two Stitching Modes: Partition-Based and Filter-Based + +The design supports two complementary stitching approaches based on connector capabilities and query types: + +**Partition-Based Stitching (Disjunctive Predicates)** +Uses partition boundaries for bulk operations. The connector provides disjunctive constraints identifying changed partitions, and the planner creates UNION plans that read entire fresh partitions from the MV data table and recompute entire stale partitions from base tables. This approach applies to aggregated materialized views and scenarios where partition-level granularity is used. + +**Filter-Based Stitching (Conjunctive Predicates + Time Travel)** +Uses filtering predicates for record-level data selection. The connector provides conjunctive constraints identifying specific changed records or files, enabling the planner to create UNION plans with filtering. For simple filter-based materialized views, this enables time travel queries that read incremental data from base tables at the last refresh snapshot, combined with filtering of fresh data from the MV data table. + +**Capability Signaling** +Connectors signal their capabilities through the granularity of conjunctive predicates: +- Specific conjunctive predicates (snapshot IDs, record keys) → enables filter-based stitching +- `TupleDomain.all()` conjunctive predicates → falls back to partition-based stitching + +**Query Examples by Stitching Mode** + +Partition-Based Stitching (aggregated materialized views): +```sql +-- Aggregation MV: requires recomputing entire groups when data changes +CREATE MATERIALIZED VIEW sales_summary AS +SELECT customer_region, sale_date, SUM(amount), COUNT(*) +FROM sales +GROUP BY customer_region, sale_date; + +-- Join MV with deletes/updates: single table change affects multiple MV rows, requires partition-level refresh +-- Also required when both sides of join are stale (can't time travel on both sides) +CREATE MATERIALIZED VIEW sales_with_customer AS +SELECT s.*, c.customer_name, c.customer_tier +FROM sales s JOIN customers c ON s.customer_id = c.id; +``` + +Filter-Based Stitching (simple filter materialized views): +```sql +-- Simple filter MV: row-level changes can be precisely tracked +CREATE MATERIALIZED VIEW recent_sales AS +SELECT * FROM sales WHERE sale_date >= '2024-01-01'; + +-- Multi-table filter MV: can use time travel only if one side of join is stale and there are no deletes/updates +CREATE MATERIALIZED VIEW high_value_sales AS +SELECT s.*, c.customer_name +FROM sales s JOIN customers c ON s.customer_id = c.id +WHERE s.amount > 10000; +``` + +Both Approaches (connector capability dependent): +```sql +-- Filter MV where filter aligns with partitions: works with both approaches +-- Assumes sales table is partitioned by day(sale_date) +CREATE MATERIALIZED VIEW recent_sales AS +SELECT * FROM sales +WHERE sale_date >= '2024-01-01'; +-- Partition-based: recompute entire day partitions when updates/deletes occur +-- Filter-based: use time travel for append-only changes within partitions + +-- Filter with additional non-partition predicates +CREATE MATERIALIZED VIEW high_value_recent_sales AS +SELECT * FROM sales +WHERE sale_date >= '2024-01-01' AND amount > 10000; +-- Partition-based: recompute affected day partitions +-- Filter-based: append new high-value rows via time travel when possible +``` + +### 7. Handling Partition Evolution and Incremental Data + +When a base table's partitioning evolves after MV creation, the system uses snapshot IDs to identify incremental changes since the last refresh. For append-only scenarios, the connector identifies files added after the MV's refresh snapshot and queries only those new rows. The snapshot ID marks the change boundary for incremental scans. + +### 8. Handling Deletes and Updates + +#### Incremental Scan Support via Conjunctive Predicates + +The connector signals its incremental scan capabilities through the granularity of conjunctive predicates in `StaleDataConstraints`[^15]. For append-only tables, connectors can provide snapshot-based time travel predicates for record-level precision. For tables with deletes or updates, connectors return `TupleDomain.all()` to signal that only partition-level boundaries are available. Future MERGE operations will enable group-level tracking for aggregation queries where specific affected groups can be identified. + +Connectors communicate their capabilities through predicate granularity rather than explicit capability methods. Specific conjunctive predicates indicate the connector supports record-level change tracking, while `TupleDomain.all()` indicates only partition-level refresh boundaries are available. + +### 9. Storage Table Location Strategy + +Iceberg will provide flexible configuration for where MV storage tables are created: + +```sql +-- Default: Same schema as MV +CREATE MATERIALIZED VIEW catalog.sales.monthly_summary AS ... +-- Creates storage table: catalog.sales.$materialized_view_storage$monthly_summary + +-- Option: Different schema for storage +CREATE MATERIALIZED VIEW catalog.sales.monthly_summary +WITH ( + storage_schema = 'sales_mv_storage', + partitioning = ARRAY['year(sale_date)', 'month(sale_date)'] +) +AS SELECT ... +-- Creates storage table: catalog.sales_mv_storage.$materialized_view_storage$monthly_summary +``` + +**Storage Configuration Options**: +- `storage_schema`: Schema for storage table (default: same as MV) +- `storage_table_prefix`: Prefix for storage table names (default: `$materialized_view_storage$`) + +**Session-level Defaults**: +```sql +SET SESSION iceberg.default_mv_storage_schema = 'mv_storage'; +SET SESSION iceberg.mv_storage_table_prefix = 'mv_'; +``` + +### 10. Atomic Operations and Catalog Support + +Since Iceberg doesn't support atomic multi-table operations, the implementation achieves consistency through a two-phase approach. During refresh, the storage table is updated first and its resulting snapshot ID is recorded. The view metadata is then updated with this snapshot ID, with this second commit serving as the atomic point. Queries always read the storage table at the snapshot specified in the view metadata, which serves as the ultimate source of truth. + +## Adoption Plan + +### Impact on Existing Users + +- **Deprecation**: The existing Hive MV implementation will be deprecated and eventually removed through the migration cycle (this feature is currently undocumented) +- **New Feature Flags**: + - `experimental.materialized-view-planner-stitching-enabled` (controls new query-time stitching) + - `experimental.materialized-view-connector-driven-refresh-enabled` (controls new refresh planning) + + +### Documentation Requirements + +- SPI implementation guide explaining the connector interfaces required for materialized view support +- Users guide covering system configurations and session properties for materialized views +- Iceberg-specific documentation for features like snapshot-based freshness and partition transforms + +### Out of Scope + +- Cross-connector materialized views +- Automatic MV selection for arbitrary queries +- View maintenance policies (TTL, auto-refresh) +- Cost-based refresh scheduling + +## Test Plan + +### Unit Tests + +- Basic tests for SPI implementations +- Planner rule tests for refresh logic +- Freshness calculation tests +- Incremental filter generation tests +- Partition alignment detection tests + +### Integration Tests + +- End-to-end MV creation and refresh +- Concurrent refresh and query execution +- Transaction rollback scenarios +- Large-scale incremental refresh + +## Migration Path from Current Implementation + +Since there are no tests for the end-to-end stitching logic, the migration refactors `MaterializedViewStatus` in-place and uses feature flags to control behavior: + +### Phase 1: In-Place Refactoring with Feature Flags + +The existing `MaterializedViewStatus` class is enhanced with the new `StaleDataConstraints` structure while maintaining backward compatibility. The same `getMaterializedViewStatus()` method returns the enhanced structure, but runtime behavior depends on feature flags. Two experimental feature flags control the new behavior: +- `experimental.materialized-view-planner-stitching-enabled` (controls query-time stitching in planner) +- `experimental.materialized-view-connector-driven-refresh-enabled` (controls dynamic refresh planning) + +Both flags default to false initially. + +### Phase 2: Dual Code Paths with Feature Flag Control + +The runtime maintains both old and new code paths simultaneously: + +**Query-time stitching**: When the planner stitching flag is disabled, the system uses the existing AST-based PredicateStitcher. When enabled, it uses the new planner-based MaterializedViewOptimizer that leverages the enhanced `MaterializedViewStatus` structure. + +**Refresh planning**: When the connector-driven refresh flag is disabled, the system uses the existing WHERE clause-based refresh. When enabled, it uses dynamic connector-driven refresh planning based on the `StaleDataConstraints` from `MaterializedViewStatus`. + +### Phase 3: Gradual Rollout and Testing + +**Release N: Experimental (flags off)** - Enhanced `MaterializedViewStatus` structure deployed, feature flags default to false, existing code paths remain active. + +**Release N+1: Opt-in Testing** - Feature flags can be enabled per deployment for testing, connectors update their `getMaterializedViewStatus()` implementations to return enhanced structures, deprecation warnings appear for `REFRESH MATERIALIZED VIEW WHERE` syntax when flag is enabled. + +**Release N+2: Default Transition** - Feature flags default to true, legacy code paths remain as fallback, connectors that haven't updated continue working with degraded functionality. + +**Release N+?: Legacy Removal** - Remove AST-based PredicateStitcher and WHERE clause refresh parsing, remove feature flags as new behavior becomes standard, `getMaterializedViewStatus()` with enhanced structure becomes the only implementation. + +## Open Questions + +1. **How to handle multiple base tables with different partitioning schemes?** + - Current design focuses on single base table scenarios + - Multi-table MVs may need special handling for partition alignment + - Simplified approach makes this easier to reason about + +2. **Should we support time-based staleness tolerance?** + - Allow MVs to be "acceptable stale" for performance + - Per-MV configuration vs global settings + - Could be implemented as filtering in MaterializedViewStatus + +3. **How to handle cross-connector materialized views in the future?** + - Not in initial scope but approach makes it easier + - Could extend MaterializedViewStatus to handle multiple catalogs + - Planner already handles cross-connector queries + +--- + +## Footnotes + +[^1]: **SPI Interface Details**: The existing `ConnectorMetadata` interface already contains all necessary methods for materialized views. The only addition is optional delegation methods for native connectors that handle refresh operations in their own databases (PostgreSQL, Snowflake, etc.) rather than using Presto's planning-based refresh. + +[^2]: **StaleDataConstraints Structure**: +```java +public class StaleDataConstraints { + // Disjunctive constraints: OR'd partition boundaries per table + private final Map>> dataDisjuncts; + + // Conjunctive constraints: AND'd filtering within boundaries per table + private final Map> conjunctiveConstraints; + + // Unified constraint calculation for any table + public TupleDomain getUnifiedConstraintForTable(SchemaTableName tableName); +} +``` + +The enhanced `MaterializedViewStatus` maintains backward compatibility while adding the new constraint structure and refresh time tracking. + +[^3]: **Planning Phase Changes**: The refresh planning logic moves from `StatementAnalyzer.visitRefreshMaterializedView()` (analysis phase) to `LogicalPlanner.createRefreshMaterializedViewPlan()` (planning phase). Analysis stores MV definition and WHERE clause in `RefreshMaterializedViewAnalysis`. Planning gets staleness from connector, applies WHERE filters by intersecting with stale constraints, builds plans for affected base tables (excluding MV data table), combines with UNION nodes, and uses existing `TableWriterNode` infrastructure. + +[^4]: **MaterializedViewScan AST and Plan Nodes**: New AST node `MaterializedViewScan` with data table and view query components. Analysis creates `MaterializedViewScanNode` plan node. Optimization converts to UNION via `MaterializedViewOptimizer` rule that gets staleness info and builds filtered fresh data + recomputed stale data union. + +[^5]: **Access Control Implementation**: Modified `StatementAnalyzer.visitRefreshMaterializedView()` determines access control mode by checking MV owner vs session user. Definer mode creates new Identity with owner credentials and ViewAccessControl wrapper. Invoker mode uses session identity directly. Builds appropriate session and StatementAnalyzer for refresh query analysis with correct permissions. + +[^6]: **Iceberg Staleness Detection**: `getMaterializedViewStatus()` compares current base table snapshot ID with MV's recorded refresh snapshot. For partitioned tables, identifies changed partitions between snapshots, converts to `TupleDomain` constraints. Helper methods detect stale partitions and convert Iceberg partition structs to constraint predicates for planner consumption. + +[^7]: **Snapshot-Based Change Detection**: `detectChangedPartitions()` identifies all files added/modified between snapshots, extracting partition information from each file. Refresh planning uses staleness information to get stale constraints, optionally intersects with WHERE clause, builds plans for affected base tables, applies MV transformations, and combines with UNION nodes. + +[^8]: **Query-Time Stitching Implementation**: +```java +// In RelationPlanner - when encountering a materialized view scan +public RelationPlan planMaterializedViewQuery(TableHandle mvHandle, MaterializedViewDefinition definition) { + // Get staleness information using existing SPI method + MaterializedViewStatus status = metadata.getMaterializedViewStatus(session, mvHandle.getSchemaTableName()); + + if (status.isFullyMaterialized()) { + // MV is completely fresh - just scan it directly + return createSimpleTableScan(mvHandle); + } + + // Build stitching plan using standard nodes + List unionParts = new ArrayList<>(); + + // Part 1: Fresh data from MV + Map> staleConstraints = status.getStaleDataConstraints(); + TupleDomain freshConstraint = calculateFreshConstraint(staleConstraints); + if (!freshConstraint.isNone()) { + TableScanNode freshScan = new TableScanNode(mvHandle.withConstraint(freshConstraint), mvColumns, assignments); + unionParts.add(freshScan); + } + + // Part 2: Stale data from base tables (recomputed) + for (Map.Entry> entry : staleConstraints.entrySet()) { + SchemaTableName tableName = entry.getKey(); + TupleDomain staleConstraint = entry.getValue(); + + // Get base table and apply stale constraint + TableHandle baseHandle = getBaseTableHandle(tableName); + TableScanNode staleScan = new TableScanNode(baseHandle.withConstraint(staleConstraint), baseColumns, baseAssignments); + + // Apply MV transformations to stale data + PlanNode transformedStaleData = applyMVTransformations(staleScan, definition); + unionParts.add(transformedStaleData); + } + + // Union fresh and stale data + return new RelationPlan(new UnionNode(idAllocator.getNextId(), unionParts, mvColumns, symbolMapping), scope, mvColumns); +} + +// Calculate what data is fresh (inverse of stale constraints) +private TupleDomain calculateFreshConstraint(Map> staleConstraints) { + // Union all stale constraints + TupleDomain allStaleData = TupleDomain.none(); + for (TupleDomain staleConstraint : staleConstraints.values()) { + allStaleData = allStaleData.union(staleConstraint); + } + // Fresh data is everything NOT stale + return allStaleData.complement(); +} +``` + +[^9]: **Connector Staleness Detection Implementation**: +```java +public MaterializedViewStatus getMaterializedViewStatus(SchemaTableName viewName) { + // Connector detects staleness on base tables using pass-through columns + Map>> staleDisjuncts = new HashMap<>(); + Map> conjunctiveConstraints = new HashMap<>(); + + // Example: sales table has stale partitions for specific groups + List> salesStalePartitions = ImmutableList.of( + TupleDomain.withColumnDomains(Map.of( + "sale_date", Domain.greaterThanOrEqual(DATE, DateTimeUtils.parseDate("2024-01-01")), + "customer_region", Domain.singleValue(VARCHAR, utf8Slice("US"))))); + + staleDisjuncts.put(salesTableName, salesStalePartitions); + + // Conjunctive: precise filtering within partition boundaries (if connector supports it) + conjunctiveConstraints.put(salesTableName, TupleDomain.all()); // Safe boundary for this example + + StaleDataConstraints staleConstraints = new StaleDataConstraints(staleDisjuncts, conjunctiveConstraints); + return new MaterializedViewStatus(false, staleConstraints); +} +``` + +[^10]: **Runtime MV Constraint Derivation**: +```java +// In RelationPlanner.planMaterializedViewQuery() +public RelationPlan planMaterializedViewQuery(TableHandle mvHandle, MaterializedViewDefinition definition) { + MaterializedViewStatus status = metadata.getMaterializedViewStatus(session, mvHandle.getSchemaTableName()); + StaleDataConstraints staleConstraints = status.getStaleDataConstraints(); + + // Runtime derives fresh constraints for MV data table using complement logic + TupleDomain mvFreshConstraints = deriveMVFreshConstraints(staleConstraints); + + // Build UNION: fresh MV data + recomputed stale base data + return buildStitchingPlan(mvHandle, mvFreshConstraints, staleConstraints, definition); +} + +private TupleDomain deriveMVFreshConstraints(StaleDataConstraints staleConstraints) { + // Union all stale constraints from base tables + TupleDomain allStaleConstraints = TupleDomain.none(); + for (Map.Entry>> entry : staleConstraints.getDataDisjuncts().entrySet()) { + for (TupleDomain staleConstraint : entry.getValue()) { + allStaleConstraints = allStaleConstraints.union(staleConstraint); + } + } + + // Derive fresh constraints using custom logic similar to MaterializedViewUtils.differenceDataPredicates + // This handles constraint negation and boundary computation for pass-through columns + return MaterializedViewConstraintUtils.deriveFreshConstraints(allStaleConstraints); +} +``` + +[^11]: **Iceberg-Specific Constraint Processing Implementation**: +```java +// Step 1: Snapshot-Based Staleness Detection +public MaterializedViewStatus getMaterializedViewStatus(SchemaTableName viewName) { + IcebergMaterializedView mv = getMaterializedView(viewName); + Table baseTable = getTable(mv.getBaseTableName()); + + long currentSnapshot = baseTable.currentSnapshot().snapshotId(); + long lastRefreshSnapshot = mv.getBaseTableSnapshotId(); + + if (currentSnapshot == lastRefreshSnapshot) { + return MaterializedViewStatus.fullyMaterialized(); + } + + // Use appropriate Iceberg scan to identify changed partitions + Set changedPartitions = detectChangedPartitions( + baseTable, lastRefreshSnapshot, currentSnapshot); + + return buildConstraintsFromChangedPartitions(changedPartitions, mv); +} + +// Step 2: Constraint Building from Changed Partitions +private StaleDataConstraints buildConstraintsFromChangedPartitions( + Set changedPartitions, + IcebergMaterializedView mv) { + + List> baseTableStaleConstraints = + convertPartitionsToConstraints(changedPartitions, mv.getBaseTable().spec()); + + return new StaleDataConstraints( + Map.of(mv.getBaseTableName(), baseTableStaleConstraints), + Map.of(mv.getBaseTableName(), TupleDomain.all()) + ); +} + +// Step 3: Schema Mapping Elimination +private List> convertPartitionsToConstraints( + Set partitions, + PartitionSpec partitionSpec) { + + List> constraints = new ArrayList<>(); + + for (StructLike partition : partitions) { + Map columnDomains = new HashMap<>(); + + for (int i = 0; i < partitionSpec.fields().size(); i++) { + PartitionField field = partitionSpec.fields().get(i); + Object partitionValue = partition.get(i, Object.class); + + // Hidden partitions: use the raw column name, not transform name + String sourceColumnName = field.transform().toString(); + Domain domain = createDomainFromPartitionValue(partitionValue, field.transform()); + + columnDomains.put(sourceColumnName, domain); + } + + constraints.add(TupleDomain.withColumnDomains(columnDomains)); + } + + return constraints; +} +``` + +[^12]: **Mixed Partition Alignment Example**: +```java +// Example showing different strategies per base table in multi-table materialized views +StaleDataConstraints mixed = new StaleDataConstraints( + Map.of( + // Aligned partitioning: specific predicates provided + salesTable, List.of(TupleDomain.withColumnDomains(Map.of( + "sale_date", Domain.singleValue(DATE, parseDate("2024-01-15"))))), + + // Misaligned partitioning: empty list signals full refresh needed + ordersTable, List.of() + ), + Map.of(salesTable, TupleDomain.all(), ordersTable, TupleDomain.all()) +); +``` + +[^13]: **Missing MV-Side Filtering Example**: +```java +// From StatementAnalyzer.java - creates UNION of: +// 1. Base table query with stale partition predicates (filtered correctly) +// 2. MV table with NO filtering (includes ALL data, even stale!) + +// TODO: consider materialized view predicates https://github.com/prestodb/presto/issues/16034 +QuerySpecification materializedViewQuerySpecification = new QuerySpecification( + selectList(new AllColumns()), + Optional.of(materializedView), + Optional.empty(), // NO WHERE clause - includes stale data! + // ... all other constraints are empty +); + +Union union = new Union(ImmutableList.of( + predicateStitchedQuery.getQueryBody(), // Base tables (filtered) + materializedViewQuerySpecification // MV (unfiltered - includes stale data!) +), Optional.of(Boolean.FALSE)); +``` + +[^14]: **Disjunctive vs Conjunctive Constraints Examples**: +```java +// Disjunctive (existing): OR'd partition boundaries - for bulk partition operations +Map>> disjunctive = Map.of( + salesTable, List.of( + // Partition 1: January US sales + TupleDomain.withColumnDomains(Map.of( + "sale_date", Domain.singleValue(DATE, parseDate("2024-01-01")), + "customer_region", Domain.singleValue(VARCHAR, utf8Slice("US")))), + // Partition 2: February US sales + TupleDomain.withColumnDomains(Map.of( + "sale_date", Domain.singleValue(DATE, parseDate("2024-02-01")), + "customer_region", Domain.singleValue(VARCHAR, utf8Slice("US")))) + ) // These are OR'd together +); + +// Conjunctive (new): AND'd filtering within boundaries - for file/record-level precision +Map> conjunctive = Map.of( + salesTable, TupleDomain.withColumnDomains(Map.of( + "file_id", Domain.multipleValues(BIGINT, List.of(101L, 102L, 103L)), + "last_modified", Domain.greaterThan(TIMESTAMP, parseTimestamp("2024-01-15 10:00:00")) + )) // These constraints are AND'd together for precision within partition boundaries +); +``` + +[^15]: **Incremental Scan Capability Signaling**: +```java +// Append-only tables: Can provide precise snapshot-based changes +Map>> appendOnlyDisjuncts = ImmutableMap.of( + baseTableName, ImmutableList.of(TupleDomain.withColumnDomains( + ImmutableMap.of("date", Domain.greaterThanOrEqual(VARCHAR, utf8Slice("2024-01-01")))))); +Map> appendOnlyConjuncts = ImmutableMap.of( + baseTableName, TupleDomain.withColumnDomains( + ImmutableMap.of("$snapshot_id", Domain.singleValue(BIGINT, lastRefreshSnapshotId)))); +StaleDataConstraints appendOnlyConstraints = new StaleDataConstraints(appendOnlyDisjuncts, appendOnlyConjuncts); + +// Tables with deletes/updates: Can only provide safe boundaries +Map>> safeDisjuncts = ImmutableMap.of( + baseTableName, ImmutableList.of(TupleDomain.withColumnDomains( + ImmutableMap.of("date", Domain.greaterThanOrEqual(VARCHAR, utf8Slice("2024-01-01")))))); +Map> safeConjuncts = ImmutableMap.of( + baseTableName, TupleDomain.all()); // No precision available - broad recomputation needed +StaleDataConstraints safeConstraints = new StaleDataConstraints(safeDisjuncts, safeConjuncts); + +// Future with MERGE: Can provide precise group-level changes +Map>> mergeDisjuncts = ImmutableMap.of( + baseTableName, ImmutableList.of(TupleDomain.withColumnDomains( + ImmutableMap.of("product_id", Domain.singleValue(INTEGER, 123L))))); +Map> mergeConjuncts = ImmutableMap.of( + baseTableName, TupleDomain.withColumnDomains(ImmutableMap.of( + "affected_groups", Domain.multipleValues(ROW_TYPE, affectedGroupingKeys)))); +StaleDataConstraints mergeConstraints = new StaleDataConstraints(mergeDisjuncts, mergeConjuncts); +``` \ No newline at end of file diff --git a/RFC-0017/current-vs-rfc-refresh.excalidraw b/RFC-0017/current-vs-rfc-refresh.excalidraw new file mode 100644 index 00000000..1109d308 --- /dev/null +++ b/RFC-0017/current-vs-rfc-refresh.excalidraw @@ -0,0 +1,869 @@ +{ + "type": "excalidraw", + "version": 2, + "source": "https://excalidraw.com", + "elements": [ + { + "type": "text", + "version": 13, + "versionNonce": 2027189846, + "isDeleted": false, + "id": "title-current", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 186.84010314941406, + "y": 30, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 226.31979370117188, + "height": 25, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "Current Refresh", + "textAlign": "center", + "verticalAlign": "top", + "containerId": null, + "originalText": "Current Refresh", + "lineHeight": 1.25, + "baseline": 18, + "index": "a0", + "autoResize": true + }, + { + "type": "text", + "version": 13, + "versionNonce": 93667850, + "isDeleted": false, + "id": "title-rfc", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 659.3900527954102, + "y": 30, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 131.2198944091797, + "height": 25, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "RFC Refresh", + "textAlign": "center", + "verticalAlign": "top", + "containerId": null, + "originalText": "RFC Refresh", + "lineHeight": 1.25, + "baseline": 18, + "index": "a1", + "autoResize": true + }, + { + "type": "text", + "version": 32, + "versionNonce": 987708310, + "isDeleted": false, + "id": "analysis-phase", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 10, + "y": 100, + "strokeColor": "#495057", + "backgroundColor": "transparent", + "width": 80, + "height": 20, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 1, + "text": "Analysis", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Analysis", + "lineHeight": 1.25, + "baseline": 15, + "index": "a2", + "autoResize": true + }, + { + "type": "text", + "version": 127, + "versionNonce": 1383362762, + "isDeleted": false, + "id": "planning-phase", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 10, + "y": 310, + "strokeColor": "#495057", + "backgroundColor": "transparent", + "width": 80, + "height": 20, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 1, + "text": "Planning", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Planning", + "lineHeight": 1.25, + "baseline": 15, + "index": "a3", + "autoResize": true + }, + { + "type": "text", + "version": 174, + "versionNonce": 299849942, + "isDeleted": false, + "id": "execution-phase", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 10, + "y": 520, + "strokeColor": "#495057", + "backgroundColor": "transparent", + "width": 80, + "height": 20, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 1, + "text": "Execution", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Execution", + "lineHeight": 1.25, + "baseline": 15, + "index": "a4", + "autoResize": true + }, + { + "type": "line", + "version": 111, + "versionNonce": 16762762, + "isDeleted": false, + "id": "separator-line", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "dashed", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 450, + "y": 70, + "strokeColor": "#868e96", + "backgroundColor": "transparent", + "width": 0, + "height": 530, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": null, + "points": [ + [ + 0, + 0 + ], + [ + 0, + 530 + ] + ], + "index": "a5", + "polygon": false + }, + { + "type": "rectangle", + "version": 117, + "versionNonce": 931070294, + "isDeleted": false, + "id": "step1-current", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 110, + "y": 99.87109375, + "strokeColor": "#1971c2", + "backgroundColor": "#dbeafe", + "width": 330, + "height": 151.171875, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step1-current-text" + } + ], + "updated": 1759267091863, + "link": null, + "locked": false, + "index": "a6" + }, + { + "type": "text", + "version": 108, + "versionNonce": 679229718, + "isDeleted": false, + "id": "step1-current-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 115, + "y": 104.87109375, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 232.83377075195312, + "height": 70, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267109015, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Parse MV definition\n• Extract WHERE clause\n• Build refresh query from WHERE\n• Analyze constructed query", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step1-current", + "originalText": "• Parse MV definition\n• Extract WHERE clause\n• Build refresh query from WHERE\n• Analyze constructed query", + "lineHeight": 1.25, + "baseline": 144, + "index": "a7", + "autoResize": true + }, + { + "type": "rectangle", + "version": 158, + "versionNonce": 666529302, + "isDeleted": false, + "id": "step1-rfc", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 499.87109375, + "y": 99.87109375, + "strokeColor": "#1971c2", + "backgroundColor": "#dbeafe", + "width": 330, + "height": 153.7421875, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step1-rfc-text" + } + ], + "updated": 1759267021972, + "link": null, + "locked": false, + "index": "a8" + }, + { + "type": "text", + "version": 117, + "versionNonce": 257332694, + "isDeleted": false, + "id": "step1-rfc-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 504.87109375, + "y": 104.87109375, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 282.7576904296875, + "height": 87.5, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267132692, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Store MV definition\n• Store WHERE clause (if present)\n• Create RefreshMaterializedViewAnalysis\n• No query construction\n• Analyze embedded MV definition", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step1-rfc", + "originalText": "• Store MV definition\n• Store WHERE clause (if present)\n• Create RefreshMaterializedViewAnalysis\n• No query construction\n• Analyze embedded MV definition", + "lineHeight": 1.25, + "baseline": 144, + "index": "a9", + "autoResize": true + }, + { + "type": "arrow", + "version": 57, + "versionNonce": 1330757782, + "isDeleted": false, + "id": "arrow1-current", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 275, + "y": 260, + "strokeColor": "#1971c2", + "backgroundColor": "transparent", + "width": 0, + "height": 40, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 40 + ] + ], + "index": "aA" + }, + { + "type": "arrow", + "version": 88, + "versionNonce": 1478015946, + "isDeleted": false, + "id": "arrow1-rfc", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 665, + "y": 260, + "strokeColor": "#1971c2", + "backgroundColor": "transparent", + "width": 0, + "height": 40, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 40 + ] + ], + "index": "aB" + }, + { + "type": "rectangle", + "version": 190, + "versionNonce": 2129108694, + "isDeleted": false, + "id": "step2-current", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 110, + "y": 309.87109375, + "strokeColor": "#fd7e14", + "backgroundColor": "#ffe8cc", + "width": 330, + "height": 153.61328125000003, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step2-current-text" + } + ], + "updated": 1759267083881, + "link": null, + "locked": false, + "index": "aC" + }, + { + "type": "text", + "version": 169, + "versionNonce": 74887894, + "isDeleted": false, + "id": "step2-current-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 115, + "y": 314.87109375, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 279.3836975097656, + "height": 87.5, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267283160, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Use pre-built query from analysis\n• Plan constructed query\n• Rewrite to create insert with pre-built\nquery\n• Staleness embedded in query", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step2-current", + "originalText": "• Use pre-built query from analysis\n• Plan constructed query\n• Rewrite to create insert with pre-built query\n• Staleness embedded in query", + "lineHeight": 1.25, + "baseline": 144, + "index": "aD", + "autoResize": true + }, + { + "type": "rectangle", + "version": 369, + "versionNonce": 1453400906, + "isDeleted": false, + "id": "step2-rfc", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 487.8046875, + "y": 307.57421875, + "strokeColor": "#fd7e14", + "backgroundColor": "#ffe8cc", + "width": 330, + "height": 153.7578125, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step2-rfc-text" + } + ], + "updated": 1759267210561, + "link": null, + "locked": false, + "index": "aE" + }, + { + "type": "text", + "version": 399, + "versionNonce": 752299274, + "isDeleted": false, + "id": "step2-rfc-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 492.8046875, + "y": 312.57421875, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 319.2976989746094, + "height": 87.5, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267231725, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Use query from analysis\n• Call getMaterializedViewStatus()\n• Rewrite to add filters to base table scans,\ncreate insert\n• Plan query", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step2-rfc", + "originalText": "• Use query from analysis\n• Call getMaterializedViewStatus()\n• Rewrite to add filters to base table scans, create insert\n• Plan query", + "lineHeight": 1.25, + "baseline": 144, + "index": "aF", + "autoResize": true + }, + { + "type": "arrow", + "version": 131, + "versionNonce": 1423458390, + "isDeleted": false, + "id": "arrow2-current", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 275, + "y": 470, + "strokeColor": "#fd7e14", + "backgroundColor": "transparent", + "width": 0, + "height": 40, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 40 + ] + ], + "index": "aG" + }, + { + "type": "arrow", + "version": 162, + "versionNonce": 873142282, + "isDeleted": false, + "id": "arrow2-rfc", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 665, + "y": 470, + "strokeColor": "#fd7e14", + "backgroundColor": "transparent", + "width": 0, + "height": 40, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 40 + ] + ], + "index": "aH" + }, + { + "type": "rectangle", + "version": 181, + "versionNonce": 937018774, + "isDeleted": false, + "id": "step3-current", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 110, + "y": 520, + "strokeColor": "#9775fa", + "backgroundColor": "#f3f0ff", + "width": 330, + "height": 80, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step3-current-text" + } + ], + "updated": 1759266985233, + "link": null, + "locked": false, + "index": "aI" + }, + { + "type": "text", + "version": 214, + "versionNonce": 532645578, + "isDeleted": false, + "id": "step3-current-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 115, + "y": 525, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 320, + "height": 70, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Execute refresh plan\n• Write to MV storage table", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step3-current", + "originalText": "• Execute refresh plan\n• Write to MV storage table", + "lineHeight": 1.25, + "baseline": 64, + "index": "aJ", + "autoResize": true + }, + { + "type": "rectangle", + "version": 147, + "versionNonce": 1660461782, + "isDeleted": false, + "id": "step3-rfc", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 500, + "y": 520, + "strokeColor": "#9775fa", + "backgroundColor": "#f3f0ff", + "width": 330, + "height": 80, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [ + { + "type": "text", + "id": "step3-rfc-text" + } + ], + "updated": 1759266985233, + "link": null, + "locked": false, + "index": "aK" + }, + { + "type": "text", + "version": 152, + "versionNonce": 1618484618, + "isDeleted": false, + "id": "step3-rfc-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 505, + "y": 525, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 320, + "height": 70, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759266985233, + "link": null, + "locked": false, + "fontSize": 14, + "fontFamily": 1, + "text": "• Execute refresh plan\n• Write to MV storage table", + "textAlign": "left", + "verticalAlign": "top", + "containerId": "step3-rfc", + "originalText": "• Execute refresh plan\n• Write to MV storage table", + "lineHeight": 1.25, + "baseline": 64, + "index": "aL", + "autoResize": true + } + ], + "appState": { + "gridSize": 20, + "gridStep": 5, + "gridModeEnabled": false, + "viewBackgroundColor": "#ffffff", + "lockedMultiSelections": {} + }, + "files": {} +} \ No newline at end of file diff --git a/RFC-0017/current-vs-rfc-refresh.png b/RFC-0017/current-vs-rfc-refresh.png new file mode 100644 index 0000000000000000000000000000000000000000..01e2f63344e84731f272d69fcac0d94377b2df85 GIT binary patch literal 110970 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

RM7$|n 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

cRph)fNA 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 E0mDTsdH?_b literal 0 HcmV?d00001 diff --git a/RFC-0017/mv-architecture-flow.excalidraw b/RFC-0017/mv-architecture-flow.excalidraw new file mode 100644 index 00000000..f800a107 --- /dev/null +++ b/RFC-0017/mv-architecture-flow.excalidraw @@ -0,0 +1,969 @@ +{ + "type": "excalidraw", + "version": 2, + "source": "https://excalidraw.com", + "elements": [ + { + "type": "text", + "version": 3, + "versionNonce": 1031141450, + "isDeleted": false, + "id": "title", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 305.7281036376953, + "y": 20, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 488.5437927246094, + "height": 35, + "seed": 1, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 28, + "fontFamily": 1, + "text": "Materialized View Architecture Flow", + "textAlign": "center", + "verticalAlign": "top", + "containerId": null, + "originalText": "Materialized View Architecture Flow", + "lineHeight": 1.25, + "baseline": 25, + "index": "a0", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 2000423254, + "isDeleted": false, + "id": "phase1", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 250, + "y": 100, + "strokeColor": "#1971c2", + "backgroundColor": "#e7f5ff", + "width": 850, + "height": 200, + "seed": 2, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "a1" + }, + { + "type": "text", + "version": 3, + "versionNonce": 828661514, + "isDeleted": false, + "id": "phase1-title", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 270, + "y": 110, + "strokeColor": "#1971c2", + "backgroundColor": "transparent", + "width": 264.97979736328125, + "height": 25, + "seed": 3, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "Phase 1: Parser & Analysis", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Phase 1: Parser & Analysis", + "lineHeight": 1.25, + "baseline": 18, + "index": "a2", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 1289514646, + "isDeleted": false, + "id": "query-mv-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 300, + "y": 150, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 120, + "seed": 6, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "a3" + }, + { + "type": "text", + "version": 4, + "versionNonce": 1347939786, + "isDeleted": false, + "id": "query-mv-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 310, + "y": 160, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 262.5, + "height": 100, + "seed": 7, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "QUERY (SELECT FROM MV)\n\n• Parser: Table reference\n• Analysis: Resolve table\n• SPI: getMaterializedView()", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "QUERY (SELECT FROM MV)\n\n• Parser: Table reference\n• Analysis: Resolve table\n• SPI: getMaterializedView()", + "lineHeight": 1.25, + "baseline": 95, + "index": "a4", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 1941842902, + "isDeleted": false, + "id": "refresh-mv-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 720, + "y": 150, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 120, + "seed": 8, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "a5" + }, + { + "type": "text", + "version": 4, + "versionNonce": 1332454538, + "isDeleted": false, + "id": "refresh-mv-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 730, + "y": 160, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 365.625, + "height": 100, + "seed": 9, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "REFRESH MATERIALIZED VIEW\n\n• Parser: RefreshMaterializedView AST\n• Analysis: Store MV definition & WHERE\n• SPI: getMaterializedView()", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "REFRESH MATERIALIZED VIEW\n\n• Parser: RefreshMaterializedView AST\n• Analysis: Store MV definition & WHERE\n• SPI: getMaterializedView()", + "lineHeight": 1.25, + "baseline": 95, + "index": "a6", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 1777746198, + "isDeleted": false, + "id": "phase2", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 250, + "y": 320, + "strokeColor": "#2f9e44", + "backgroundColor": "#e6fcf5", + "width": 850, + "height": 280, + "seed": 10, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "a7" + }, + { + "type": "text", + "version": 3, + "versionNonce": 140149578, + "isDeleted": false, + "id": "phase2-title", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 270, + "y": 330, + "strokeColor": "#2f9e44", + "backgroundColor": "transparent", + "width": 171.55987548828125, + "height": 25, + "seed": 11, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "Phase 2: Planning", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Phase 2: Planning", + "lineHeight": 1.25, + "baseline": 18, + "index": "a8", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 586788438, + "isDeleted": false, + "id": "query-plan-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 300, + "y": 370, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 200, + "seed": 14, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "a9" + }, + { + "type": "text", + "version": 9, + "versionNonce": 212955466, + "isDeleted": false, + "id": "query-plan-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 310, + "y": 380, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 328.125, + "height": 160, + "seed": 15, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267482366, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "QUERY MV Planning (Stitching)\n\n• Create MaterializedViewScanNode\n• Check freshness\n\n• SPI calls:\n - getMaterializedViewStatus()\n• Optimizer will transform to Union", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "QUERY MV Planning (Stitching)\n\n• Create MaterializedViewScanNode\n• Check freshness\n\n• SPI calls:\n - getMaterializedViewStatus()\n• Optimizer will transform to Union", + "lineHeight": 1.25, + "baseline": 175, + "index": "aA", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 1537045398, + "isDeleted": false, + "id": "refresh-plan-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 720, + "y": 370, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 200, + "seed": 16, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "aB" + }, + { + "type": "text", + "version": 4, + "versionNonce": 1305852106, + "isDeleted": false, + "id": "refresh-plan-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 730, + "y": 380, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 337.5, + "height": 180, + "seed": 17, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "REFRESH MV Planning\n\n• Create RefreshMaterializedViewNode\n• Determine refresh strategy\n\n• SPI calls:\n - getMaterializedViewStatus()\n - getRefreshLayout()\n - beginRefreshMaterializedView()", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "REFRESH MV Planning\n\n• Create RefreshMaterializedViewNode\n• Determine refresh strategy\n\n• SPI calls:\n - getMaterializedViewStatus()\n - getRefreshLayout()\n - beginRefreshMaterializedView()", + "lineHeight": 1.25, + "baseline": 175, + "index": "aC", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 1846972630, + "isDeleted": false, + "id": "phase3", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 250, + "y": 620, + "strokeColor": "#e03131", + "backgroundColor": "#fff0f6", + "width": 850, + "height": 200, + "seed": 18, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "aD" + }, + { + "type": "text", + "version": 3, + "versionNonce": 284692362, + "isDeleted": false, + "id": "phase3-title", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 270, + "y": 630, + "strokeColor": "#e03131", + "backgroundColor": "transparent", + "width": 189.85984802246094, + "height": 25, + "seed": 19, + "groupIds": [ + "phases" + ], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "Phase 3: Execution", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Phase 3: Execution", + "lineHeight": 1.25, + "baseline": 18, + "index": "aE", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 637142550, + "isDeleted": false, + "id": "query-exec-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 300, + "y": 670, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 120, + "seed": 22, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "aF" + }, + { + "type": "text", + "version": 4, + "versionNonce": 1394708042, + "isDeleted": false, + "id": "query-exec-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 310, + "y": 680, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 375, + "height": 100, + "seed": 23, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "QUERY MV Execution\n\n• Execute stitched plan (if needed)\n• Read from MV and/or base tables\n• SPI: getTableScanHandle(), getSplits()", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "QUERY MV Execution\n\n• Execute stitched plan (if needed)\n• Read from MV and/or base tables\n• SPI: getTableScanHandle(), getSplits()", + "lineHeight": 1.25, + "baseline": 95, + "index": "aG", + "autoResize": true + }, + { + "type": "rectangle", + "version": 2, + "versionNonce": 339530582, + "isDeleted": false, + "id": "refresh-exec-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 720, + "y": 670, + "strokeColor": "#1e1e1e", + "backgroundColor": "#ffffff", + "width": 380, + "height": 120, + "seed": 24, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "index": "aH" + }, + { + "type": "text", + "version": 4, + "versionNonce": 2033005834, + "isDeleted": false, + "id": "refresh-exec-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 730, + "y": 680, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 356.25, + "height": 100, + "seed": 25, + "groupIds": [], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "REFRESH MV Execution\n\n• Execute refresh plan\n• Update MV storage table\n• SPI: finishRefreshMaterializedView()", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "REFRESH MV Execution\n\n• Execute refresh plan\n• Update MV storage table\n• SPI: finishRefreshMaterializedView()", + "lineHeight": 1.25, + "baseline": 95, + "index": "aI", + "autoResize": true + }, + { + "type": "arrow", + "version": 2, + "versionNonce": 1664350358, + "isDeleted": false, + "id": "arrow2", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 490, + "y": 270, + "strokeColor": "#1971c2", + "backgroundColor": "transparent", + "width": 0, + "height": 100, + "seed": 27, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 100 + ] + ], + "index": "aJ" + }, + { + "type": "arrow", + "version": 2, + "versionNonce": 345375690, + "isDeleted": false, + "id": "arrow3", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 910, + "y": 270, + "strokeColor": "#1971c2", + "backgroundColor": "transparent", + "width": 0, + "height": 100, + "seed": 28, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 100 + ] + ], + "index": "aK" + }, + { + "type": "arrow", + "version": 2, + "versionNonce": 714372566, + "isDeleted": false, + "id": "arrow5", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 490, + "y": 570, + "strokeColor": "#2f9e44", + "backgroundColor": "transparent", + "width": 0, + "height": 100, + "seed": 30, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 100 + ] + ], + "index": "aL" + }, + { + "type": "arrow", + "version": 2, + "versionNonce": 1333197450, + "isDeleted": false, + "id": "arrow6", + "fillStyle": "hachure", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 910, + "y": 570, + "strokeColor": "#2f9e44", + "backgroundColor": "transparent", + "width": 0, + "height": 100, + "seed": 31, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 2 + }, + "boundElements": [], + "updated": 1759267463199, + "link": null, + "locked": false, + "startBinding": null, + "endBinding": null, + "lastCommittedPoint": null, + "startArrowhead": null, + "endArrowhead": "arrow", + "points": [ + [ + 0, + 0 + ], + [ + 0, + 100 + ] + ], + "index": "aM" + }, + { + "type": "rectangle", + "version": 3, + "versionNonce": 2044265174, + "isDeleted": false, + "id": "legend-box", + "fillStyle": "solid", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 250, + "y": 849.87109375, + "strokeColor": "#868e96", + "backgroundColor": "#f8f9fa", + "width": 850, + "height": 150, + "seed": 32, + "groupIds": [ + "legend" + ], + "frameId": null, + "roundness": { + "type": 3 + }, + "boundElements": [], + "updated": 1759267491361, + "link": null, + "locked": false, + "index": "aN" + }, + { + "type": "text", + "version": 4, + "versionNonce": 882784278, + "isDeleted": false, + "id": "legend-title", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 270, + "y": 859.87109375, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 169.61985778808594, + "height": 25, + "seed": 33, + "groupIds": [ + "legend" + ], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267491361, + "link": null, + "locked": false, + "fontSize": 20, + "fontFamily": 1, + "text": "Key SPI Methods", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "Key SPI Methods", + "lineHeight": 1.25, + "baseline": 18, + "index": "aO", + "autoResize": true + }, + { + "type": "text", + "version": 7, + "versionNonce": 322350998, + "isDeleted": false, + "id": "legend-text", + "fillStyle": "hachure", + "strokeWidth": 1, + "strokeStyle": "solid", + "roughness": 1, + "opacity": 100, + "angle": 0, + "x": 270, + "y": 899.87109375, + "strokeColor": "#1e1e1e", + "backgroundColor": "transparent", + "width": 609.375, + "height": 60, + "seed": 34, + "groupIds": [ + "legend" + ], + "frameId": null, + "roundness": null, + "boundElements": [], + "updated": 1759267495439, + "link": null, + "locked": false, + "fontSize": 16, + "fontFamily": 3, + "text": "• getMaterializedView() - Retrieve MV definition (Analysis phase)\n• getMaterializedViewStatus() - Check freshness (Planning phase)\n", + "textAlign": "left", + "verticalAlign": "top", + "containerId": null, + "originalText": "• getMaterializedView() - Retrieve MV definition (Analysis phase)\n• getMaterializedViewStatus() - Check freshness (Planning phase)\n", + "lineHeight": 1.25, + "baseline": 75, + "index": "aP", + "autoResize": true + } + ], + "appState": { + "gridSize": 20, + "gridStep": 5, + "gridModeEnabled": false, + "viewBackgroundColor": "#ffffff", + "lockedMultiSelections": {} + }, + "files": {} +} \ No newline at end of file