Please address the comments from this code review:

## Overall Comments
- In `resolveTableName`, you strip the catalog and always return a `Table` with only `schema.table`; if the original relation was catalog-qualified, this could break matching for multi-catalog setups—consider preserving the catalog component in the returned `QualifiedName`.
- The `resolveTableName` helper only handles `Table` instances; since `visitRelation` is called on a generic `Relation`, it may be safer to either enforce/validate that only `Table` nodes reach this code path or to handle/warn on other `Relation` subtypes explicitly to avoid surprising behavior.

## Individual Comments

### Comment 1
<location> `presto-main-base/src/test/java/com/facebook/presto/sql/analyzer/TestMaterializedViewQueryOptimizer.java:453-454` </location>
<code_context>
         assertOptimizedQuery(baseQuerySqlWithTablePrefix, expectedRewrittenSql, originalViewSqlWithTablePrefix, BASE_TABLE_1, VIEW_1);
     }

+    @Test
+    public void testWithSchemaQualifiedTableName()
+    {
+        String schemaQualifiedTable = SESSION_SCHEMA + "." + BASE_TABLE_1;
</code_context>

<issue_to_address>
**suggestion (testing):** Add negative tests for mismatching schemas/table names to prove we don’t rewrite when we shouldn’t

To make the optimizer behavior more robustly tested, please add one or two negative cases where the schema-qualified name resolves to a *different* table than the MV base table (e.g., `SESSION_SCHEMA.other_table` or `other_schema.base_table`). These should assert that the MV rewrite does not occur (or that the correct exception path is taken), ensuring the new `resolveTableName` logic does not over-match tables.

Suggested implementation:

```java
    @Test
    public void testWithSchemaQualifiedTableName()
    {
        String schemaQualifiedTable = SESSION_SCHEMA + "." + BASE_TABLE_1;

        String originalViewSql = format("SELECT a, b FROM %s", BASE_TABLE_1);
        String baseQuerySql = format("SELECT a, b FROM %s", schemaQualifiedTable);
        String expectedRewrittenSql = format("SELECT a, b FROM %s", VIEW_1);

        assertOptimizedQuery(baseQuerySql, expectedRewrittenSql, originalViewSql, BASE_TABLE_1, VIEW_1);

        originalViewSql = format("SELECT a, b FROM %s", schemaQualifiedTable);
        baseQuerySql = format("SELECT a, b FROM %s", BASE_TABLE_1);
        expectedRewrittenSql = format("SELECT a, b FROM %s", VIEW_1);

        assertOptimizedQuery(baseQuerySql, expectedRewrittenSql, originalViewSql, BASE_TABLE_1, VIEW_1);
    }

    @Test
    public void testWithSchemaQualifiedTableNameMismatchingTable()
    {
        // MV is defined over BASE_TABLE_1; query uses a different table in the same schema
        String schemaQualifiedOtherTable = SESSION_SCHEMA + "." + BASE_TABLE_2;

        String originalViewSql = format("SELECT a, b FROM %s", BASE_TABLE_1);
        String baseQuerySql = format("SELECT a, b FROM %s", schemaQualifiedOtherTable);

        // Verify that a different table name in the same schema does NOT trigger a rewrite
        assertNotOptimizedQuery(baseQuerySql, originalViewSql, BASE_TABLE_1, VIEW_1);
    }

    @Test
    public void testWithSchemaQualifiedTableNameMismatchingSchema()
    {
        // MV is defined over SESSION_SCHEMA.BASE_TABLE_1; query uses the same table name in a different schema
        String otherSchemaQualifiedTable = "other_schema." + BASE_TABLE_1;

        String originalViewSql = format("SELECT a, b FROM %s", SESSION_SCHEMA + "." + BASE_TABLE_1);
        String baseQuerySql = format("SELECT a, b FROM %s", otherSchemaQualifiedTable);

        // Verify that a different schema for the same table name does NOT trigger a rewrite
        assertNotOptimizedQuery(baseQuerySql, originalViewSql, BASE_TABLE_1, VIEW_1);

```

To fully wire these tests into the existing test harness, you will also need to:
1. Ensure there is a `BASE_TABLE_2` constant defined in this test class (or adjust `testWithSchemaQualifiedTableNameMismatchingTable` to use whatever second base-table constant already exists).
2. Implement or reuse an assertion helper like `assertNotOptimizedQuery(String baseQuerySql, String originalViewSql, String baseTable, String viewName)` that:
   - Runs the materialized view optimizer on `baseQuerySql` given the provided MV definition (`originalViewSql`, `baseTable`, `viewName`).
   - Asserts that either:
     a) The optimized query text is identical to `baseQuerySql` (no rewrite occurred), or  
     b) The optimizer throws the expected exception for non-rewritable queries (if that is the intended behavior).
3. If such a helper already exists under a different name/signature (e.g., `assertNoRewrite`, `assertNotRewrittenQuery`, etc.), replace `assertNotOptimizedQuery(...)` calls with the appropriate existing helper and adjust the arguments accordingly.
</issue_to_address>