From 85c137d699a2786932366eb68f5482fb5dd35454 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Wed, 18 Sep 2024 14:34:02 +0200 Subject: [PATCH] [jOOQ/jOOQ#17259] Meta::filterCatalogs is applied too late for internal MetaImpl queries executed by Meta::ddl --- .../main/java/org/jooq/impl/AbstractMeta.java | 296 +++++++++++------- .../java/org/jooq/impl/CatalogMetaImpl.java | 5 + .../main/java/org/jooq/impl/FilteredMeta.java | 58 ++-- .../jooq/impl/InformationSchemaMetaImpl.java | 6 + .../main/java/org/jooq/impl/Interpreter.java | 6 + .../src/main/java/org/jooq/impl/MetaImpl.java | 30 +- .../src/main/java/org/jooq/impl/Snapshot.java | 6 + .../java/org/jooq/impl/TableMetaImpl.java | 6 + 8 files changed, 267 insertions(+), 146 deletions(-) diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java b/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java index f15b89d19a..7f6359cf0d 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java @@ -38,7 +38,6 @@ package org.jooq.impl; import static org.jooq.impl.DSL.name; -import static org.jooq.impl.Tools.findAny; import static org.jooq.impl.Tools.flatMap; import static org.jooq.impl.Tools.map; @@ -80,31 +79,33 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable // [#9010] TODO: Allow for opting out of this cache private Map cachedCatalogs; - private Map cachedQualifiedSchemas; - private Map> cachedQualifiedTables; - private Map> cachedQualifiedDomains; - private Map> cachedQualifiedSequences; - private Map> cachedQualifiedPrimaryKeys; - private Map> cachedQualifiedUniqueKeys; - private Map> cachedQualifiedForeignKeys; - private Map cachedQualifiedIndexes; - private Map> cachedUnqualifiedSchemas; - private Map>> cachedUnqualifiedTables; - private Map>> cachedUnqualifiedDomains; - private Map>> cachedUnqualifiedSequences; - private Map>> cachedUnqualifiedPrimaryKeys; - private Map>> cachedUnqualifiedUniqueKeys; - private Map>> cachedUnqualifiedForeignKeys; - private Map> cachedUnqualifiedIndexes; - + private Cached cachedSchemas; + private Cached> cachedTables; + private Cached> cachedDomains; + private Cached> cachedSequences; + private Cached> cachedPrimaryKeys; + private Cached> cachedUniqueKeys; + private Cached> cachedForeignKeys; + private Cached cachedIndexes; + final Predicate catalogFilter; + final Predicate schemaFilter; AbstractMeta(Configuration configuration) { - super(configuration); + this(configuration, null, null); } + AbstractMeta(Configuration configuration, Predicate catalogFilter, Predicate schemaFilter) { + super(configuration); + + this.catalogFilter = catalogFilter; + this.schemaFilter = schemaFilter; + } + + abstract AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter); + @Override public final Catalog getCatalog(String name) { return getCatalog(name(name)); @@ -112,27 +113,62 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final Catalog getCatalog(Name name) { - initCatalogs(); - return cachedCatalogs.get(name); + return getCachedCatalogs().get(name); } @Override public final List getCatalogs() { - initCatalogs(); - return Collections.unmodifiableList(new ArrayList<>(cachedCatalogs.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedCatalogs().values())); } - private final void initCatalogs() { - if (cachedCatalogs == null) { - cachedCatalogs = new LinkedHashMap<>(); + private final Map getCachedCatalogs() { + Map c = cachedCatalogs; + + if (c == null) { + c = new LinkedHashMap<>(); for (Catalog catalog : getCatalogs0()) - cachedCatalogs.put(catalog.getQualifiedName(), catalog); + c.put(catalog.getQualifiedName(), catalog); } + + if (caching()) + cachedCatalogs = c; + + return c; } abstract List getCatalogs0(); + private static final record Cached(Map qualified, Map> unqualified) { + Cached() { + this(new LinkedHashMap<>(), new LinkedHashMap<>()); + } + + final void init(Iterable i) { + if (qualified().isEmpty()) { + for (N object : i) { + Name q = object.getQualifiedName(); + Name u = object.getUnqualifiedName(); + + qualified().put(q, object); + unqualified().computeIfAbsent(u, n -> new ArrayList<>()).add(object); + } + } + } + + final List get(Name name) { + N object = qualified().get(name); + if (object != null) + return Collections.singletonList(object); + + List list = unqualified().get(name); + if (list == null) + return Collections.emptyList(); + else + return Collections.unmodifiableList(list); + } + } + @Override public final List getSchemas(String name) { return getSchemas(name(name)); @@ -140,22 +176,29 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List getSchemas(Name name) { - initSchemas(); - return get(name, () -> getSchemas0().iterator(), cachedQualifiedSchemas, cachedUnqualifiedSchemas); + return getCachedSchemas().get(name); } @Override public final List getSchemas() { - initSchemas(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedSchemas.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedSchemas().qualified().values())); } - private final void initSchemas() { - if (cachedQualifiedSchemas == null) { - cachedQualifiedSchemas = new LinkedHashMap<>(); - cachedUnqualifiedSchemas = new LinkedHashMap<>(); - get(name(""), () -> getSchemas0().iterator(), cachedQualifiedSchemas, cachedUnqualifiedSchemas); + private final Cached getCachedSchemas() { + Cached s = cachedSchemas; + + if (s == null) { + s = new Cached<>(); + s.init(schemaFilter != null + ? () -> Tools.filter(getSchemas0().iterator(), schemaFilter) + : () -> getSchemas0().iterator() + ); } + + if (caching()) + cachedSchemas = s; + + return s; } List getSchemas0() { @@ -169,22 +212,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getTables(Name name) { - initTables(); - return get(name, () -> getTables().iterator(), cachedQualifiedTables, cachedUnqualifiedTables); + return getCachedTables().get(name); } @Override public final List> getTables() { - initTables(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedTables.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedTables().qualified().values())); } - private final void initTables() { - if (cachedQualifiedTables == null) { - cachedQualifiedTables = new LinkedHashMap<>(); - cachedUnqualifiedTables = new LinkedHashMap<>(); - get(name(""), () -> getTables0().iterator(), cachedQualifiedTables, cachedUnqualifiedTables); + private final Cached> getCachedTables() { + Cached> t = cachedTables; + + if (t == null) { + t = new Cached<>(); + t.init(() -> getTables0().iterator()); } + + if (caching()) + cachedTables = t; + + return t; } List> getTables0() { @@ -198,22 +245,27 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getDomains(Name name) { - initDomains(); - return get(name, () -> getDomains().iterator(), cachedQualifiedDomains, cachedUnqualifiedDomains); + return getCachedDomains().get(name); } @Override public final List> getDomains() { - initDomains(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedDomains.values())); + getCachedDomains(); + return Collections.unmodifiableList(new ArrayList<>(getCachedDomains().qualified().values())); } - private final void initDomains() { - if (cachedQualifiedDomains == null) { - cachedQualifiedDomains = new LinkedHashMap<>(); - cachedUnqualifiedDomains = new LinkedHashMap<>(); - get(name(""), () -> getDomains0().iterator(), cachedQualifiedDomains, cachedUnqualifiedDomains); + private final Cached> getCachedDomains() { + Cached> d = cachedDomains; + + if (d == null) { + d = new Cached<>(); + d.init(() -> getDomains0().iterator()); } + + if (caching()) + cachedDomains = d; + + return d; } List> getDomains0() { @@ -248,6 +300,10 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable + + + + @@ -260,22 +316,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getSequences(Name name) { - initSequences(); - return get(name, () -> getSequences().iterator(), cachedQualifiedSequences, cachedUnqualifiedSequences); + return getCachedSequences().get(name); } @Override public final List> getSequences() { - initSequences(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedSequences.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedSequences().qualified().values())); } - private final void initSequences() { - if (cachedQualifiedSequences == null) { - cachedQualifiedSequences = new LinkedHashMap<>(); - cachedUnqualifiedSequences = new LinkedHashMap<>(); - get(name(""), () -> getSequences0().iterator(), cachedQualifiedSequences, cachedUnqualifiedSequences); + private final Cached> getCachedSequences() { + Cached> s = cachedSequences; + + if (s == null) { + s = new Cached<>(); + s.init(() -> getSequences0().iterator()); } + + if (caching()) + cachedSequences = s; + + return s; } final List> getSequences0() { @@ -289,22 +349,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getPrimaryKeys(Name name) { - initPrimaryKeys(); - return get(name, () -> getPrimaryKeys().iterator(), cachedQualifiedPrimaryKeys, cachedUnqualifiedPrimaryKeys); + return getCachedPrimaryKeys().get(name); } @Override public final List> getPrimaryKeys() { - initPrimaryKeys(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedPrimaryKeys.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedPrimaryKeys().qualified().values())); } - private final void initPrimaryKeys() { - if (cachedQualifiedPrimaryKeys == null) { - cachedQualifiedPrimaryKeys = new LinkedHashMap<>(); - cachedUnqualifiedPrimaryKeys = new LinkedHashMap<>(); - get(name(""), () -> getPrimaryKeys0().iterator(), cachedQualifiedPrimaryKeys, cachedUnqualifiedPrimaryKeys); + private final Cached> getCachedPrimaryKeys() { + Cached> k = cachedPrimaryKeys; + + if (k == null) { + k = new Cached<>(); + k.init(() -> getPrimaryKeys0().iterator()); } + + if (caching()) + cachedPrimaryKeys = k; + + return k; } List> getPrimaryKeys0() { @@ -324,22 +388,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getUniqueKeys(Name name) { - initUniqueKeys(); - return get(name, () -> getUniqueKeys().iterator(), cachedQualifiedUniqueKeys, cachedUnqualifiedUniqueKeys); + return getCachedUniqueKeys().get(name); } @Override public final List> getUniqueKeys() { - initUniqueKeys(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedUniqueKeys.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedUniqueKeys().qualified().values())); } - private final void initUniqueKeys() { - if (cachedQualifiedUniqueKeys == null) { - cachedQualifiedUniqueKeys = new LinkedHashMap<>(); - cachedUnqualifiedUniqueKeys = new LinkedHashMap<>(); - get(name(""), () -> getUniqueKeys0().iterator(), cachedQualifiedUniqueKeys, cachedUnqualifiedUniqueKeys); + private final Cached> getCachedUniqueKeys() { + Cached> k = cachedUniqueKeys; + + if (k == null) { + k = new Cached<>(); + k.init(() -> getUniqueKeys0().iterator()); } + + if (caching()) + cachedUniqueKeys = k; + + return k; } List> getUniqueKeys0() { @@ -353,22 +421,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List> getForeignKeys(Name name) { - initForeignKeys(); - return get(name, () -> getForeignKeys().iterator(), cachedQualifiedForeignKeys, cachedUnqualifiedForeignKeys); + return getCachedForeignKeys().get(name); } @Override public final List> getForeignKeys() { - initForeignKeys(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedForeignKeys.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedForeignKeys().qualified().values())); } - private final void initForeignKeys() { - if (cachedQualifiedForeignKeys == null) { - cachedQualifiedForeignKeys = new LinkedHashMap<>(); - cachedUnqualifiedForeignKeys = new LinkedHashMap<>(); - get(name(""), () -> getForeignKeys0().iterator(), cachedQualifiedForeignKeys, cachedUnqualifiedForeignKeys); + private final Cached> getCachedForeignKeys() { + Cached> k = cachedForeignKeys; + + if (k == null) { + k = new Cached<>(); + k.init(() -> getForeignKeys0().iterator()); } + + if (caching()) + cachedForeignKeys = k; + + return k; } List> getForeignKeys0() { @@ -382,48 +454,34 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable @Override public final List getIndexes(Name name) { - initIndexes(); - return get(name, () -> getIndexes().iterator(), cachedQualifiedIndexes, cachedUnqualifiedIndexes); + return getCachedIndexes().get(name); } @Override public final List getIndexes() { - initIndexes(); - return Collections.unmodifiableList(new ArrayList<>(cachedQualifiedIndexes.values())); + return Collections.unmodifiableList(new ArrayList<>(getCachedIndexes().qualified().values())); } - private final void initIndexes() { - if (cachedQualifiedIndexes == null) { - cachedQualifiedIndexes = new LinkedHashMap<>(); - cachedUnqualifiedIndexes = new LinkedHashMap<>(); - get(name(""), () -> getIndexes0().iterator(), cachedQualifiedIndexes, cachedUnqualifiedIndexes); + private final Cached getCachedIndexes() { + Cached i = cachedIndexes; + + if (i == null) { + i = new Cached<>(); + i.init(() -> getIndexes0().iterator()); } + + if (caching()) + cachedIndexes = i; + + return i; } List getIndexes0() { return flatMap(getTables(), t -> t.getIndexes()); } - private final List get(Name name, Iterable i, Map qualified, Map> unqualified) { - if (qualified.isEmpty()) { - for (T object : i) { - Name q = object.getQualifiedName(); - Name u = object.getUnqualifiedName(); - - qualified.put(q, object); - unqualified.computeIfAbsent(u, n -> new ArrayList<>()).add(object); - } - } - - T object = qualified.get(name); - if (object != null) - return Collections.singletonList(object); - - List list = unqualified.get(name); - if (list == null) - return Collections.emptyList(); - else - return Collections.unmodifiableList(list); + private boolean caching() { + return true; } @Override diff --git a/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java index 3f43d11303..566983eaff 100644 --- a/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java @@ -70,6 +70,11 @@ final class CatalogMetaImpl extends AbstractMeta { this.catalogs = catalogs; } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return this; + } + @Override final List getCatalogs0() { return Arrays.asList(catalogs); diff --git a/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java b/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java index ce6bc4cf3a..ef5587ed29 100644 --- a/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java +++ b/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java @@ -70,8 +70,6 @@ import org.jooq.UniqueKey; final class FilteredMeta extends AbstractMeta { private final AbstractMeta meta; - private final Predicate catalogFilter; - private final Predicate schemaFilter; private final Predicate> tableFilter; private final Predicate> domainFilter; @@ -98,11 +96,9 @@ final class FilteredMeta extends AbstractMeta { Predicate> foreignKeyFilter, Predicate indexFilter ) { - super(meta.configuration()); + super(meta.configuration(), catalogFilter, schemaFilter); - this.meta = meta; - this.catalogFilter = catalogFilter; - this.schemaFilter = schemaFilter; + this.meta = meta.filtered0(catalogFilter, schemaFilter); this.tableFilter = tableFilter; this.domainFilter = domainFilter; @@ -115,6 +111,11 @@ final class FilteredMeta extends AbstractMeta { this.indexFilter = indexFilter; } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return filterCatalogs(catalogFilter).filterSchemas(schemaFilter); + } + @Override final List getCatalogs0() { List result = new ArrayList<>(); @@ -127,10 +128,10 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterCatalogs(Predicate filter) { + public final FilteredMeta filterCatalogs(Predicate filter) { return new FilteredMeta( meta, - catalogFilter != null ? new And<>(catalogFilter, filter) : filter, + and(catalogFilter, filter), schemaFilter, tableFilter, domainFilter, @@ -146,11 +147,11 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterSchemas(Predicate filter) { + public final FilteredMeta filterSchemas(Predicate filter) { return new FilteredMeta( meta, catalogFilter, - schemaFilter != null ? new And<>(schemaFilter, filter) : filter, + and(schemaFilter, filter), tableFilter, domainFilter, @@ -165,12 +166,12 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterTables(Predicate> filter) { + public final FilteredMeta filterTables(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, schemaFilter, - tableFilter != null ? new And<>(tableFilter, filter) : filter, + and(tableFilter, filter), domainFilter, @@ -184,13 +185,13 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterDomains(Predicate> filter) { + public final FilteredMeta filterDomains(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, schemaFilter, tableFilter, - domainFilter != null ? new And<>(domainFilter, filter) : filter, + and(domainFilter, filter), @@ -224,7 +225,7 @@ final class FilteredMeta extends AbstractMeta { @Override - public final Meta filterSequences(Predicate> filter) { + public final FilteredMeta filterSequences(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, @@ -234,7 +235,7 @@ final class FilteredMeta extends AbstractMeta { - sequenceFilter != null ? new And<>(sequenceFilter, filter) : filter, + and(sequenceFilter, filter), primaryKeyFilter, uniqueKeyFilter, foreignKeyFilter, @@ -243,7 +244,7 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterPrimaryKeys(Predicate> filter) { + public final FilteredMeta filterPrimaryKeys(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, @@ -254,7 +255,7 @@ final class FilteredMeta extends AbstractMeta { sequenceFilter, - primaryKeyFilter != null ? new And<>(primaryKeyFilter, filter) : filter, + and(primaryKeyFilter, filter), uniqueKeyFilter, foreignKeyFilter, indexFilter @@ -262,7 +263,7 @@ final class FilteredMeta extends AbstractMeta { } @Override - public final Meta filterUniqueKeys(Predicate> filter) { + public final FilteredMeta filterUniqueKeys(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, @@ -274,14 +275,14 @@ final class FilteredMeta extends AbstractMeta { sequenceFilter, primaryKeyFilter, - uniqueKeyFilter != null ? new And<>(uniqueKeyFilter, filter) : filter, + and(uniqueKeyFilter, filter), foreignKeyFilter, indexFilter ); } @Override - public final Meta filterForeignKeys(Predicate> filter) { + public final FilteredMeta filterForeignKeys(Predicate> filter) { return new FilteredMeta( meta, catalogFilter, @@ -294,13 +295,13 @@ final class FilteredMeta extends AbstractMeta { sequenceFilter, primaryKeyFilter, uniqueKeyFilter, - foreignKeyFilter != null ? new And<>(foreignKeyFilter, filter) : filter, + and(foreignKeyFilter, filter), indexFilter ); } @Override - public final Meta filterIndexes(Predicate filter) { + public final FilteredMeta filterIndexes(Predicate filter) { return new FilteredMeta( meta, catalogFilter, @@ -314,7 +315,7 @@ final class FilteredMeta extends AbstractMeta { primaryKeyFilter, uniqueKeyFilter, foreignKeyFilter, - indexFilter != null ? new And<>(indexFilter, filter) : filter + and(indexFilter, filter) ); } @@ -333,6 +334,15 @@ final class FilteredMeta extends AbstractMeta { } } + static Predicate and(Predicate p1, Predicate p2) { + if (p1 == null) + return p2; + else if (p2 == null) + return p1; + else + return new And<>(p1, p2); + } + private class FilteredCatalog extends CatalogImpl { private final Catalog delegate; diff --git a/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java index 00759e6b30..5a7de1e725 100644 --- a/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java @@ -61,6 +61,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; +import java.util.function.Predicate; import org.jooq.Catalog; import org.jooq.Check; @@ -157,6 +158,11 @@ final class InformationSchemaMetaImpl extends AbstractMeta { init(source); } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return this; + } + @SuppressWarnings({ "unchecked", "rawtypes" }) private final void init(InformationSchema meta) { List errors = new ArrayList<>(); diff --git a/jOOQ/src/main/java/org/jooq/impl/Interpreter.java b/jOOQ/src/main/java/org/jooq/impl/Interpreter.java index 433447cd9c..088c3351d8 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Interpreter.java +++ b/jOOQ/src/main/java/org/jooq/impl/Interpreter.java @@ -78,6 +78,7 @@ import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.function.Function; +import java.util.function.Predicate; import org.jooq.Catalog; import org.jooq.Check; @@ -175,6 +176,11 @@ final class Interpreter { return new AbstractMeta(configuration) { + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return this; + } + @Override final List getCatalogs0() throws DataAccessException { return map(catalogs.values(), c -> c.interpretedCatalog()); diff --git a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java index 805a32c2e6..354dd228dc 100644 --- a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java @@ -110,6 +110,7 @@ import java.util.Map; import java.util.Set; import java.util.function.Consumer; import java.util.function.Function; +import java.util.function.Predicate; import java.util.function.Supplier; import java.util.regex.Pattern; @@ -183,12 +184,31 @@ final class MetaImpl extends AbstractMeta { private final boolean inverseSchemaCatalog; MetaImpl(Configuration configuration, DatabaseMetaData databaseMetaData) { - super(configuration); + this(configuration, databaseMetaData, null, null); + } + + private MetaImpl( + Configuration configuration, + DatabaseMetaData databaseMetaData, + Predicate catalogFilter, + Predicate schemaFilter + ) { + super(configuration, catalogFilter, schemaFilter); this.databaseMetaData = databaseMetaData; this.inverseSchemaCatalog = INVERSE_SCHEMA_CATALOG.contains(dialect()); } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return new MetaImpl( + configuration(), + databaseMetaData, + FilteredMeta.and(this.catalogFilter, catalogFilter), + FilteredMeta.and(this.schemaFilter, schemaFilter) + ); + } + final boolean hasCatalog(Catalog catalog) { return catalog != null && !isEmpty(catalog.getName()); } @@ -281,8 +301,12 @@ final class MetaImpl extends AbstractMeta { SQLDataType.VARCHAR // TABLE_CATALOG )); - for (String name : catalogs.getValues(0, String.class)) - result.add(new MetaCatalog(name)); + for (String name : catalogs.getValues(0, String.class)) { + MetaCatalog c = new MetaCatalog(name); + + if (catalogFilter == null || catalogFilter.test(c)) + result.add(c); + } } } diff --git a/jOOQ/src/main/java/org/jooq/impl/Snapshot.java b/jOOQ/src/main/java/org/jooq/impl/Snapshot.java index 5197947fdc..62ace15a6c 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Snapshot.java +++ b/jOOQ/src/main/java/org/jooq/impl/Snapshot.java @@ -44,6 +44,7 @@ import static org.jooq.impl.Tools.map; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.function.Predicate; import org.jooq.Catalog; import org.jooq.Check; @@ -84,6 +85,11 @@ final class Snapshot extends AbstractMeta { resolveReferences(); } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return this; + } + private final void resolveReferences() { for (Catalog catalog : getCatalogs()) ((SnapshotCatalog) catalog).resolveReferences(); diff --git a/jOOQ/src/main/java/org/jooq/impl/TableMetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/TableMetaImpl.java index 0c0c936407..428dfa223a 100644 --- a/jOOQ/src/main/java/org/jooq/impl/TableMetaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/TableMetaImpl.java @@ -43,6 +43,7 @@ import java.util.Collections; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; +import java.util.function.Predicate; import org.jooq.Catalog; import org.jooq.Configuration; @@ -68,6 +69,11 @@ final class TableMetaImpl extends AbstractMeta { this.tables = tables; } + @Override + final AbstractMeta filtered0(Predicate catalogFilter, Predicate schemaFilter) { + return this; + } + @Override final List getCatalogs0() { Set result = new LinkedHashSet<>();