[ML] Add categorical exclude condition (elastic/x-pack-elasticsearch#4326)

Original commit: elastic/x-pack-elasticsearch@6c80988e08

plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/job/config/DetectionRule.java

@@ -251,7 +251,7 @@ public class DetectionRule implements ToXContentObject, Writeable {
                 throw ExceptionsHelper.badRequestException(msg);
             }
             for (RuleCondition condition : conditions) {
-                if (condition.getType() == RuleConditionType.CATEGORICAL && targetFieldName != null) {
+                if (condition.getType().isCategorical() && targetFieldName != null) {
                     String msg = Messages.getMessage(Messages.JOB_CONFIG_DETECTION_RULE_CONDITION_CATEGORICAL_INVALID_OPTION,
                             DetectionRule.TARGET_FIELD_NAME_FIELD.getPreferredName());
                     throw ExceptionsHelper.badRequestException(msg);

plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/job/config/Detector.java

@@ -698,6 +698,7 @@ public class Detector implements ToXContentObject, Writeable {
                 List<String> validOptions = Collections.emptyList();
                 switch (condition.getType()) {
                     case CATEGORICAL:
+                    case CATEGORICAL_COMPLEMENT:
                         validOptions = extractAnalysisFields();
                         break;
                     case NUMERICAL_ACTUAL:

plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/job/config/RuleCondition.java

@@ -197,6 +197,7 @@ public class RuleCondition implements ToXContentObject, Writeable {
     private static void verifyFieldsBoundToType(RuleCondition ruleCondition) throws ElasticsearchParseException {
         switch (ruleCondition.getType()) {
         case CATEGORICAL:
+        case CATEGORICAL_COMPLEMENT:
             verifyCategorical(ruleCondition);
             break;
         case NUMERICAL_ACTUAL:

plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/job/config/RuleConditionType.java

@@ -6,6 +6,7 @@
 package org.elasticsearch.xpack.core.ml.job.config;
 
 
+import org.elasticsearch.Version;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
@@ -14,22 +15,29 @@ import java.io.IOException;
 import java.util.Locale;
 
 public enum RuleConditionType implements Writeable {
-    CATEGORICAL(false),
+    CATEGORICAL(false, true),
-    NUMERICAL_ACTUAL(true),
+    NUMERICAL_ACTUAL(true, false),
-    NUMERICAL_TYPICAL(true),
+    NUMERICAL_TYPICAL(true, false),
-    NUMERICAL_DIFF_ABS(true),
+    NUMERICAL_DIFF_ABS(true, false),
-    TIME(false);
+    TIME(false, false),
+    CATEGORICAL_COMPLEMENT(false, true);
 
     private final boolean isNumerical;
+    private final boolean isCategorical;
 
-    RuleConditionType(boolean isNumerical) {
+    RuleConditionType(boolean isNumerical, boolean isCategorical) {
         this.isNumerical = isNumerical;
+        this.isCategorical = isCategorical;
     }
 
     public boolean isNumerical() {
         return isNumerical;
     }
 
+    public boolean isCategorical() {
+        return isCategorical;
+    }
+
     /**
      * Case-insensitive from string method.
      *
@@ -47,7 +55,11 @@ public enum RuleConditionType implements Writeable {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        out.writeEnum(this);
+        if (this == CATEGORICAL_COMPLEMENT && out.getVersion().before(Version.V_6_3_0)) {
+            out.writeEnum(CATEGORICAL);
+        } else {
+            out.writeEnum(this);
+        }
     }
 
     @Override

plugin/core/src/test/java/org/elasticsearch/xpack/core/ml/job/config/RuleConditionTests.java

@@ -19,25 +19,22 @@ public class RuleConditionTests extends AbstractSerializingTestCase<RuleConditio
         String fieldName = null;
         String valueFilter = null;
         String fieldValue = null;
-        RuleConditionType r = randomFrom(RuleConditionType.values());
+        RuleConditionType type = randomFrom(RuleConditionType.values());
-        switch (r) {
+        if (type.isCategorical()) {
-        case CATEGORICAL:
             valueFilter = randomAlphaOfLengthBetween(1, 20);
             if (randomBoolean()) {
                 fieldName = randomAlphaOfLengthBetween(1, 20);
             }
-            break;
+        } else {
-        default:
+            // no need to randomize, it is properly randomly tested in
-            // no need to randomize, it is properly randomily tested in
             // ConditionTest
             condition = new Condition(Operator.LT, Long.toString(randomLong()));
             if (randomBoolean()) {
                 fieldName = randomAlphaOfLengthBetween(1, 20);
                 fieldValue = randomAlphaOfLengthBetween(1, 20);
             }
-            break;
         }
-        return new RuleCondition(r, fieldName, fieldValue, condition, valueFilter);
+        return new RuleCondition(type, fieldName, fieldValue, condition, valueFilter);
     }
 
     @Override
@@ -201,6 +198,7 @@ public class RuleConditionTests extends AbstractSerializingTestCase<RuleConditio
     public void testVerify_GivenValidCategorical() {
         // no validation error:
         new RuleCondition(RuleConditionType.CATEGORICAL, "metric", null, null, "myFilter");
+        new RuleCondition(RuleConditionType.CATEGORICAL_COMPLEMENT, "metric", null, null, "myFilter");
     }
 
     public void testVerify_GivenValidNumericalActual() {

plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/config/RuleConditionTypeTests.java

@@ -31,6 +31,7 @@ public class RuleConditionTypeTests extends ESTestCase {
 
     public void testToString() {
         assertEquals("categorical", RuleConditionType.CATEGORICAL.toString());
+        assertEquals("categorical_complement", RuleConditionType.CATEGORICAL_COMPLEMENT.toString());
         assertEquals("numerical_actual", RuleConditionType.NUMERICAL_ACTUAL.toString());
         assertEquals("numerical_typical", RuleConditionType.NUMERICAL_TYPICAL.toString());
         assertEquals("numerical_diff_abs", RuleConditionType.NUMERICAL_DIFF_ABS.toString());
@@ -122,7 +123,18 @@ public class RuleConditionTypeTests extends ESTestCase {
             } else {
                 assertFalse(isNumerical);
             }
+        }
+    }
 
+    public void testIsCategorical() {
+        for (RuleConditionType type : EnumSet.allOf(RuleConditionType.class)) {
+            boolean isCategorical = type.isCategorical();
+            if (type == RuleConditionType.CATEGORICAL ||
+                    type == RuleConditionType.CATEGORICAL_COMPLEMENT) {
+                assertTrue(isCategorical);
+            } else {
+                assertFalse(isCategorical);
+            }
         }
     }
 }