From 0d2351382ea6fffa238e664a342418faf92cb2e0 Mon Sep 17 00:00:00 2001 From: lukaseder Date: Wed, 17 Oct 2018 11:31:49 +0200 Subject: [PATCH] [#7947] Let code generation patterns match also partially qualified object names --- .../java/org/jooq/codegen/GenerationTool.java | 1 + .../java/org/jooq/meta/AbstractDatabase.java | 39 +++++++++++----- .../src/main/java/org/jooq/meta/Database.java | 14 ++++++ .../java/org/jooq/meta/jaxb/Database.java | 46 +++++++++++++++++++ .../resources/xsd/jooq-codegen-3.12.0.xsd | 4 ++ 5 files changed, 93 insertions(+), 11 deletions(-) diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java index a48fbc8086..78723b842d 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java @@ -505,6 +505,7 @@ public class GenerationTool { if (d.getRegexFlags() != null) database.setRegexFlags(d.getRegexFlags()); + database.setRegexMatchesPartialQualification(!FALSE.equals(d.isRegexMatchesPartialQualification())); SchemaVersionProvider svp = null; CatalogVersionProvider cvp = null; diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java b/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java index 144480dc0e..bf1401e1a7 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/AbstractDatabase.java @@ -47,6 +47,7 @@ import java.math.BigInteger; import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; @@ -103,6 +104,7 @@ public abstract class AbstractDatabase implements Database { private SQLDialect dialect; private Connection connection; private List regexFlags; + private boolean regexMatchesPartialQualification; private List filters; private String[] excludes; private String[] includes = { ".*" }; @@ -353,6 +355,20 @@ public abstract class AbstractDatabase implements Database { return true; } + final boolean matches(Pattern pattern, Definition definition) { + if (!getRegexMatchesPartialQualification()) + return pattern.matcher(definition.getName()).matches() + || pattern.matcher(definition.getQualifiedName()).matches(); + + List parts = Arrays.asList(definition.getQualifiedNamePart().parts()); + + for (int i = parts.size() - 1; i >= 0; i--) + if (pattern.matcher(DSL.name(parts.subList(i, parts.size()).toArray(new Name[0])).unquotedName().toString()).matches()) + return true; + + return false; + } + final Pattern pattern(String regex) { Pattern pattern = patterns.get(regex); @@ -883,6 +899,16 @@ public abstract class AbstractDatabase implements Database { return regexFlags; } + @Override + public final void setRegexMatchesPartialQualification(boolean regexMatchesPartialQualification) { + this.regexMatchesPartialQualification = regexMatchesPartialQualification; + } + + @Override + public final boolean getRegexMatchesPartialQualification() { + return regexMatchesPartialQualification; + } + @Override public void setRecordVersionFields(String[] recordVersionFields) { this.recordVersionFields = recordVersionFields; @@ -1819,12 +1845,7 @@ public abstract class AbstractDatabase implements Database { definitionsLoop: for (T definition : definitions) { if (e != null) { for (String exclude : e) { - Pattern p = pattern(exclude); - - if (exclude != null && - (p.matcher(definition.getName()).matches() || - p.matcher(definition.getQualifiedName()).matches())) { - + if (exclude != null && matches(pattern(exclude), definition)) { if (log.isDebugEnabled()) log.debug("Exclude", "Excluding " + definition.getQualifiedName() + " because of pattern " + exclude); @@ -1835,11 +1856,7 @@ public abstract class AbstractDatabase implements Database { if (i != null) { for (String include : i) { - Pattern p = pattern(include); - - if (include != null && - (p.matcher(definition.getName()).matches() || - p.matcher(definition.getQualifiedName()).matches())) { + if (include != null && matches(pattern(include), definition)) { // [#3488] This allows for filtering out additional objects, in case the applicable // code generation configuration might cause conflicts in resulting code diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/Database.java b/jOOQ-meta/src/main/java/org/jooq/meta/Database.java index c8c99c9e28..4b305ab3ad 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/Database.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/Database.java @@ -579,6 +579,20 @@ public interface Database extends AutoCloseable { */ List getRegexFlags(); + /** + * Whether the regular expressions matching database objects should match + * partially qualified names as well as fully qualified and unqualified + * names. + */ + void setRegexMatchesPartialQualification(boolean regexMatchesPartialQualification); + + /** + * Whether the regular expressions matching database objects should match + * partially qualified names as well as fully qualified and unqualified + * names. + */ + boolean getRegexMatchesPartialQualification(); + /** * Table columns matching these regular expressions will be considered as * record version fields in generated code. diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Database.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Database.java index 9aa1ad5388..e04bd2416a 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Database.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Database.java @@ -44,6 +44,8 @@ public class Database implements Serializable @XmlList @XmlElement(defaultValue = "COMMENTS CASE_INSENSITIVE") protected List regexFlags; + @XmlElement(defaultValue = "true") + protected Boolean regexMatchesPartialQualification = true; @XmlElement(defaultValue = ".*") @XmlJavaTypeAdapter(StringAdapter.class) protected String includes = ".*"; @@ -245,6 +247,30 @@ public class Database implements Serializable return this.regexFlags; } + /** + * Whether regular expressions that match qualified object names also match partial qualifications (e.g. `table\.column` matches `schema.table.column`) or only full and/or no qualifications (e.g. `schema\.table\.column` and `column` match `schema.table.column`) + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isRegexMatchesPartialQualification() { + return regexMatchesPartialQualification; + } + + /** + * Sets the value of the regexMatchesPartialQualification property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setRegexMatchesPartialQualification(Boolean value) { + this.regexMatchesPartialQualification = value; + } + /** * All elements that are generated from your schema. *

@@ -1327,6 +1353,11 @@ public class Database implements Serializable return this; } + public Database withRegexMatchesPartialQualification(Boolean value) { + setRegexMatchesPartialQualification(value); + return this; + } + public Database withIncludes(String value) { setIncludes(value); return this; @@ -1655,6 +1686,11 @@ public class Database implements Serializable } sb.append(""); } + if (regexMatchesPartialQualification!= null) { + sb.append(""); + sb.append(regexMatchesPartialQualification); + sb.append(""); + } if (includes!= null) { sb.append(""); sb.append(includes); @@ -1927,6 +1963,15 @@ public class Database implements Serializable return false; } } + if (regexMatchesPartialQualification == null) { + if (other.regexMatchesPartialQualification!= null) { + return false; + } + } else { + if (!regexMatchesPartialQualification.equals(other.regexMatchesPartialQualification)) { + return false; + } + } if (includes == null) { if (other.includes!= null) { return false; @@ -2323,6 +2368,7 @@ public class Database implements Serializable int result = 1; result = ((prime*result)+((name == null)? 0 :name.hashCode())); result = ((prime*result)+((regexFlags == null)? 0 :regexFlags.hashCode())); + result = ((prime*result)+((regexMatchesPartialQualification == null)? 0 :regexMatchesPartialQualification.hashCode())); result = ((prime*result)+((includes == null)? 0 :includes.hashCode())); result = ((prime*result)+((excludes == null)? 0 :excludes.hashCode())); result = ((prime*result)+((includeExcludeColumns == null)? 0 :includeExcludeColumns.hashCode())); diff --git a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.12.0.xsd b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.12.0.xsd index ef8ddfcef2..2bc7104508 100644 --- a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.12.0.xsd +++ b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.12.0.xsd @@ -439,6 +439,10 @@ encoding=UTF-8 The default value is "COMMENTS CASE_INSENSITIVE"]]> + + + +