github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[jOOQ/jOOQ#17259] Meta::filterCatalogs is applied too late for internal

Browse Source 
MetaImpl queries executed by Meta::ddl
This commit is contained in:
Lukas Eder 2024-09-18 14:34:02 +02:00
parent 807ec8850e
commit 85c137d699
8 changed files with 267 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java
View File

@ -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<Name, Catalog> cachedCatalogs;
private Map<Name, Schema> cachedQualifiedSchemas;
private Map<Name, Table<?>> cachedQualifiedTables;
private Map<Name, Domain<?>> cachedQualifiedDomains;
private Map<Name, Sequence<?>> cachedQualifiedSequences;
private Map<Name, UniqueKey<?>> cachedQualifiedPrimaryKeys;
private Map<Name, UniqueKey<?>> cachedQualifiedUniqueKeys;
private Map<Name, ForeignKey<?, ?>> cachedQualifiedForeignKeys;
private Map<Name, Index> cachedQualifiedIndexes;
private Map<Name, List<Schema>> cachedUnqualifiedSchemas;
private Map<Name, List<Table<?>>> cachedUnqualifiedTables;
private Map<Name, List<Domain<?>>> cachedUnqualifiedDomains;
private Map<Name, List<Sequence<?>>> cachedUnqualifiedSequences;
private Map<Name, List<UniqueKey<?>>> cachedUnqualifiedPrimaryKeys;
private Map<Name, List<UniqueKey<?>>> cachedUnqualifiedUniqueKeys;
private Map<Name, List<ForeignKey<?, ?>>> cachedUnqualifiedForeignKeys;
private Map<Name, List<Index>> cachedUnqualifiedIndexes;
private Cached<Schema> cachedSchemas;
private Cached<Table<?>> cachedTables;
private Cached<Domain<?>> cachedDomains;
private Cached<Sequence<?>> cachedSequences;
private Cached<UniqueKey<?>> cachedPrimaryKeys;
private Cached<UniqueKey<?>> cachedUniqueKeys;
private Cached<ForeignKey<?, ?>> cachedForeignKeys;
private Cached<Index> cachedIndexes;
final Predicate<? super Catalog> catalogFilter;
final Predicate<? super Schema> schemaFilter;
AbstractMeta(Configuration configuration) {
super(configuration);
this(configuration, null, null);
}
AbstractMeta(Configuration configuration, Predicate<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
super(configuration);
this.catalogFilter = catalogFilter;
this.schemaFilter = schemaFilter;
}
abstract AbstractMeta filtered0(Predicate<? super Catalog> catalogFilter, Predicate<? super Schema> 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<Catalog> 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<Name, Catalog> getCachedCatalogs() {
Map<Name, Catalog> 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<Catalog> getCatalogs0();
private static final record Cached<N extends Named>(Map<Name, N> qualified, Map<Name, List<N>> unqualified) {
Cached() {
this(new LinkedHashMap<>(), new LinkedHashMap<>());
}
final void init(Iterable<N> 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<N> get(Name name) {
N object = qualified().get(name);
if (object != null)
return Collections.singletonList(object);
List<N> list = unqualified().get(name);
if (list == null)
return Collections.emptyList();
else
return Collections.unmodifiableList(list);
}
}
@Override
public final List<Schema> getSchemas(String name) {
return getSchemas(name(name));
@ -140,22 +176,29 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<Schema> getSchemas(Name name) {
initSchemas();
return get(name, () -> getSchemas0().iterator(), cachedQualifiedSchemas, cachedUnqualifiedSchemas);
return getCachedSchemas().get(name);
}
@Override
public final List<Schema> 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<Schema> getCachedSchemas() {
Cached<Schema> 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<Schema> getSchemas0() {
@ -169,22 +212,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<Table<?>> getTables(Name name) {
initTables();
return get(name, () -> getTables().iterator(), cachedQualifiedTables, cachedUnqualifiedTables);
return getCachedTables().get(name);
}
@Override
public final List<Table<?>> 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<Table<?>> getCachedTables() {
Cached<Table<?>> t = cachedTables;
if (t == null) {
t = new Cached<>();
t.init(() -> getTables0().iterator());
}
if (caching())
cachedTables = t;
return t;
}
List<Table<?>> getTables0() {
@ -198,22 +245,27 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<Domain<?>> getDomains(Name name) {
initDomains();
return get(name, () -> getDomains().iterator(), cachedQualifiedDomains, cachedUnqualifiedDomains);
return getCachedDomains().get(name);
}
@Override
public final List<Domain<?>> 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<Domain<?>> getCachedDomains() {
Cached<Domain<?>> d = cachedDomains;
if (d == null) {
d = new Cached<>();
d.init(() -> getDomains0().iterator());
}
if (caching())
cachedDomains = d;
return d;
}
List<Domain<?>> 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<Sequence<?>> getSequences(Name name) {
initSequences();
return get(name, () -> getSequences().iterator(), cachedQualifiedSequences, cachedUnqualifiedSequences);
return getCachedSequences().get(name);
}
@Override
public final List<Sequence<?>> 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<Sequence<?>> getCachedSequences() {
Cached<Sequence<?>> s = cachedSequences;
if (s == null) {
s = new Cached<>();
s.init(() -> getSequences0().iterator());
}
if (caching())
cachedSequences = s;
return s;
}
final List<Sequence<?>> getSequences0() {
@ -289,22 +349,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<UniqueKey<?>> getPrimaryKeys(Name name) {
initPrimaryKeys();
return get(name, () -> getPrimaryKeys().iterator(), cachedQualifiedPrimaryKeys, cachedUnqualifiedPrimaryKeys);
return getCachedPrimaryKeys().get(name);
}
@Override
public final List<UniqueKey<?>> 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<UniqueKey<?>> getCachedPrimaryKeys() {
Cached<UniqueKey<?>> k = cachedPrimaryKeys;
if (k == null) {
k = new Cached<>();
k.init(() -> getPrimaryKeys0().iterator());
}
if (caching())
cachedPrimaryKeys = k;
return k;
}
List<UniqueKey<?>> getPrimaryKeys0() {
@ -324,22 +388,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<UniqueKey<?>> getUniqueKeys(Name name) {
initUniqueKeys();
return get(name, () -> getUniqueKeys().iterator(), cachedQualifiedUniqueKeys, cachedUnqualifiedUniqueKeys);
return getCachedUniqueKeys().get(name);
}
@Override
public final List<UniqueKey<?>> 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<UniqueKey<?>> getCachedUniqueKeys() {
Cached<UniqueKey<?>> k = cachedUniqueKeys;
if (k == null) {
k = new Cached<>();
k.init(() -> getUniqueKeys0().iterator());
}
if (caching())
cachedUniqueKeys = k;
return k;
}
List<UniqueKey<?>> getUniqueKeys0() {
@ -353,22 +421,26 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<ForeignKey<?, ?>> getForeignKeys(Name name) {
initForeignKeys();
return get(name, () -> getForeignKeys().iterator(), cachedQualifiedForeignKeys, cachedUnqualifiedForeignKeys);
return getCachedForeignKeys().get(name);
}
@Override
public final List<ForeignKey<?, ?>> 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<ForeignKey<?, ?>> getCachedForeignKeys() {
Cached<ForeignKey<?, ?>> k = cachedForeignKeys;
if (k == null) {
k = new Cached<>();
k.init(() -> getForeignKeys0().iterator());
}
if (caching())
cachedForeignKeys = k;
return k;
}
List<ForeignKey<?, ?>> getForeignKeys0() {
@ -382,48 +454,34 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable
@Override
public final List<Index> getIndexes(Name name) {
initIndexes();
return get(name, () -> getIndexes().iterator(), cachedQualifiedIndexes, cachedUnqualifiedIndexes);
return getCachedIndexes().get(name);
}
@Override
public final List<Index> 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<Index> getCachedIndexes() {
Cached<Index> i = cachedIndexes;
if (i == null) {
i = new Cached<>();
i.init(() -> getIndexes0().iterator());
}
if (caching())
cachedIndexes = i;
return i;
}
List<Index> getIndexes0() {
return flatMap(getTables(), t -> t.getIndexes());
}
private final <T extends Named> List<T> get(Name name, Iterable<T> i, Map<Name, T> qualified, Map<Name, List<T>> 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<T> list = unqualified.get(name);
if (list == null)
return Collections.emptyList();
else
return Collections.unmodifiableList(list);
private boolean caching() {
return true;
}
@Override

5
jOOQ/src/main/java/org/jooq/impl/CatalogMetaImpl.java
View File

@ -70,6 +70,11 @@ final class CatalogMetaImpl extends AbstractMeta {
this.catalogs = catalogs;
}
@Override
final AbstractMeta filtered0(Predicate<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return this;
}
@Override
final List<Catalog> getCatalogs0() {
return Arrays.asList(catalogs);

58
jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java
View File

@ -70,8 +70,6 @@ import org.jooq.UniqueKey;
final class FilteredMeta extends AbstractMeta {
private final AbstractMeta meta;
private final Predicate<? super Catalog> catalogFilter;
private final Predicate<? super Schema> schemaFilter;
private final Predicate<? super Table<?>> tableFilter;
private final Predicate<? super Domain<?>> domainFilter;
@ -98,11 +96,9 @@ final class FilteredMeta extends AbstractMeta {
Predicate<? super ForeignKey<?, ?>> foreignKeyFilter,
Predicate<? super Index> 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<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return filterCatalogs(catalogFilter).filterSchemas(schemaFilter);
}
@Override
final List<Catalog> getCatalogs0() {
List<Catalog> result = new ArrayList<>();
@ -127,10 +128,10 @@ final class FilteredMeta extends AbstractMeta {
}
@Override
public final Meta filterCatalogs(Predicate<? super Catalog> filter) {
public final FilteredMeta filterCatalogs(Predicate<? super Catalog> 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<? super Schema> filter) {
public final FilteredMeta filterSchemas(Predicate<? super Schema> 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<? super Table<?>> filter) {
public final FilteredMeta filterTables(Predicate<? super Table<?>> 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<? super Domain<?>> filter) {
public final FilteredMeta filterDomains(Predicate<? super Domain<?>> 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<? super Sequence<?>> filter) {
public final FilteredMeta filterSequences(Predicate<? super Sequence<?>> 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<? super UniqueKey<?>> filter) {
public final FilteredMeta filterPrimaryKeys(Predicate<? super UniqueKey<?>> 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<? super UniqueKey<?>> filter) {
public final FilteredMeta filterUniqueKeys(Predicate<? super UniqueKey<?>> 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<? super ForeignKey<?, ?>> filter) {
public final FilteredMeta filterForeignKeys(Predicate<? super ForeignKey<?, ?>> 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<? super Index> filter) {
public final FilteredMeta filterIndexes(Predicate<? super Index> 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 <Q extends QueryPart> Predicate<? super Q> and(Predicate<? super Q> p1, Predicate<? super Q> 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;

6
jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java
View File

@ -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<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return this;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private final void init(InformationSchema meta) {
List<String> errors = new ArrayList<>();

6
jOOQ/src/main/java/org/jooq/impl/Interpreter.java
View File

@ -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<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return this;
}
@Override
final List<Catalog> getCatalogs0() throws DataAccessException {
return map(catalogs.values(), c -> c.interpretedCatalog());

30
jOOQ/src/main/java/org/jooq/impl/MetaImpl.java
View File

@ -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<? super Catalog> catalogFilter,
Predicate<? super Schema> schemaFilter
) {
super(configuration, catalogFilter, schemaFilter);
this.databaseMetaData = databaseMetaData;
this.inverseSchemaCatalog = INVERSE_SCHEMA_CATALOG.contains(dialect());
}
@Override
final AbstractMeta filtered0(Predicate<? super Catalog> catalogFilter, Predicate<? super Schema> 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);
}
}
}

6
jOOQ/src/main/java/org/jooq/impl/Snapshot.java
View File

@ -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<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return this;
}
private final void resolveReferences() {
for (Catalog catalog : getCatalogs())
((SnapshotCatalog) catalog).resolveReferences();

6
jOOQ/src/main/java/org/jooq/impl/TableMetaImpl.java
View File

@ -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<? super Catalog> catalogFilter, Predicate<? super Schema> schemaFilter) {
return this;
}
@Override
final List<Catalog> getCatalogs0() {
Set<Catalog> result = new LinkedHashSet<>();