From e35b66b27e22ee98083e044e91fb808c125c71e2 Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Tue, 23 Feb 2021 10:52:09 +0100
Subject: [PATCH] [jOOQ/jOOQ#11502] Unknown table identifier when trying to
 look up CustomTable or TableImpl whose Schema doesn't reference its tables

---
 .../java/org/jooq/impl/AbstractNamed.java     |  6 ++
 .../java/org/jooq/impl/CatalogMetaImpl.java   | 58 ++++++++++---------
 2 files changed, 38 insertions(+), 26 deletions(-)

diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractNamed.java b/jOOQ/src/main/java/org/jooq/impl/AbstractNamed.java
index 36d7fd1596..34baa8b3e1 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractNamed.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractNamed.java
@@ -38,6 +38,8 @@
 
 package org.jooq.impl;
 
+import static org.jooq.impl.AbstractName.NO_NAME;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -122,6 +124,10 @@ abstract class AbstractNamed extends AbstractQueryPart implements Named {
     // Utilities
     // -------------------------------------------------------------------------
 
+    static final Name nameOrDefault(Named named) {
+        return named == null ? NO_NAME : named.getQualifiedName();
+    }
+
     static final Name qualify(Named qualifier, Name name) {
         // [#9820] [#11292] name == null || name.empty() are special cases that
         //                  may appear when using unnamed constraint declarations.
diff --git a/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java
index 077cb9980e..305e280160 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java
@@ -37,18 +37,22 @@
  */
 package org.jooq.impl;
 
+import static org.jooq.impl.AbstractNamed.nameOrDefault;
 import static org.jooq.impl.Tools.EMPTY_CATALOG;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.Predicate;
 
 import org.jooq.Catalog;
 import org.jooq.Configuration;
 import org.jooq.Meta;
+import org.jooq.Name;
 import org.jooq.QueryPart;
 import org.jooq.Schema;
 import org.jooq.Table;
@@ -74,7 +78,7 @@ final class CatalogMetaImpl extends AbstractMeta {
     }
 
     static final Meta filterCatalogs(Configuration configuration, Catalog[] catalogs) {
-        return filterCatalogs0(configuration, catalogs, new HashSet<>(Arrays.asList(catalogs)));
+        return filterCatalogs0(configuration, catalogs, new LinkedHashSet<>(Arrays.asList(catalogs)));
     }
 
     static final Meta filterCatalogs(Configuration configuration, Set<Catalog> catalogs) {
@@ -86,45 +90,47 @@ final class CatalogMetaImpl extends AbstractMeta {
     }
 
     static final Meta filterSchemas(Configuration configuration, Schema[] schemas) {
-        return filterSchemas(configuration, new HashSet<>(Arrays.asList(schemas)));
+        return filterSchemas(configuration, new LinkedHashSet<>(Arrays.asList(schemas)));
     }
 
     static final Meta filterSchemas(Configuration configuration, Set<Schema> schemas) {
+        Map<Name, Catalog> c = new LinkedHashMap<>();
+        Map<Name, List<Schema>> mapping = new LinkedHashMap<>();
 
-        // TODO: Some schemas may belong to another catalog
-        Catalog defaultCatalog = new CatalogImpl("") {
-            @Override
-            public List<Schema> getSchemas() {
-                return new ArrayList<>(schemas);
-            }
-        };
-
-        Set<Catalog> c = new HashSet<>();
         for (Schema schema : schemas)
-            c.add(schema.getCatalog() != null ? schema.getCatalog() : defaultCatalog);
+            mapping.computeIfAbsent(nameOrDefault(schema.getCatalog()), k -> new ArrayList<>()).add(schema);
 
-        return filterCatalogs(configuration, c).filterSchemas(schemas::contains);
+        for (Schema schema : schemas)
+            c.computeIfAbsent(nameOrDefault(schema.getCatalog()), k -> new CatalogImpl(k) {
+                @Override
+                public List<Schema> getSchemas() {
+                    return mapping.get(getQualifiedName());
+                }
+            });
+
+        return filterCatalogs(configuration, new LinkedHashSet<>(c.values())).filterSchemas(schemas::contains);
     }
 
     static final Meta filterTables(Configuration configuration, Table<?>[] tables) {
-        return filterTables(configuration, new HashSet<>(Arrays.asList(tables)));
+        return filterTables(configuration, new LinkedHashSet<>(Arrays.asList(tables)));
     }
 
     static final Meta filterTables(Configuration configuration, Set<Table<?>> tables) {
+        Map<Name, Schema> s = new LinkedHashMap<>();
+        Map<Name, List<Table<?>>> mapping = new LinkedHashMap<>();
 
-        // TODO: Some tables may belong to another schema
-        Schema defaultSchema = new SchemaImpl("") {
-            @Override
-            public List<Table<?>> getTables() {
-                return new ArrayList<>(tables);
-            }
-        };
-
-        Set<Schema> s = new HashSet<>();
         for (Table<?> table : tables)
-            s.add(table.getSchema() != null ? table.getSchema() : defaultSchema);
+            mapping.computeIfAbsent(nameOrDefault(table.getSchema()), k -> new ArrayList<>()).add(table);
 
-        return filterSchemas(configuration, s)
+        for (Table<?> table : tables)
+            s.computeIfAbsent(nameOrDefault(table.getSchema()), k -> new SchemaImpl(k, table.getCatalog()) {
+                @Override
+                public List<Table<?>> getTables() {
+                    return mapping.get(getQualifiedName());
+                }
+            });
+
+        return filterSchemas(configuration, new LinkedHashSet<>(s.values()))
               .filterTables(tables::contains)
               .filterSequences(none())
               .filterDomains(none())