diff --git a/jOOQ/src/main/java/org/jooq/Meta.java b/jOOQ/src/main/java/org/jooq/Meta.java index d8dcca47cc..ab4d92e5f3 100644 --- a/jOOQ/src/main/java/org/jooq/Meta.java +++ b/jOOQ/src/main/java/org/jooq/Meta.java @@ -242,6 +242,51 @@ public interface Meta extends Scope { @Support List getIndexes() throws DataAccessException; + /** + * A predicate to filter out query parts of a given type from meta data. + */ + interface Predicateextends java.util.function.Predicate { + + @Override + + boolean test(Q t); + } + + /** + * Create a wrapper {@link Meta} instance filtering out some catalogs. + */ + Meta filterCatalogs(Predicate filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some schemas. + */ + Meta filterSchemas(Predicate filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some tables. + */ + Meta filterTables(Predicate> filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some domains. + */ + Meta filterDomains(Predicate> filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some sequences. + */ + Meta filterSequences(Predicate> filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some primary keys. + */ + Meta filterPrimaryKeys(Predicate> filter); + + /** + * Create a wrapper {@link Meta} instance filtering out some indexes. + */ + Meta filterIndexes(Predicate filter); + /** * Generate a creation script for the entire meta data. * diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java b/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java index 3e05ced9e4..7a51031aba 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractMeta.java @@ -197,8 +197,10 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable List> getTables0() { List> result = new ArrayList<>(); + for (Schema schema : getSchemas()) result.addAll(schema.getTables()); + return result; } @@ -283,8 +285,10 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable List> getSequences0() { List> result = new ArrayList<>(); + for (Schema schema : getSchemas()) result.addAll(schema.getSequences()); + return result; } @@ -358,6 +362,104 @@ abstract class AbstractMeta extends AbstractScope implements Meta, Serializable return Collections.unmodifiableList(list); } + @Override + public Meta filterCatalogs(Predicate filter) { + return new FilteredMeta( + this, + filter, + null, + null, + null, + null, + null, + null + ); + } + + @Override + public Meta filterSchemas(Predicate filter) { + return new FilteredMeta( + this, + null, + filter, + null, + null, + null, + null, + null + ); + } + + @Override + public Meta filterTables(Predicate> filter) { + return new FilteredMeta( + this, + null, + null, + filter, + null, + null, + null, + null + ); + } + + @Override + public Meta filterDomains(Predicate> filter) { + return new FilteredMeta( + this, + null, + null, + null, + filter, + null, + null, + null + ); + } + + @Override + public Meta filterSequences(Predicate> filter) { + return new FilteredMeta( + this, + null, + null, + null, + null, + filter, + null, + null + ); + } + + @Override + public Meta filterPrimaryKeys(Predicate> filter) { + return new FilteredMeta( + this, + null, + null, + null, + null, + null, + filter, + null + ); + } + + @Override + public Meta filterIndexes(Predicate filter) { + return new FilteredMeta( + this, + null, + null, + null, + null, + null, + null, + filter + ); + } + @Override public final Queries ddl() { return ddl(new DDLExportConfiguration()); diff --git a/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java b/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java new file mode 100644 index 0000000000..4594a58773 --- /dev/null +++ b/jOOQ/src/main/java/org/jooq/impl/FilteredMeta.java @@ -0,0 +1,308 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Other licenses: + * ----------------------------------------------------------------------------- + * Commercial licenses for this work are available. These replace the above + * ASL 2.0 and offer limited warranties, support, maintenance, and commercial + * database integrations. + * + * For more information, please visit: http://www.jooq.org/licenses + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ +package org.jooq.impl; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.jooq.Catalog; +import org.jooq.Domain; +import org.jooq.Index; +import org.jooq.Meta; +import org.jooq.QueryPart; +import org.jooq.Schema; +import org.jooq.Sequence; +import org.jooq.Table; +import org.jooq.UDT; +import org.jooq.UniqueKey; + +/** + * A {@link Meta} implementation that applies filters on a delegate {@link Meta} + * object. + * + * @author Lukas Eder + */ +final class FilteredMeta extends AbstractMeta { + + /** + * Generated UID + */ + private static final long serialVersionUID = 2589476339574534267L; + + private final AbstractMeta meta; + private final Predicate catalogFilter; + private final Predicate schemaFilter; + private final Predicate> tableFilter; + private final Predicate> domainFilter; + private final Predicate> sequenceFilter; + private final Predicate> primaryKeyFilter; + private final Predicate indexFilter; + + FilteredMeta( + AbstractMeta meta, + Predicate catalogFilter, + Predicate schemaFilter, + Predicate> tableFilter, + Predicate> domainFilter, + Predicate> sequenceFilter, + Predicate> primaryKeyFilter, + Predicate indexFilter + ) { + super(meta.configuration()); + + this.meta = meta; + this.catalogFilter = catalogFilter; + this.schemaFilter = schemaFilter; + this.tableFilter = tableFilter; + this.domainFilter = domainFilter; + this.sequenceFilter = sequenceFilter; + this.primaryKeyFilter = primaryKeyFilter; + this.indexFilter = indexFilter; + } + + @Override + final List getCatalogs0() { + List result = new ArrayList<>(); + + for (Catalog c : meta.getCatalogs()) + if (catalogFilter == null || catalogFilter.test(c)) + result.add(new FilteredCatalog(c)); + + return result; + } + + @Override + public final Meta filterCatalogs(Predicate filter) { + return new FilteredMeta( + meta, + catalogFilter != null ? new And<>(catalogFilter, filter) : filter, + schemaFilter, + tableFilter, + domainFilter, + sequenceFilter, + primaryKeyFilter, + indexFilter + ); + } + + @Override + public final Meta filterSchemas(Predicate filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter != null ? new And<>(schemaFilter, filter) : filter, + tableFilter, + domainFilter, + sequenceFilter, + primaryKeyFilter, + indexFilter + ); + } + + @Override + public final Meta filterTables(Predicate> filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter, + tableFilter != null ? new And<>(tableFilter, filter) : filter, + domainFilter, + sequenceFilter, + primaryKeyFilter, + indexFilter + ); + } + + @Override + public final Meta filterDomains(Predicate> filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter, + tableFilter, + domainFilter != null ? new And<>(domainFilter, filter) : filter, + sequenceFilter, + primaryKeyFilter, + indexFilter + ); + } + + @Override + public final Meta filterSequences(Predicate> filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter, + tableFilter, + domainFilter, + sequenceFilter != null ? new And<>(sequenceFilter, filter) : filter, + primaryKeyFilter, + indexFilter + ); + } + + @Override + public final Meta filterPrimaryKeys(Predicate> filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter, + tableFilter, + domainFilter, + sequenceFilter, + primaryKeyFilter != null ? new And<>(primaryKeyFilter, filter) : filter, + indexFilter + ); + } + + @Override + public final Meta filterIndexes(Predicate filter) { + return new FilteredMeta( + meta, + catalogFilter, + schemaFilter, + tableFilter, + domainFilter, + sequenceFilter, + primaryKeyFilter, + indexFilter != null ? new And<>(indexFilter, filter) : filter + ); + } + + private static class And implements Predicate { + private final Predicate p1; + private final Predicate p2; + + And(Predicate p1, Predicate p2) { + this.p1 = p1; + this.p2 = p2; + } + + @Override + public final boolean test(Q q) { + return p1.test(q) && p2.test(q); + } + } + + private class FilteredCatalog extends CatalogImpl { + private static final long serialVersionUID = 7979890261252183486L; + + private final Catalog delegate; + private transient List schemas; + + private FilteredCatalog(Catalog delegate) { + super(delegate.getQualifiedName(), DSL.comment(delegate.getComment())); + + this.delegate = delegate; + } + + @Override + public final List getSchemas() { + if (schemas == null) { + schemas = new ArrayList<>(); + + for (Schema s : delegate.getSchemas()) + if (schemaFilter == null || schemaFilter.test(s)) + schemas.add(new FilteredSchema(s)); + } + + return Collections.unmodifiableList(schemas); + } + } + + private class FilteredSchema extends SchemaImpl { + private static final long serialVersionUID = -95755926444275258L; + + private final Schema delegate; + private transient List> domains; + private transient List> tables; + private transient List> sequences; + + private FilteredSchema(Schema delegate) { + super(delegate.getQualifiedName(), delegate.getCatalog(), DSL.comment(delegate.getComment())); + + this.delegate = delegate; + } + + @Override + public final List> getDomains() { + if (domains == null) { + domains = new ArrayList<>(); + + for (Domain d : delegate.getDomains()) + if (domainFilter == null || domainFilter.test(d)) + domains.add(d); + } + + return Collections.unmodifiableList(domains); + } + + @Override + public final List> getTables() { + if (tables == null) { + tables = new ArrayList<>(); + + for (Table t : delegate.getTables()) + if (tableFilter == null || tableFilter.test(t)) + // TODO create a FilteredTable and filter out primary key and indexes + tables.add(t); + } + + return Collections.unmodifiableList(tables); + } + + @Override + public final List> getSequences() { + if (sequences == null) { + sequences = new ArrayList<>(); + + for (Sequence t : delegate.getSequences()) + if (sequenceFilter == null || sequenceFilter.test(t)) + sequences.add(t); + } + + return Collections.unmodifiableList(sequences); + } + + @Override + public final List> getUDTs() { + return delegate.getUDTs(); + } + } +}