private MultiKeyUntyped getKeys(EventBean event) {
   Object[] keys = new Object[partitionExpressions.length];
   eventsPerStream[0] = event;
   int count = 0;
   for (ExprEvaluator node : partitionExpressions) {
     keys[count++] = node.evaluate(eventsPerStream, true, exprEvaluatorContext);
   }
   return new MultiKeyUntyped(keys);
 }
 public boolean matches(EventBean[] eventsPerStream, ExprEvaluatorContext exprEvaluatorContext) {
   if (exprNode == null) {
     return true;
   }
   Boolean result = (Boolean) exprNode.evaluate(eventsPerStream, true, exprEvaluatorContext);
   if (result != null) {
     return result;
   }
   return false;
 }
Beispiel #3
0
  public Object evaluate(
      long startTs,
      long endTs,
      EventBean[] eventsPerStream,
      boolean isNewData,
      ExprEvaluatorContext context) {
    Object parameter = evaluatorTimestamp.evaluate(eventsPerStream, isNewData, context);
    if (parameter == null) {
      return parameter;
    }

    return intervalOpEval.evaluate(startTs, endTs, parameter, eventsPerStream, isNewData, context);
  }
Beispiel #4
0
 public Object evaluate(
     long startTs,
     long endTs,
     Object parameterStartTs,
     EventBean[] eventsPerStream,
     boolean isNewData,
     ExprEvaluatorContext context) {
   Object paramEndTs = evaluatorEndTimestamp.evaluate(eventsPerStream, isNewData, context);
   if (paramEndTs == null) {
     return null;
   }
   return evaluate(
       startTs, endTs, parameterStartTs, paramEndTs, eventsPerStream, isNewData, context);
 }
  private static Object coerceProperty(
      String propertyName,
      Class containingType,
      Object value,
      Class type,
      EngineImportService engineImportService,
      boolean forceNumeric)
      throws ExprValidationException {
    if (value instanceof ExprNode && type != ExprNode.class) {
      if (value instanceof ExprIdentNode) {
        ExprIdentNode identNode = (ExprIdentNode) value;
        Property prop;
        try {
          prop = PropertyParser.parse(identNode.getFullUnresolvedName(), false);
        } catch (Exception ex) {
          throw new ExprValidationException(
              "Failed to parse property '" + identNode.getFullUnresolvedName() + "'");
        }
        if (!(prop instanceof MappedProperty)) {
          throw new ExprValidationException(
              "Unrecognized property '" + identNode.getFullUnresolvedName() + "'");
        }
        MappedProperty mappedProperty = (MappedProperty) prop;
        if (mappedProperty.getPropertyNameAtomic().toLowerCase().equals(SYSTEM_PROPETIES_NAME)) {
          return System.getProperty(mappedProperty.getKey());
        }
      } else {
        ExprNode exprNode = (ExprNode) value;
        ExprEvaluator evaluator = exprNode.getExprEvaluator();
        if (evaluator == null) {
          throw new ExprValidationException(
              "Failed to evaluate expression '" + exprNode.toExpressionString() + "'");
        }
        value = evaluator.evaluate(null, true, null);
      }
    }

    if (value == null) {
      return null;
    }
    if (value.getClass() == type) {
      return value;
    }
    if (JavaClassHelper.isAssignmentCompatible(value.getClass(), type)) {
      if (forceNumeric
          && JavaClassHelper.getBoxedType(value.getClass()) != JavaClassHelper.getBoxedType(type)
          && JavaClassHelper.isNumeric(type)
          && JavaClassHelper.isNumeric(value.getClass())) {
        value = JavaClassHelper.coerceBoxed((Number) value, JavaClassHelper.getBoxedType(type));
      }
      return value;
    }
    if (JavaClassHelper.isSubclassOrImplementsInterface(value.getClass(), type)) {
      return value;
    }
    if (type.isArray()) {
      if (!(value instanceof Collection)) {
        throw new ExprValidationException(
            "Property '"
                + propertyName
                + "' of class "
                + JavaClassHelper.getClassNameFullyQualPretty(containingType)
                + " expects an array but receives a value of type "
                + value.getClass().getName());
      }
      Object[] items = ((Collection) value).toArray();
      Object coercedArray = Array.newInstance(type.getComponentType(), items.length);
      for (int i = 0; i < items.length; i++) {
        Object coercedValue =
            coerceProperty(
                propertyName + " (array element)",
                type,
                items[i],
                type.getComponentType(),
                engineImportService,
                false);
        Array.set(coercedArray, i, coercedValue);
      }
      return coercedArray;
    }
    if (!(value instanceof Map)) {
      throw new ExprValidationException(
          "Property '"
              + propertyName
              + "' of class "
              + JavaClassHelper.getClassNameFullyQualPretty(containingType)
              + " expects an "
              + JavaClassHelper.getClassNameFullyQualPretty(type)
              + " but receives a value of type "
              + value.getClass().getName());
    }
    Map<String, Object> props = (Map<String, Object>) value;
    return instantiatePopulateObject(props, type, engineImportService);
  }