private boolean determineHasTableTypes() { for (EventType type : eventTypes) { if (type instanceof EventTypeSPI) { EventTypeSPI typeSPI = (EventTypeSPI) type; if (typeSPI.getMetadata().getTypeClass() == EventTypeTypeClass.TABLE_PUBLIC || typeSPI.getMetadata().getTypeClass() == EventTypeTypeClass.TABLE_INTERNAL) { return true; } } } return false; }
private void processEvent(EventBean theEvent) { EventTypeSPI spi = (EventTypeSPI) theEvent.getEventType(); EventBeanReader reader = spi.getReader(); Object[] props = reader.read(theEvent); String[] names = spi.getPropertyNames(); Map<String, String> parameters = formPairs(names, props, "stream", stream); URI requestURI; if (uriPrecompiled != null) { requestURI = URIUtil.withQuery(uriPrecompiled, parameters); } else { String uri = formURI(parameters, fragments); try { requestURI = new URI(uri); } catch (URISyntaxException e) { log.error("Incorrect URI generated: " + e.getMessage(), e); return; } } if (log.isDebugEnabled()) { log.debug("Requesting from URI " + requestURI); } HttpGet httpget = new HttpGet(requestURI); try { httpclient.execute(httpget, responseHandler); } catch (IOException e) { log.warn("Error executing request:" + e.getMessage()); } }
for (EventPropertyDescriptor writableUndProp : spi.getWriteableProperties()) { final String propertyName = writableUndProp.getPropertyName(); final EventPropertyWriter innerWriter = spi.getWriter(propertyName); if (innerWriter == null) { continue;
public ExprNode validate(ExprValidationContext validationContext) throws ExprValidationException { if (validationContext.getContextDescriptor() == null) { throw new ExprValidationException("Context property '" + propertyName + "' cannot be used in the expression as provided"); } EventTypeSPI eventType = (EventTypeSPI) validationContext.getContextDescriptor().getContextPropertyRegistry().getContextEventType(); if (eventType == null) { throw new ExprValidationException("Context property '" + propertyName + "' cannot be used in the expression as provided"); } getter = eventType.getGetterSPI(propertyName); if (getter == null) { throw new ExprValidationException("Context property '" + propertyName + "' is not a known property, known properties are " + Arrays.toString(eventType.getPropertyNames())); } returnType = JavaClassHelper.getBoxedType(eventType.getPropertyType(propertyName)); return null; }
EventPropertyWriterSPI writer = spi.getWriter(subPropertyName); EventPropertyGetterSPI getter = spi.getGetterSPI(subPropertyName); Class getterType = spi.getPropertyType(subPropertyName); if (writer == null) { throw new ExprValidationException("Variable by name '" + variableName + "' the property '" + subPropertyName + "' is not writable"); variableTypes.put(fullVariableName, spi.getPropertyType(subPropertyName)); CopyMethodDesc writtenProps = eventTypeWrittenProps.get(spi); if (writtenProps == null) { List<String> propsWritten = entry.getValue().getPropertiesCopied(); String[] props = propsWritten.toArray(new String[propsWritten.size()]); EventBeanCopyMethodForge copyMethod = entry.getKey().getCopyMethodForge(props); if (copyMethod == null) { throw new ExprValidationException("Variable '" + entry.getValue().getVariableName() + "' of declared type " + JavaClassHelper.getClassNameFullyQualPretty(entry.getKey().getUnderlyingType()) + "' cannot be assigned to");
EventPropertyDescriptor writableProperty = eventTypeSPI.getWritableProperty(propertyName); EventPropertyWriterSPI writers = eventTypeSPI.getWriter(propertyName); boolean notNullableField = writableProperty.getPropertyType().isPrimitive(); ExprIdentNode node = (ExprIdentNode) possibleAssignment.getSecond(); FragmentEventType fragmentRHS = optionalTriggeringEventType.getFragmentType(node.getResolvedPropertyName()); FragmentEventType fragmentLHS = eventTypeSPI.getFragmentType(possibleAssignment.getFirst()); if (fragmentRHS != null && fragmentLHS != null && !EventTypeUtility.isTypeOrSubTypeOf(fragmentRHS.getFragmentType(), fragmentLHS.getFragmentType())) { throw new ExprValidationException("Invalid assignment to property '" + copyMethod = eventTypeSPI.getCopyMethodForge(propertiesArray); if (copyMethod == null) { throw new ExprValidationException("Event type does not support event bean copy"); if (!propertiesInitialValue.isEmpty()) { String[] propertiesInitialValueArray = propertiesInitialValue.toArray(new String[propertiesInitialValue.size()]); copyMethod = eventTypeSPI.getCopyMethodForge(propertiesInitialValueArray);
public static EventPropertyGetterSPI[] getGetters(EventType eventType, String[] props) { EventPropertyGetterSPI[] getters = new EventPropertyGetterSPI[props.length]; EventTypeSPI spi = (EventTypeSPI) eventType; for (int i = 0; i < getters.length; i++) { getters[i] = spi.getGetterSPI(props[i]); } return getters; }
public OutputProcessViewDirectDistinctOrAfterFactory(OutputStrategyPostProcessFactory postProcessFactory, boolean distinct, TimePeriodCompute afterTimePeriod, Integer afterConditionNumberOfEvents, EventType resultEventType) { super(postProcessFactory); isDistinct = distinct; this.afterTimePeriod = afterTimePeriod; this.afterConditionNumberOfEvents = afterConditionNumberOfEvents; if (isDistinct) { if (resultEventType instanceof EventTypeSPI) { EventTypeSPI eventTypeSPI = (EventTypeSPI) resultEventType; eventBeanReader = eventTypeSPI.getReader(); } if (eventBeanReader == null) { eventBeanReader = new EventBeanReaderDefaultImpl(resultEventType); } } }
EventTypeSPI spi = (EventTypeSPI) underlyingEventType; for (int i = 0; i < properties.length; i++) { if (spi.getWritableProperty(properties[i]) == null) { isOnlyUnderlying = false; EventBeanWriter undWriter = spi.getWriter(properties); if (undWriter == null) { return undWriter;
EventBeanWriter writer = eventTypeSPI.getWriter(entry.getKey().getProperties()); desc.add(new InternalEventRouterEntry(priority, isDrop, entry.getValue().getOptionalWhereClauseEvaluator(), entry.getKey().getAssignments(), writer, entry.getValue().getWideners(), entry.getValue().getOutputView(), entry.getValue().getAgentInstanceLock(), entry.getValue().hasSubselect)); EventBeanCopyMethodForge copyMethodForge = eventTypeSPI.getCopyMethodForge(eventPropertiesWritten.toArray(new String[eventPropertiesWritten.size()])); if (copyMethodForge == null) { return new NullableObject<>(null);
for (int i = 0; i < validationContext.getStreamTypeService().getEventTypes().length; i++) { if (types[i] instanceof EventTypeSPI) { hasPropertyAgnosticType |= ((EventTypeSPI) types[i]).getMetadata().isPropertyAgnostic(); throw new ExprValidationException("Property '" + optSubPropName + "' is not valid for variable '" + variableName + "'"); optSubPropGetter = ((EventTypeSPI) variableMeta.getEventType()).getGetterSPI(optSubPropName); if (optSubPropGetter == null) { throw new ExprValidationException("Property '" + optSubPropName + "' is not valid for variable '" + variableName + "'");
getter = ((EventTypeSPI) streamType).getGetterSPI(propertyInfoPair.getFirst().getPropertyName()); throw new ExprValidationException("Parameter expression to mapped property '" + propertyName + "' is expected to return a string-type value but returns " + JavaClassHelper.getClassNameFullyQualPretty(paramEval.getEvaluationType())); EventPropertyGetterMappedSPI mappedGetter = ((EventTypeSPI) propertyInfoPair.getFirst().getStreamEventType()).getGetterMappedSPI(propertyInfoPair.getFirst().getPropertyName()); if (mappedGetter == null) { throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object"); throw new ExprValidationException("Parameter expression to mapped property '" + propertyName + "' is expected to return a Integer-type value but returns " + JavaClassHelper.getClassNameFullyQualPretty(paramEval.getEvaluationType())); EventPropertyGetterIndexedSPI indexedGetter = ((EventTypeSPI) propertyInfoPair.getFirst().getStreamEventType()).getGetterIndexedSPI(propertyInfoPair.getFirst().getPropertyName()); if (indexedGetter == null) { throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object");
if (spi.getWritableProperty(properties[i]) == null) { isOnlyUnderlying = false; EventBeanCopyMethodForge undCopyMethod = ((EventTypeSPI) underlyingEventType).getCopyMethodForge(properties); if (undCopyMethod == null) { return null;
Class type = inputEventType.getPropertyType(chainElement.getName()); EventPropertyGetterSPI getter = inputEventType.getGetterSPI(chainElement.getName()); if (type != null && getter != null) { ExprDotForgeProperty noduck = new ExprDotForgeProperty(getter, EPTypeHelper.singleValue(JavaClassHelper.getBoxedType(type)));
public BeaconSourceOp(BeaconSourceFactory factory, long iterations, long initialDelayMSec, long periodDelayMSec, Map<String, Object> additionalParameters) { this.factory = factory; this.iterations = iterations; this.initialDelayMSec = initialDelayMSec; this.periodDelayMSec = periodDelayMSec; if (additionalParameters != null) { additionalProperties = new Pair[additionalParameters.size()]; int count = 0; for (Map.Entry<String, Object> param : additionalParameters.entrySet()) { EventPropertyWriter writer = ((EventTypeSPI) factory.getOutputEventType()).getWriter(param.getKey()); if (writer == null) { throw new EPException("Failed to find writer for property '" + param.getKey() + "' for event type '" + factory.getOutputEventType().getName() + "'"); } additionalProperties[count++] = new Pair<>(writer, param.getValue()); } } }
throw new ExprValidationException("Parameter expression to mapped property '" + propertyDesc.getPropertyName() + "' is expected to return a string-type value but returns " + JavaClassHelper.getClassNameFullyQualPretty(parameterForge.getEvaluationType())); mappedGetter = ((EventTypeSPI) propertyInfoPair.getFirst().getStreamEventType()).getGetterMappedSPI(propertyInfoPair.getFirst().getPropertyName()); if (mappedGetter == null) { throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object"); throw new ExprValidationException("Parameter expression to indexed property '" + propertyDesc.getPropertyName() + "' is expected to return a Integer-type value but returns " + JavaClassHelper.getClassNameFullyQualPretty(parameterForge.getEvaluationType())); indexedGetter = ((EventTypeSPI) propertyInfoPair.getFirst().getStreamEventType()).getGetterIndexedSPI(propertyInfoPair.getFirst().getPropertyName()); if (indexedGetter == null) { throw new ExprValidationException("Indexed property named '" + propertyName + "' failed to obtain getter-object");
public static void compareExistingType(EventType newEventType, EventType existingType) throws ExprValidationException { ExprValidationException compared = ((EventTypeSPI) newEventType).equalsCompareType(existingType); if (compared != null) { throw new ExprValidationException("Event type named '" + newEventType.getName() + "' has already been declared with differing column name or type information: " + compared.getMessage(), compared); } }
public EventPropertyGetterMappedSPI getGetterMappedSPI(String mappedProperty) { final EventPropertyGetterMappedSPI undMapped = ((EventTypeSPI) underlyingEventType).getGetterMappedSPI(mappedProperty); if (undMapped != null) { return new WrapperGetterMapped(undMapped);
public EventPropertyGetterIndexedSPI getGetterIndexedSPI(String indexedProperty) { final EventPropertyGetterIndexedSPI undIndexed = ((EventTypeSPI) underlyingEventType).getGetterIndexedSPI(indexedProperty); if (undIndexed != null) { return new WrapperGetterIndexed(undIndexed);
public ExprIdentNodeImpl(EventType eventType, String propertyName, int streamNumber) { unresolvedPropertyName = propertyName; resolvedPropertyName = propertyName; EventPropertyGetterSPI propertyGetter = ((EventTypeSPI) eventType).getGetterSPI(propertyName); if (propertyGetter == null) { throw new IllegalArgumentException("Ident-node constructor could not locate property " + propertyName); } Class propertyType = eventType.getPropertyType(propertyName); evaluator = new ExprIdentNodeEvaluatorImpl(streamNumber, propertyGetter, JavaClassHelper.getBoxedType(propertyType), this, eventType, true, false); }