Check patterns support using multiple filters, separated by a comma.

piotrczarnas · piotrczarnas · commit 171d182070d2 · 2024-05-13T17:26:25.000+02:00
diff --git a/dqops/src/main/java/com/dqops/metadata/defaultchecks/column/TargetColumnPatternFilter.java b/dqops/src/main/java/com/dqops/metadata/defaultchecks/column/TargetColumnPatternFilter.java
@@ -29,8 +29,8 @@
  * Target column filter for default checks that uses parsed patterns.
  */
 public class TargetColumnPatternFilter extends TargetTablePatternFilter {
-    private SearchPattern columnPattern;
-    private SearchPattern dataTypePattern;
+    private SearchPattern[] columnPattern;
+    private SearchPattern[] dataTypePattern;
     private DataTypeCategory dataTypeCategory;
 
     /**
@@ -41,11 +41,11 @@ public TargetColumnPatternFilter(TargetColumnPatternSpec columnPatternSpec) {
         super(columnPatternSpec);
 
         if (!Strings.isNullOrEmpty(columnPatternSpec.getColumn())) {
-            this.columnPattern = SearchPattern.create(false, columnPatternSpec.getColumn());
+            this.columnPattern = SearchPattern.createForCommaSeparatedPatterns(false, columnPatternSpec.getColumn());
         }
 
         if (!Strings.isNullOrEmpty(columnPatternSpec.getDataType())) {
-            this.dataTypePattern = SearchPattern.create(false, columnPatternSpec.getDataType());
+            this.dataTypePattern = SearchPattern.createForCommaSeparatedPatterns(false, columnPatternSpec.getDataType());
         }
 
         this.dataTypeCategory = columnPatternSpec.getDataTypeCategory();
@@ -61,13 +61,13 @@ public TargetColumnPatternFilter(TargetColumnPatternSpec columnPatternSpec) {
      */
     public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, ColumnSpec columnSpec, DataTypeCategory dataTypeCategory) {
         if (this.columnPattern != null) {
-            if (!this.columnPattern.match(columnSpec.getColumnName())) {
+            if (!SearchPattern.matchAny(this.columnPattern, columnSpec.getColumnName())) {
                 return false;
             }
         }
 
         if (this.dataTypePattern != null) {
-            if (columnSpec.getTypeSnapshot() == null || !this.dataTypePattern.match(columnSpec.getTypeSnapshot().getColumnType())) {
+            if (columnSpec.getTypeSnapshot() == null || !SearchPattern.matchAny(this.dataTypePattern, columnSpec.getTypeSnapshot().getColumnType())) {
                 return false;
             }
         }
@@ -86,7 +86,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, ColumnS
             LabelSetSpec columnSpecLabels = columnSpec.getLabels();
             if (columnSpecLabels != null && !columnSpecLabels.isEmpty()) {
                 for (String label : columnSpecLabels) {
-                    if (this.labelPattern.match(label)) {
+                    if (SearchPattern.matchAny(this.labelPattern, label)) {
                         return true;
                     }
                 }
diff --git a/dqops/src/main/java/com/dqops/metadata/defaultchecks/table/TargetTablePatternFilter.java b/dqops/src/main/java/com/dqops/metadata/defaultchecks/table/TargetTablePatternFilter.java
@@ -26,36 +26,36 @@
  * Target table filter for default checks that uses parsed patterns.
  */
 public class TargetTablePatternFilter {
-    private SearchPattern connectionPattern;
-    private SearchPattern schemaPattern;
-    private SearchPattern tablePattern;
-    private SearchPattern stagePattern;
+    private SearchPattern[] connectionPattern;
+    private SearchPattern[] schemaPattern;
+    private SearchPattern[] tablePattern;
+    private SearchPattern[] stagePattern;
     private Integer tablePriority;
-    protected SearchPattern labelPattern;
+    protected SearchPattern[] labelPattern;
 
     /**
      * Creates a table pattern search object given a target table pattern specification. Creates search patterns for filled fields.
      * @param tablePatternSpec Target table search pattern.
      */
     public TargetTablePatternFilter(TargetTablePatternSpec tablePatternSpec) {
         if (!Strings.isNullOrEmpty(tablePatternSpec.getConnection())) {
-            this.connectionPattern = SearchPattern.create(false, tablePatternSpec.getConnection());
+            this.connectionPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getConnection());
         }
 
         if (!Strings.isNullOrEmpty(tablePatternSpec.getSchema())) {
-            this.schemaPattern = SearchPattern.create(false, tablePatternSpec.getSchema());
+            this.schemaPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getSchema());
         }
 
         if (!Strings.isNullOrEmpty(tablePatternSpec.getTable())) {
-            this.tablePattern = SearchPattern.create(false, tablePatternSpec.getTable());
+            this.tablePattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getTable());
         }
 
         if (!Strings.isNullOrEmpty(tablePatternSpec.getStage())) {
-            this.stagePattern = SearchPattern.create(false, tablePatternSpec.getStage());
+            this.stagePattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getStage());
         }
 
         if (!Strings.isNullOrEmpty(tablePatternSpec.getLabel())) {
-            this.labelPattern = SearchPattern.create(false, tablePatternSpec.getLabel());
+            this.labelPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getLabel());
         }
 
         this.tablePriority = tablePatternSpec.getTablePriority();
@@ -70,25 +70,25 @@ public TargetTablePatternFilter(TargetTablePatternSpec tablePatternSpec) {
      */
     public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean matchLabels) {
         if (this.connectionPattern != null) {
-            if (!this.connectionPattern.match(connectionSpec.getConnectionName())) {
+            if (!SearchPattern.matchAny(this.connectionPattern, connectionSpec.getConnectionName())) {
                 return false;
             }
         }
 
         if (this.schemaPattern != null) {
-            if (!this.schemaPattern.match(tableSpec.getPhysicalTableName().getSchemaName())) {
+            if (!SearchPattern.matchAny(this.schemaPattern, tableSpec.getPhysicalTableName().getSchemaName())) {
                 return false;
             }
         }
 
         if (this.tablePattern != null) {
-            if (!this.tablePattern.match(tableSpec.getPhysicalTableName().getTableName())) {
+            if (!SearchPattern.matchAny(this.tablePattern, tableSpec.getPhysicalTableName().getTableName())) {
                 return false;
             }
         }
 
         if (this.stagePattern != null) {
-            if (!this.stagePattern.match(tableSpec.getStage())) {
+            if (!SearchPattern.matchAny(this.stagePattern, tableSpec.getStage())) {
                 return false;
             }
         }
@@ -103,7 +103,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean
             LabelSetSpec connectionLabels = connectionSpec.getLabels();
             if (connectionLabels != null && !connectionLabels.isEmpty()) {
                 for (String label : connectionLabels) {
-                    if (this.labelPattern.match(label)) {
+                    if (SearchPattern.matchAny(this.labelPattern, label)) {
                         return true;
                     }
                 }
@@ -112,7 +112,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean
             LabelSetSpec tableLabels = tableSpec.getLabels();
             if (tableLabels != null && !tableLabels.isEmpty()) {
                 for (String label : tableLabels) {
-                    if (this.labelPattern.match(label)) {
+                    if (SearchPattern.matchAny(this.labelPattern, label)) {
                         return true;
                     }
                 }
diff --git a/dqops/src/main/java/com/dqops/metadata/search/pattern/SearchPattern.java b/dqops/src/main/java/com/dqops/metadata/search/pattern/SearchPattern.java
@@ -17,6 +17,7 @@
 package com.dqops.metadata.search.pattern;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.apache.commons.lang3.StringUtils;
 
 import java.util.AbstractMap;
 import java.util.Map;
@@ -82,6 +83,12 @@ protected static AbstractSearchPatternStrategy determineSearchPatternStrategy(bo
         }
     }
 
+    /**
+     * Creates a search pattern for a given configuration.
+     * @param ignoreCase Ignore case.
+     * @param patternString Pattern text.
+     * @return Search pattern.
+     */
     public static SearchPattern create(boolean ignoreCase, String patternString) {
         if (patternString == null) {
             throw new IllegalArgumentException("Search pattern is null.");
@@ -91,13 +98,63 @@ public static SearchPattern create(boolean ignoreCase, String patternString) {
         return new SearchPattern(patternString, searchPatternStrategy);
     }
 
+    /**
+     * Creates an array of search patterns for values that are comma separated.
+     * @param ignoreCase Ignore case.
+     * @param patternString Pattern text with comma separated values.
+     * @return Search pattern.
+     */
+    public static SearchPattern[] createForCommaSeparatedPatterns(boolean ignoreCase, String patternString) {
+        if (patternString == null) {
+            throw new IllegalArgumentException("Search pattern is null.");
+        }
+
+        String[] textPatterns = StringUtils.split(patternString, ',');
+        if (textPatterns.length == 0) {
+            return null;
+        }
+
+        SearchPattern[] searchPatterns = new SearchPattern[textPatterns.length];
+        for (int i = 0; i < searchPatterns.length; i++) {
+            String pattern = textPatterns[i];
+            AbstractSearchPatternStrategy searchPatternStrategy = determineSearchPatternStrategy(ignoreCase, pattern);
+            searchPatterns[i] = new SearchPattern(pattern, searchPatternStrategy);
+        }
+
+        return searchPatterns;
+    }
+
+    /**
+     * Tests a text if it matches the pattern.
+     * @param otherString Text to verify.
+     * @return True when the value matches a pattern.
+     */
     public boolean match(String otherString) {
         if (this.searchPatternStrategy == null) {
             return false;
         }
         return this.searchPatternStrategy.match(otherString);
     }
 
+    /**
+     * Tests the text if it matches any pattern from the array of check patterns.
+     * @param patterns Array of check patterns.
+     * @param text Text to verify.
+     * @return True when it matches any pattern.
+     */
+    public static boolean matchAny(SearchPattern[] patterns, String text) {
+        for (SearchPattern pattern : patterns) {
+            if (pattern.match(text)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if the pattern contains a wildcard character '*'.
+     */
     @JsonIgnore
     public boolean isWildcardSearchPattern() {
         if (this.searchPatternStrategy == null) {

Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,8 @@`
`29`	`29`	`* Target column filter for default checks that uses parsed patterns.`
`30`	`30`	`*/`
`31`	`31`	`public class TargetColumnPatternFilter extends TargetTablePatternFilter {`
`32`		`- private SearchPattern columnPattern;`
`33`		`- private SearchPattern dataTypePattern;`
	`32`	`+ private SearchPattern[] columnPattern;`
	`33`	`+ private SearchPattern[] dataTypePattern;`
`34`	`34`	`private DataTypeCategory dataTypeCategory;`
`35`	`35`
`36`	`36`	`/**`
`@@ -41,11 +41,11 @@ public TargetColumnPatternFilter(TargetColumnPatternSpec columnPatternSpec) {`
`41`	`41`	`super(columnPatternSpec);`
`42`	`42`
`43`	`43`	`if (!Strings.isNullOrEmpty(columnPatternSpec.getColumn())) {`
`44`		`- this.columnPattern = SearchPattern.create(false, columnPatternSpec.getColumn());`
	`44`	`+ this.columnPattern = SearchPattern.createForCommaSeparatedPatterns(false, columnPatternSpec.getColumn());`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`if (!Strings.isNullOrEmpty(columnPatternSpec.getDataType())) {`
`48`		`- this.dataTypePattern = SearchPattern.create(false, columnPatternSpec.getDataType());`
	`48`	`+ this.dataTypePattern = SearchPattern.createForCommaSeparatedPatterns(false, columnPatternSpec.getDataType());`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`this.dataTypeCategory = columnPatternSpec.getDataTypeCategory();`
`@@ -61,13 +61,13 @@ public TargetColumnPatternFilter(TargetColumnPatternSpec columnPatternSpec) {`
`61`	`61`	`*/`
`62`	`62`	`public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, ColumnSpec columnSpec, DataTypeCategory dataTypeCategory) {`
`63`	`63`	`if (this.columnPattern != null) {`
`64`		`- if (!this.columnPattern.match(columnSpec.getColumnName())) {`
	`64`	`+ if (!SearchPattern.matchAny(this.columnPattern, columnSpec.getColumnName())) {`
`65`	`65`	`return false;`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`if (this.dataTypePattern != null) {`
`70`		`- if (columnSpec.getTypeSnapshot() == null \|\| !this.dataTypePattern.match(columnSpec.getTypeSnapshot().getColumnType())) {`
	`70`	`+ if (columnSpec.getTypeSnapshot() == null \|\| !SearchPattern.matchAny(this.dataTypePattern, columnSpec.getTypeSnapshot().getColumnType())) {`
`71`	`71`	`return false;`
`72`	`72`	`}`
`73`	`73`	`}`
`@@ -86,7 +86,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, ColumnS`
`86`	`86`	`LabelSetSpec columnSpecLabels = columnSpec.getLabels();`
`87`	`87`	`if (columnSpecLabels != null && !columnSpecLabels.isEmpty()) {`
`88`	`88`	`for (String label : columnSpecLabels) {`
`89`		`- if (this.labelPattern.match(label)) {`
	`89`	`+ if (SearchPattern.matchAny(this.labelPattern, label)) {`
`90`	`90`	`return true;`
`91`	`91`	`}`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,36 +26,36 @@`
`26`	`26`	`* Target table filter for default checks that uses parsed patterns.`
`27`	`27`	`*/`
`28`	`28`	`public class TargetTablePatternFilter {`
`29`		`- private SearchPattern connectionPattern;`
`30`		`- private SearchPattern schemaPattern;`
`31`		`- private SearchPattern tablePattern;`
`32`		`- private SearchPattern stagePattern;`
	`29`	`+ private SearchPattern[] connectionPattern;`
	`30`	`+ private SearchPattern[] schemaPattern;`
	`31`	`+ private SearchPattern[] tablePattern;`
	`32`	`+ private SearchPattern[] stagePattern;`
`33`	`33`	`private Integer tablePriority;`
`34`		`- protected SearchPattern labelPattern;`
	`34`	`+ protected SearchPattern[] labelPattern;`
`35`	`35`
`36`	`36`	`/**`
`37`	`37`	`* Creates a table pattern search object given a target table pattern specification. Creates search patterns for filled fields.`
`38`	`38`	`* @param tablePatternSpec Target table search pattern.`
`39`	`39`	`*/`
`40`	`40`	`public TargetTablePatternFilter(TargetTablePatternSpec tablePatternSpec) {`
`41`	`41`	`if (!Strings.isNullOrEmpty(tablePatternSpec.getConnection())) {`
`42`		`- this.connectionPattern = SearchPattern.create(false, tablePatternSpec.getConnection());`
	`42`	`+ this.connectionPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getConnection());`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`if (!Strings.isNullOrEmpty(tablePatternSpec.getSchema())) {`
`46`		`- this.schemaPattern = SearchPattern.create(false, tablePatternSpec.getSchema());`
	`46`	`+ this.schemaPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getSchema());`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`if (!Strings.isNullOrEmpty(tablePatternSpec.getTable())) {`
`50`		`- this.tablePattern = SearchPattern.create(false, tablePatternSpec.getTable());`
	`50`	`+ this.tablePattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getTable());`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`if (!Strings.isNullOrEmpty(tablePatternSpec.getStage())) {`
`54`		`- this.stagePattern = SearchPattern.create(false, tablePatternSpec.getStage());`
	`54`	`+ this.stagePattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getStage());`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`if (!Strings.isNullOrEmpty(tablePatternSpec.getLabel())) {`
`58`		`- this.labelPattern = SearchPattern.create(false, tablePatternSpec.getLabel());`
	`58`	`+ this.labelPattern = SearchPattern.createForCommaSeparatedPatterns(false, tablePatternSpec.getLabel());`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`this.tablePriority = tablePatternSpec.getTablePriority();`
`@@ -70,25 +70,25 @@ public TargetTablePatternFilter(TargetTablePatternSpec tablePatternSpec) {`
`70`	`70`	`*/`
`71`	`71`	`public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean matchLabels) {`
`72`	`72`	`if (this.connectionPattern != null) {`
`73`		`- if (!this.connectionPattern.match(connectionSpec.getConnectionName())) {`
	`73`	`+ if (!SearchPattern.matchAny(this.connectionPattern, connectionSpec.getConnectionName())) {`
`74`	`74`	`return false;`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`if (this.schemaPattern != null) {`
`79`		`- if (!this.schemaPattern.match(tableSpec.getPhysicalTableName().getSchemaName())) {`
	`79`	`+ if (!SearchPattern.matchAny(this.schemaPattern, tableSpec.getPhysicalTableName().getSchemaName())) {`
`80`	`80`	`return false;`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`if (this.tablePattern != null) {`
`85`		`- if (!this.tablePattern.match(tableSpec.getPhysicalTableName().getTableName())) {`
	`85`	`+ if (!SearchPattern.matchAny(this.tablePattern, tableSpec.getPhysicalTableName().getTableName())) {`
`86`	`86`	`return false;`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`if (this.stagePattern != null) {`
`91`		`- if (!this.stagePattern.match(tableSpec.getStage())) {`
	`91`	`+ if (!SearchPattern.matchAny(this.stagePattern, tableSpec.getStage())) {`
`92`	`92`	`return false;`
`93`	`93`	`}`
`94`	`94`	`}`
`@@ -103,7 +103,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean`
`103`	`103`	`LabelSetSpec connectionLabels = connectionSpec.getLabels();`
`104`	`104`	`if (connectionLabels != null && !connectionLabels.isEmpty()) {`
`105`	`105`	`for (String label : connectionLabels) {`
`106`		`- if (this.labelPattern.match(label)) {`
	`106`	`+ if (SearchPattern.matchAny(this.labelPattern, label)) {`
`107`	`107`	`return true;`
`108`	`108`	`}`
`109`	`109`	`}`
`@@ -112,7 +112,7 @@ public boolean match(ConnectionSpec connectionSpec, TableSpec tableSpec, boolean`
`112`	`112`	`LabelSetSpec tableLabels = tableSpec.getLabels();`
`113`	`113`	`if (tableLabels != null && !tableLabels.isEmpty()) {`
`114`	`114`	`for (String label : tableLabels) {`
`115`		`- if (this.labelPattern.match(label)) {`
	`115`	`+ if (SearchPattern.matchAny(this.labelPattern, label)) {`
`116`	`116`	`return true;`
`117`	`117`	`}`
`118`	`118`	`}`