//物化视图 CREATE MATERIALIZED VIEW mv1 AS SELECT column1,column2,column3,column4 FROM test1 WHERE column1=column2 AND column3=column4; //用户查询 SELECT column1,column2,column3,column4 FROM test1 WHERE column1=column2;

• 用户 query 的等价类为：
• 物化视图等价类为：

//物化视图 CREATE MATERIALIZED VIEW mv1 AS SELECT column1,column2,column3,column4,column5 FROM test1 WHERE column3 > 10; //查询 SELECT column1,column2,column3,column4,column5 FROM test1 WHERE column3 > 50;

• 物化视图范围谓词：{column3 } ∈ (10, +∞)
• 用户查询谓词：{column3 } ∈ (50, +∞)

1. 比较物化视图和用户 query 等价类时获得的列等价谓词。 比如谓词：(o_orderdate = l_shipdate)。
2. 根据物化视图范围谓词，检查用户 query 范围谓词时获得的范围谓词。 比如谓词： ({p_partkey, l_partkey} <= 160) 。
3. 查询中不匹配的剩余谓词。 比如谓词：(l_quantity*l_extendedprice > 100)。

1. 将视图等价类与查询等价类进行比较时构造补偿列等价谓词。 尝试将每个列引用映射到物化视图输出列（通过视图等价类），若映射失败，则改写失败。
2. 通过比较列范围来构造补偿范围谓词。 尝试将每个列引用映射到物化视图的输出列（使用查询等价类）。 若映射失败，则改写失败。
3. 查找物化视图中缺少的 query 的剩余谓词。 尝试将每个列引用映射到物化视图输出列（使用查询等价类）。 若映射失败，则改写失败。

创建视图： Create view V2 with schemabinding as Select l_orderkey, o_custkey, l_partkey, l_shipdate, o_orderdate, l_quantity*l_extendedprice as gross_revenue From dbo.lineitem, dbo.orders, dbo.part Where l_orderkey = o_orderkey And l_partkey = p_partkey And p_partkey >= 150 And o_custkey >= 50 and o_custkey <= 500 And p_name like ‘%abc%’用户 Query： Select l_orderkey, o_custkey, l_partkey, l_quantity*l_extendedprice From lineitem, orders, part Where l_orderkey = o_orderkey And l_partkey = p_partkey And l_partkey >= 150 and l_partkey <= 160 And o_custkey = 123 And o_orderdate = l_shipdate And p_name like ‘%abc%’ And l_quantity*l_extendedprice > 100

• View equivalence classes: {l_orderkey, o_orderkey}, {l_partkey, p_partkey}, {o_orderdate}, {l_shipdate}
• Query equivalence classes: {l_orderkey, o_orderkey}, {l_partkey, p_partkey}, {o_orderdate, l_shipdate}

• View ranges: {l_partkey, p_partkey} ∈ (150, +∞), {o_custkey} ∈ (50, 500)
• Query ranges: {l_partkey, p_partkey} ∈ (150, 160), {o_custkey} ∈ (123, 123)

• View residual predicate: p_name like ‘%abc%’
• Query residual predicate: p_name like ‘%abc%’, l_quantity*l_extendedprice > 100

1. 哪些数据需要被物化
2. 如何保持原始表与物化表的同步关系
3. 如何进行改写

1. 物化视图如何被定义 & 注册
2. 物化视图改写流程

• SubstitutionVisitor: based on pattern, and bottom-up visit.
• MaterializedViewRule: analyze semantics with relnode, such as SPJA

1. 轻松扩展：可以方便新建一个自定义模式来匹配并使用 mv 重写查询的计划。
2. 支持out join
3. 不止 'SPJA' ：SubstitutionVisitor支持更多模式，如：Sort。

1. 不支持 JOIN 补偿，这在MaterializedViewRule中实现
2. 受join顺序影响，eg：query(a join b), mv(b join a)

protected void registerMaterializations() { // Avoid using materializations while populating materializations! final CalciteConnectionConfig config = context.unwrap(CalciteConnectionConfig.class); if (config == null || !config.materializationsEnabled()) { return; }// Register rels using materialized views. //通过 `SubstitutionVisitor` ，获取可能进行重写的物化视图 final List>> materializationUses = RelOptMaterializations.useMaterializedViews(originalRoot, materializations); for (Pair> use : materializationUses) { RelNode rel = use.left; Hook.SUB.run(rel); registerImpl(rel, root.set); }//通过 table 引用构建的图算法，计算剩余可能被重写的物化视图 // Register table rels of materialized views that cannot find a substitution // in root rel transformation but can potentially be useful. final Set applicableMaterializations = new HashSet<>( RelOptMaterializations.getApplicableMaterializations( originalRoot, materializations)); for (Pair> use : materializationUses) { applicableMaterializations.removeAll(use.right); } for (RelOptMaterialization materialization : applicableMaterializations) { RelSubset subset = registerImpl(materialization.queryRel, null); RelNode tableRel2 = RelOptUtil.createCastRel( materialization.tableRel, materialization.queryRel.getRowType(), true); registerImpl(tableRel2, subset.set); }// Register rels using lattices. //通过 lattices 计算物化视图 final List> latticeUses = RelOptMaterializations.useLattices( originalRoot, ImmutableList.copyOf(latticeByName.values())); if (!latticeUses.isEmpty()) { RelNode rel = latticeUses.get(0).left; Hook.SUB.run(rel); registerImpl(rel, root.set); } }

• 全匹配
• 物化视图的表引用是用户 query 表引用的子集
• 用户 query 表引用是物化视图的表引用的子集

/** * Rewriting logic is based on "Optimizing Queries Using Materialized Views: * A Practical, Scalable Solution" by Goldstein and Larson. * * On the query side, rules matches a Project-node chain or node, where node * is either an Aggregate or a Join. Subplan rooted at the node operator must * be composed of one or more of the following operators: TableScan, Project, * Filter, and Join. * * For each join MV, we need to check the following: *

*
1. The plan rooted at the Join operator in the view produces all rows * needed by the plan rooted at the Join operator in the query.
*
2. All columns required by compensating predicates, i.e., predicates that * need to be enforced over the view, are available at the view output.
*
3. All output expressions can be computed from the output of the view.
*
4. All output rows occur with the correct duplication factor. We might * rely on existing Unique-Key - Foreign-Key relationships to extract that * information.
*

* * In turn, for each aggregate MV, we need to check the following: *

*
1. The plan rooted at the Aggregate operator in the view produces all rows * needed by the plan rooted at the Aggregate operator in the query.
*
2. All columns required by compensating predicates, i.e., predicates that * need to be enforced over the view, are available at the view output.
*
3. The grouping columns in the query are a subset of the grouping columns * in the view.
*
4. All columns required to perform further grouping are available in the * view output.
*
5. All columns required to compute output expressions are available in the * view output.
*

* * The rule contains multiple extensions compared to the original paper. One of * them is the possibility of creating rewritings using Union operators, e.g., if * the result of a query is partially contained in the materialized view. */ protected void perform(RelOptRuleCall call, Project topProject, RelNode node) { final RexBuilder rexBuilder = node.getCluster().getRexBuilder(); final RelMetadataQuery mq = call.getMetadataQuery(); final RelOptPlanner planner = call.getPlanner(); final RexExecutor executor = Util.first(planner.getExecutor(), RexUtil.EXECUTOR); final RelOptPredicateList predicates = RelOptPredicateList.EMPTY; final RexSimplify simplify = new RexSimplify(rexBuilder, predicates, executor); final List materializations = planner.getMaterializations(); //调用 `isValidPlan(topProject, node, mq)`，验证 RelNode 是否满足 rewrite 先觉条件，这个每个 rule 都有不同的实现，比如 join 需要通过 `RelMetadataQuery` 获取 RelNode 的 NodeType。 if (!materializations.isEmpty()) { // 1. Explore query plan to recognize whether preconditions to // try to generate a rewriting are met if (!isValidPlan(topProject, node, mq)) { return; }// 2. Initialize all query related auxiliary data structures // that will be used throughout query rewriting process // Generate query table references //获取所有 table 引用，以便后续各种操作，这一步基本都是通过RelMetadataQuery获取各种信息 final Set queryTableRefs = mq.getTableReferences(node); if (queryTableRefs == null) { // Bail out return; }// Extract query predicates //提取 查询的所有谓词，等价谓词和剩余谓词 final RelOptPredicateList queryPredicateList = mq.getAllPredicates(node); if (queryPredicateList == null) { // Bail out return; final RexNode pred = simplify.simplifyUnknownAsFalse( RexUtil.composeConjunction(rexBuilder, queryPredicateList.pulledUpPredicates)); //将查询两种谓词包装成 RexNode，等价谓词（左）和剩余谓词（右） final Pair queryPreds = splitPredicates(rexBuilder, pred); // Extract query equivalence classes. An equivalence class is a set // of columns in the query output that are known to be equal. //提取 query 的等价类（equivalence class），equivalence class 即 query output 中，已知等价的 columns 的集合 final EquivalenceClasses qEC = new EquivalenceClasses(); //遍历等价谓词，并将等价谓词的列都存起来 for (RexNode conj : RelOptUtil.conjunctions(queryPreds.left)) { assert conj.isA(SqlKind.EQUALS); RexCall equiCond = (RexCall) conj; qEC.addEquivalenceClass( (RexTableInputRef) equiCond.getOperands().get(0), (RexTableInputRef) equiCond.getOperands().get(1)); }// 3. We iterate through all applicable materializations trying to // rewrite the given query //遍历所有给定物化视图，并尝试重写，一个 relnode 可以对应多个 materialization view for (RelOptMaterialization materialization : materializations) { //获取 view 的 RelNode，并提取各种基础信息，比如所有的 RelTableRef RelNode view = materialization.tableRel; Project topViewProject; RelNode viewNode; //materialization.queryRel 表示注册的 MV sql //materialization.tableRel 表示注册的 MV 的 table name relnode //这里找到 topViewProject if (materialization.queryRel instanceof Project) { topViewProject = (Project) materialization.queryRel; viewNode = topViewProject.getInput(); } else { topViewProject = null; viewNode = materialization.queryRel; }// Extract view table references final Set viewTableRefs = mq.getTableReferences(viewNode); if (viewTableRefs == null) { // Skip it continue; }// Filter relevant materializations. Currently, we only check whether // the materialization contains any table that is used by the query //第一个过滤条件，这里只检查 MV 是否包含用户 query 所要的表 // TODO: Filtering of relevant materializations can be improved to be more fine-grained. boolean applicable = false; for (RelTableRef tableRef : viewTableRefs) { if (queryTableRefs.contains(tableRef)) { applicable = true; break; } } if (!applicable) { // Skip it continue; }//跟步骤 1 一样，不过这里对 MV query 进行校验（Valid） // 3.1. View checks before proceeding if (!isValidPlan(topViewProject, viewNode, mq)) { // Skip it continue; }// 3.2. Initialize all query related auxiliary data structures // that will be used throughout query rewriting process // Extract view predicates //跟步骤 2 类似，不过这里获取的是 MV 的各种谓词信息，表达式 final RelOptPredicateList viewPredicateList = mq.getAllPredicates(viewNode); if (viewPredicateList == null) { // Skip it continue; } final RexNode viewPred = simplify.simplifyUnknownAsFalse( RexUtil.composeConjunction(rexBuilder, viewPredicateList.pulledUpPredicates)); //获取 MV 的两种谓词，等价谓词（左）和剩余谓词（右） final Pair viewPreds = splitPredicates(rexBuilder, viewPred); // Extract view tables //用 view 和 query 的所有表进行匹配，有三种匹配结果 //MatchModality.COMPLETE：所有 MV view 的 tables 和 query 的 tables 都一致 //MatchModality.QUERY_PARTIAL：用户查询是 MV 视图的子集 的情况，检查 MV 和 query 是否保持相同的基数，主要是获取所有等价谓词，tableref 等信息，然后 compensatePartial 进行判断 //MatchModality.VIEW_PARTIAL：MV 视图是用户 query 的子集，直接调用compensateViewPartial（不同 rule 有不同实现）进行重写添加缺失的 view，重写成功则更新 view 相关信息，后面再对 view 进行补偿 MatchModality matchModality; Multimap compensationEquiColumns = ArrayListMultimap.create(); if (!queryTableRefs.equals(viewTableRefs)) { //进行补偿 // We try to compensate, e.g., for join queries it might be // possible to join missing tables with view to compute result. // Two supported cases: query tables are subset of view tables (we need to // check whether they are cardinality-preserving joins), or view tables are // subset of query tables (add additional tables through joins if possible) if (viewTableRefs.containsAll(queryTableRefs)) { //通过这个来控制补偿机制 matchModality = MatchModality.QUERY_PARTIAL; //对于用户查询是 MV 视图的子集 的情况，主要是获取所有等价谓词，tableref 等信息，然后 compensatePartial 进行判断 final EquivalenceClasses vEC = new EquivalenceClasses(); for (RexNode conj : RelOptUtil.conjunctions(viewPreds.left)) { assert conj.isA(SqlKind.EQUALS); RexCall equiCond = (RexCall) conj; vEC.addEquivalenceClass( (RexTableInputRef) equiCond.getOperands().get(0), (RexTableInputRef) equiCond.getOperands().get(1)); } //确认 query 是否能够使用 MV view 进行 rewrite if (!compensatePartial(viewTableRefs, vEC, queryTableRefs, compensationEquiColumns)) { // Cannot rewrite, skip it continue; } } else if (queryTableRefs.containsAll(viewTableRefs)) { //若MV 视图是用户 query 的子集，直接调用compensateViewPartial（不同 rule 有不同实现）进行重写 // 重写目标是将 QUery 有但 view 没有的表添加到 view 中，重写成功则更新 view 相关信息，后续会再使用 matchModality = MatchModality.VIEW_PARTIAL; ViewPartialRewriting partialRewritingResult = compensateViewPartial( call.builder(), rexBuilder, mq, view, topProject, node, queryTableRefs, qEC, topViewProject, viewNode, viewTableRefs); if (partialRewritingResult == null) { // Cannot rewrite, skip it continue; } // Rewrite succeeded view = partialRewritingResult.newView; topViewProject = partialRewritingResult.newTopViewProject; viewNode = partialRewritingResult.newViewNode; } else { // Skip it continue; } } else { matchModality = MatchModality.COMPLETE; }// 4. We map every table in the query to a table with the same qualified // name (all query tables are contained in the view, thus this is equivalent // to mapping every table in the query to a view table). //获取 query 中所有具有相等 qualified name 的 RelTableRef，并存储起来final Multimap multiMapTables = ArrayListMultimap.create(); for (RelTableRef queryTableRef1 : queryTableRefs) { for (RelTableRef queryTableRef2 : queryTableRefs) { if (queryTableRef1.getQualifiedName().equals( queryTableRef2.getQualifiedName())) { multiMapTables.put(queryTableRef1, queryTableRef2); } } }// If a table is used multiple times, we will create multiple mappings, // and we will try to rewrite the query using each of the mappings. // Then, we will try to map every source table (query) to a target // table (view), and if we are successful, we will try to create // compensation predicates to filter the view results further // (if needed). // //如果一张表被使用多次，将对该表创建多重映射，并将重写用户 query 使用这些映射。 //然后尝试将 QUERY 的 table 映射到 MV view 的 table。 //如果可以进行映射，那么下一步将填充剩余谓词 final List> flatListMappings = generateTableMappings(multiMapTables); //遍历 query table -> view table 的映射集合 for (BiMap queryToViewTableMapping : flatListMappings) { // TableMapping : mapping query tables -> view tables // 4.0. If compensation equivalence classes exist, we need to add // the mapping to the query mapping //如果存在compensation equivalence（补偿等价类），我们需要将这些加到 query mapping 中 final EquivalenceClasses currQEC = EquivalenceClasses.copy(qEC); if (matchModality == MatchModality.QUERY_PARTIAL) { for (Entry e : compensationEquiColumns.entries()) { // Copy origin RelTableRef queryTableRef = queryToViewTableMapping.inverse().get( e.getKey().getTableRef()); RexTableInputRef queryColumnRef = RexTableInputRef.of(queryTableRef, e.getKey().getIndex(), e.getKey().getType()); // Add to query equivalence classes and table mapping currQEC.addEquivalenceClass(queryColumnRef, e.getValue()); queryToViewTableMapping.put(e.getValue().getTableRef(), e.getValue().getTableRef()); // identity } }// 4.1. Compute compensation predicates, i.e., predicates that need to be // enforced over the view to retain query semantics. The resulting predicates // are expressed using {@link RexTableInputRef} over the query. // First, to establish relationship, we swap column references of the view // predicates to point to query tables and compute equivalence classes. //计算补偿谓词，生成的谓词在查询中使用 {@link RexTableInputRef} 表示。 final RexNode viewColumnsEquiPred = RexUtil.swapTableReferences( rexBuilder, viewPreds.left, queryToViewTableMapping.inverse()); final EquivalenceClasses queryBasedVEC = new EquivalenceClasses(); for (RexNode conj : RelOptUtil.conjunctions(viewColumnsEquiPred)) { assert conj.isA(SqlKind.EQUALS); RexCall equiCond = (RexCall) conj; queryBasedVEC.addEquivalenceClass( (RexTableInputRef) equiCond.getOperands().get(0), (RexTableInputRef) equiCond.getOperands().get(1)); } //计算得到补偿的等价谓词和剩余谓词 // TODO : computeCompensationPredicates 是如果提取补偿谓词的 Pair compensationPreds = computeCompensationPredicates(rexBuilder, simplify, currQEC, queryPreds, queryBasedVEC, viewPreds, queryToViewTableMapping); //若补偿谓词为空，并且允许 union rewrite，那么进行 union 的改写 if (compensationPreds == null && generateUnionRewriting) { // Attempt partial rewriting using union operator. This rewriting // will read some data from the view and the rest of the data from // the query computation. The resulting predicates are expressed // using {@link RexTableInputRef} over the view. //尝试加上 union operator 进行 sql rewrite compensationPreds = computeCompensationPredicates(rexBuilder, simplify, queryBasedVEC, viewPreds, currQEC, queryPreds, queryToViewTableMapping.inverse()); if (compensationPreds == null) { // This was our last chance to use the view, skip it continue; } RexNode compensationColumnsEquiPred = compensationPreds.left; RexNode otherCompensationPred = compensationPreds.right; assert !compensationColumnsEquiPred.isAlwaysTrue() || !otherCompensationPred.isAlwaysTrue(); // b. Generate union branch (query). //进行改写，生成 union branch final RelNode unionInputQuery = rewriteQuery(call.builder(), rexBuilder, simplify, mq, compensationColumnsEquiPred, otherCompensationPred, topProject, node, queryToViewTableMapping, queryBasedVEC, currQEC); if (unionInputQuery == null) { // Skip it continue; }// c. Generate union branch (view). // We trigger the unifying method. This method will either create a Project // or an Aggregate operator on top of the view. It will also compute the // output expressions for the query. final RelNode unionInputView = rewriteView(call.builder(), rexBuilder, simplify, mq, matchModality, true, view, topProject, node, topViewProject, viewNode, queryToViewTableMapping, currQEC); if (unionInputView == null) { // Skip it continue; }// d. Generate final rewriting (union). //分别对 query 和 view 进行 rewrite，最后再处理 final RelNode result = createUnion(call.builder(), rexBuilder, topProject, unionInputQuery, unionInputView); if (result == null) { // Skip it continue; } call.transformTo(result); } else if (compensationPreds != null) { RexNode compensationColumnsEquiPred = compensationPreds.left; RexNode otherCompensationPred = compensationPreds.right; // a. Compute final compensation predicate. //判断等价补偿谓词和剩余补偿谓词，是否都返回 true if (!compensationColumnsEquiPred.isAlwaysTrue() || !otherCompensationPred.isAlwaysTrue()) { // All columns required by compensating predicates must be contained // in the view output (condition 2). // 条件 2 判断，补偿谓词所需的列都在 view 中 // 使用映射的方式，将表引用及对应列引用映射到 View 中，若返回 null 则失败，即改写失败 List viewExprs = topViewProject == null ? extractReferences(rexBuilder, view) : topViewProject.getChildExps(); // For compensationColumnsEquiPred, we use the view equivalence classes, // since we want to enforce the rest //如果等价谓词不总为 TRUE，使用视图等价类，因为要强制执行剩余部分 if (!compensationColumnsEquiPred.isAlwaysTrue()) { //这里 rewrite 的作用，基本上就是把之前 column 的映射再转回来 compensationColumnsEquiPred = rewriteExpression(rexBuilder, mq, view, viewNode, viewExprs, queryToViewTableMapping.inverse(), queryBasedVEC, false, compensationColumnsEquiPred); if (compensationColumnsEquiPred == null) { // Skip it continue; } } // For the rest, we use the query equivalence classes //对于剩余谓词，使用 query 等价类 if (!otherCompensationPred.isAlwaysTrue()) { otherCompensationPred = rewriteExpression(rexBuilder, mq, view, viewNode, viewExprs, queryToViewTableMapping.inverse(), currQEC, true, otherCompensationPred); if (otherCompensationPred == null) { // Skip it continue; } } } // 合并补偿的等价谓词和剩余谓词，获得最终需要在 view 上面执行的剩余谓词 final RexNode viewCompensationPred = RexUtil.composeConjunction(rexBuilder, ImmutableList.of(compensationColumnsEquiPred, otherCompensationPred)); // b. Generate final rewriting if possible. // First, we add the compensation predicate (if any) on top of the view. // Then, we trigger the unifying method. This method will either create a // Project or an Aggregate operator on top of the view. It will also compute // the output expressions for the query. //生成最终重写， //1. 添加补偿谓词到 view //2. 调用统一方法，生成一个 project 或一个 Aggregate operator on top of view。 RelBuilder builder = call.builder().transform(c -> c.withPruneInputOfAggregate(false)); RelNode viewWithFilter; // 如果最终的补偿谓词并非总是 true，生成 viewWithFilter 的时候需要加上 FIlter if (!viewCompensationPred.isAlwaysTrue()) { RexNode newPred = simplify.simplifyUnknownAsFalse(viewCompensationPred); viewWithFilter = builder.push(view).filter(newPred).build(); // No need to do anything if it's a leaf node. if (viewWithFilter.getInputs().isEmpty()) { call.transformTo(viewWithFilter); return; } // We add (and push) the filter to the view plan before triggering the rewriting. // This is useful in case some of the columns can be folded to same value after // filter is added. // 触发重写前，添加 filter 并 PUSH 到 view plan。 Pair pushedNodes = pushFilterToOriginalViewPlan(builder, topViewProject, viewNode, newPred); topViewProject = (Project) pushedNodes.left; viewNode = pushedNodes.right; } else { //如果 filter 总是 TRUE ，那么只需要生成 view viewWithFilter = builder.push(view).build(); } //进行重写，生成最终的 view //这里 Agg 和 Join rule 都有自己的实现，主要看 join final RelNode result = rewriteView(builder, rexBuilder, simplify, mq, matchModality, false, viewWithFilter, topProject, node, topViewProject, viewNode, queryToViewTableMapping, currQEC); if (result == null) { // Skip it continue; } call.transformTo(result); } // end else } } } }

• Aggregate 或 Join 类型的 sql ，其子查询节点的 root ，必须为以下几种：TableScan, Project, Filter, and Join，且仅支持 inner join 类型的 sql。

1. MV 的 logical plan 中 join operator ，需包含所有 query 中，join operator 需要的所有数据。
2. 拥有补偿谓词所需的列
3. 所有的输出表达式都可以从视图的输出中计算出来。
4. 所有输出行都以正确的重复因子出现。

1. MV 的 logical plan 中 Aggregate operator ，需包含所有 query Aggregate operator 需要的所有数据。
2. 拥有补偿谓词所需的列
3. 查询中的分组列是视图中分组列的子集。
4. 视图输出中提供了进一步分组所需的所有列。
5. 视图输出中提供了计算输出表达式所需的所有列。

等价类：EquivalenceClasses：a set of equivalent columns

1. 调用 isValidPlan(topProject, node, mq)，验证 RelNode 是否满足 rewrite 先决定条件，这个join 和 Aggregate rule 都有不同的实现，比如 join 仅支持 relnode 节点类型：TableScan - Project - Filter - Inner Join。
2. 通过 RelMetadataQuery，生成 sql rewrite 过程中，所需要的一些辅助数据（所有 table 表引用等）。提取用户 query 的谓词条件，分为两部分：等价谓词，剩余谓词。表引用，表达式（常量表达式，函数等）等等。
3. 构建等价类EquivalenceClasses，等价类是从等价谓词中提取的 columns 集合

1. 首先，和 query 一样，获取物化视图的基本信息，校验，构建等价类。
   
2. 尝试计算补偿谓词，若不能则跳过视图，根据 query 和 MV 物化视图的 table 表引用数量，分三种情况。
   
   1. MatchModality.COMPLETE：所有 MV view 的 tables 和 query 的 tables 都一致，什么都不做。
   2. MatchModality.QUERY_PARTIAL：用户查询 表引用是 MV 视图的子集 的情况，检查 MV 和 query 是否保持相同的基数（join 的情况），主要是获取所有等价谓词，tableref 等信息，然后 compensatePartial 进行判断是否物化视图能进行 review。即最上面介绍的特殊 case，需要根据唯一健，外健等约束进行判断。
   3. MatchModality.VIEW_PARTIAL：MV 视图表引用是用户 query 的子集，会调用compensateViewPartial（不同 rule 有不同实现）检测业务 query 能否使用 view 进行重写，可以的话会将 Query 中多出来的表（若存在谓词那便添加这些补偿谓词）添加到 view 中并新生成一个物化视图（初步改写）。
3. 经过上述步骤，可以认定 Query 和 View 具有相同的表引用关系（或 view 有多的表引用但不影响）。
   
4. 开始计算补偿谓词，需要在视图 view 上执行补偿谓词以保证 query 语义。
   
   1. 创建 query 表引用 -> view 表引用的映射集合List>。
   2. 物化视图的等价谓词，交换 view column 指向的 TABLE 为 QUERY 的 table ，然后再计算等价类。调用 computeCompensationPredicates 计算补偿谓词，包括等价补偿谓词和剩余补偿谓词。交换 view 的表引用，是为了方便判断：视图 view 的查询条件都为 query 条件的子集。如果 view 条件不为 query 的子集，补偿谓词为空。
   3. 若计算得到的补偿谓词为空并且允许 union 重写，则进行 union 重写（最开始 union 类型是不支持改写的，这里是 calcite 的扩展。这部分先忽略。）
   4. 先进行优化，如果补偿谓词条件用 AND 相连后，结果总为 true ，类似 where 1=1，那么省略部分操作，生成新的 view。
   5. 否则进行判断，All columns required by compensating predicates must be contained in the view output（条件二） 。具体做法是将补偿谓词的列进行映射。
   6. 生成 view ，并将补偿谓词信息加到这个 view 中，调用统一方法，生成一个 project 或一个 Aggregate operator on top of view。最后再调用 rewriteView （不同 join 有不同实现）生成最终重写后的 relnode，再将新的 relnode 注册。等待后续 CBO 进一步优化。

推荐阅读

• 

  五味
• 

  激光能去除肥胖纹吗视频 激光能去除肥胖纹吗
• 

  原味烤肉制作方法 原味烤肉的制作方法
• 

  房间里面有老鼠怎么办
• 

  有没有好点收益高的副业项目？
• 

  年收入是指纯收入，年收入是什么意思
• 

  松下洗衣机烘干为什么出水,首先原因要搞清
• 

  读地图分析,如何读地图获取信息
• 

  3d|2千档高质价比手机推荐：骁龙870+三星屏+65W，真我真牛
• 

  刑事自诉案件的范围是什么
• 

  生理盐水洗鼻子可以预防新冠肺炎吗
• 

  胚芽燕麦粥
• 

  辰辉的寓意
• 

  健康工作远离疼痛现在要坐好
• 

  被子晒多久比较好
• 

  头孢料酒会有反应吗
• 

  鹌鹑鸟怎么养 鹌鹑鸟如何饲养
• 

  人成长分为哪些阶段
• 

  如何鉴别建兰国魂真假 如何鉴别建兰国魂真假
• 

  回归模型结果分析方法,ABC态度模型分析方法和运用

• ASP.NET|ASP.NET MVC中Controller控制器向View视图传值的几种方式
• petite-vue源码剖析-从静态视图开始
• mysql视图，索引
• tableView|tableView 头视图下拉放大 重写
• mysql中视图事务索引与权限管理
• （2018-05-12.Python从Zero到One）6、（Django）Django视图__1.3.2定义视图
• mysql视图简介与使用
• SAP|SAP UI5 初学者教程之十四 - 嵌入视图的使用方式试读版
• drf|drf 的几个组件
• View视图跟随手指移动