public static void Reset(
ILockManager lockManager,
ClassLoaderProvider classLoaderProvider)
{
_eventAdapterService = Allocate(lockManager, classLoaderProvider);
}
public EventPropertyGetter GetPropertyProvidedGetter(IDictionary <String, Object> nestableTypes, String propertyName, Property prop, EventAdapterService eventAdapterService)
{
return(prop.GetGetterObjectArray(PropertiesIndex, nestableTypes, eventAdapterService));
}
public EventPropertyGetter GetGetterBeanNestedArray(String name, EventType eventType, EventAdapterService eventAdapterService)
{
int index = GetAssertIndex(name);
return(new ObjectArrayFragmentArrayPropertyGetter(index, eventType, eventAdapterService));
}
public EventPropertyGetter GetGetterNestedPONOProp(String propertyName, BeanEventPropertyGetter nestedGetter, EventAdapterService eventAdapterService, Type nestedReturnType, Type nestedComponentType)
{
int index = GetAssertIndex(propertyName);
return(new ObjectArrayPONOEntryPropertyGetter(index, nestedGetter, eventAdapterService, nestedReturnType, nestedComponentType));
}
public EventPropertyGetter GetGetterBeanNested(String name, EventType eventType, EventAdapterService eventAdapterService)
{
int index = GetAssertIndex(name);
if (eventType is ObjectArrayEventType)
{
return(new ObjectArrayPropertyGetterDefaultObjectArray(index, eventType, eventAdapterService));
}
return(new ObjectArrayPropertyGetterDefaultMap(index, eventType, eventAdapterService));
}
public EventType GetEventTypeSingle(EventAdapterService eventAdapterService, int statementId)
{
return(null);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="streamNames">name of each stream</param>
/// <param name="streamTypes">type of each stream</param>
/// <param name="eventAdapterService">service for generating events and handling event types</param>
/// <param name="insertIntoDesc">describes the insert-into clause</param>
/// <param name="selectExprEventTypeRegistry">registry for event type to statements</param>
/// <param name="engineImportService"></param>
/// <param name="annotations">The annotations.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="tableService">The table service.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Stream names and types parameter length is invalid, expected use of this class is for join statements</exception>
/// <exception cref="ExprValidationException"></exception>
/// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the expression validation failed</throws>
public static SelectExprProcessor Create(ICollection <int> assignedTypeNumberStack, int statementId, string[] streamNames, EventType[] streamTypes, EventAdapterService eventAdapterService, InsertIntoDesc insertIntoDesc, SelectExprEventTypeRegistry selectExprEventTypeRegistry, EngineImportService engineImportService, Attribute[] annotations, ConfigurationInformation configuration, TableService tableService)
{
if ((streamNames.Length < 2) || (streamTypes.Length < 2) || (streamNames.Length != streamTypes.Length))
{
throw new ArgumentException(
"Stream names and types parameter length is invalid, expected use of this class is for join statements");
}
// Create EventType of result join events
var eventTypeMap = new LinkedHashMap <string, object>();
var streamTypesWTables = new EventType[streamTypes.Length];
var hasTables = false;
for (var i = 0; i < streamTypes.Length; i++)
{
streamTypesWTables[i] = streamTypes[i];
var tableName = TableServiceUtil.GetTableNameFromEventType(streamTypesWTables[i]);
if (tableName != null)
{
hasTables = true;
streamTypesWTables[i] = tableService.GetTableMetadata(tableName).PublicEventType;
}
eventTypeMap.Put(streamNames[i], streamTypesWTables[i]);
}
// If we have a name for this type, add it
var useMap = EventRepresentationUtil.IsMap(annotations, configuration, AssignedType.NONE);
EventType resultEventType;
SelectExprProcessor processor = null;
if (insertIntoDesc != null)
{
EventType existingType = eventAdapterService.GetEventTypeByName(insertIntoDesc.EventTypeName);
if (existingType != null)
{
processor = SelectExprInsertEventBeanFactory.GetInsertUnderlyingJoinWildcard(
eventAdapterService, existingType, streamNames, streamTypesWTables,
engineImportService);
}
}
if (processor == null)
{
if (insertIntoDesc != null)
{
try
{
if (useMap)
{
resultEventType = eventAdapterService.AddNestableMapType(
insertIntoDesc.EventTypeName, eventTypeMap, null, false, false, false, false, true);
}
else
{
resultEventType = eventAdapterService.AddNestableObjectArrayType(
insertIntoDesc.EventTypeName, eventTypeMap, null, false, false, false, false, true, false, null);
}
selectExprEventTypeRegistry.Add(resultEventType);
}
catch (EventAdapterException ex)
{
throw new ExprValidationException(ex.Message);
}
}
else
{
if (useMap)
{
resultEventType =
eventAdapterService.CreateAnonymousMapType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"), eventTypeMap, true);
}
else
{
resultEventType =
eventAdapterService.CreateAnonymousObjectArrayType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"), eventTypeMap);
}
}
if (resultEventType is ObjectArrayEventType)
{
processor = new SelectExprJoinWildcardProcessorObjectArray(
streamNames, resultEventType, eventAdapterService);
}
else
{
processor = new SelectExprJoinWildcardProcessorMap(streamNames, resultEventType, eventAdapterService);
}
}
if (!hasTables)
{
return(processor);
}
return(new SelectExprJoinWildcardProcessorTableRows(streamTypes, processor, tableService));
}
public override EnumEval GetEnumEval(EngineImportService engineImportService, EventAdapterService eventAdapterService, StreamTypeService streamTypeService, int statementId, string enumMethodUsedName, IList <ExprDotEvalParam> bodiesAndParameters, EventType inputEventType, Type collectionComponentType, int numStreamsIncoming, bool disablePropertyExpressionEventCollCache)
{
var first = (ExprDotEvalParamLambda)bodiesAndParameters[0];
if (inputEventType != null)
{
base.TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType);
if (first.GoesToNames.Count == 1)
{
if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST)
{
return(new EnumEvalTakeWhileLastEvents(first.BodyEvaluator, first.StreamCountIncoming));
}
return(new EnumEvalTakeWhileEvents(first.BodyEvaluator, first.StreamCountIncoming));
}
if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST)
{
return(new EnumEvalTakeWhileLastIndexEvents(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1]));
}
return(new EnumEvalTakeWhileIndexEvents(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[1]));
}
base.TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType);
if (first.GoesToNames.Count == 1)
{
if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST)
{
return(new EnumEvalTakeWhileLastScalar(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0]));
}
return(new EnumEvalTakeWhileScalar(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0]));
}
if (EnumMethodEnum == EnumMethodEnum.TAKEWHILELAST)
{
return(new EnumEvalTakeWhileLastIndexScalar(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0],
(ObjectArrayEventType)first.GoesToTypes[1]));
}
return(new EnumEvalTakeWhileIndexScalar(
first.BodyEvaluator, first.StreamCountIncoming, (ObjectArrayEventType)first.GoesToTypes[0],
(ObjectArrayEventType)first.GoesToTypes[1]));
}
public override MapEventPropertyGetter GetGetterMap(DataMap optionalMapPropTypes, EventAdapterService eventAdapterService)
{
Object type = optionalMapPropTypes.Get(PropertyNameAtomic);
if (type == null)
{
return(null);
}
if (type is string) // resolve a property that is a map event type
{
String nestedName = type.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
EventType innerType = eventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is MapEventType))
{
return(null);
}
if (!isArray)
{
return(null); // must be declared as an array to use an indexed notation
}
else
{
return(new MapArrayPropertyGetter(PropertyNameAtomic, _index, eventAdapterService, innerType));
}
}
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
Type componentType = ((Type)type).GetElementType();
// its an array
return(new MapArrayEntryIndexedPropertyGetter(PropertyNameAtomic, _index, eventAdapterService,
componentType));
}
}
/// <summary>
/// Returns the processor to use for a given select-clause.
/// </summary>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="selectionList">the list of select clause elements/items, which are expected to have been validated</param>
/// <param name="isUsingWildcard">true if the wildcard (*) occurs in the select clause</param>
/// <param name="insertIntoDesc">contains column names for the optional insert-into clause (if supplied)</param>
/// <param name="optionalInsertIntoEventType">Type of the optional insert into event.</param>
/// <param name="forClauseSpec">For clause spec.</param>
/// <param name="typeService">serves stream type information</param>
/// <param name="eventAdapterService">for generating wrapper instances for events</param>
/// <param name="statementResultService">handles listeners/subscriptions awareness to reduce output result generation</param>
/// <param name="valueAddEventService">service that handles update events and variant events</param>
/// <param name="selectExprEventTypeRegistry">registry for event type to statements</param>
/// <param name="methodResolutionService">for resolving write methods</param>
/// <param name="exprEvaluatorContext">context for expression evalauation</param>
/// <param name="variableService">The variable service.</param>
/// <param name="scriptingService">The scripting service.</param>
/// <param name="tableService">The table service.</param>
/// <param name="timeProvider">The time provider.</param>
/// <param name="engineURI">The engine URI.</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="statementName">Name of the statement.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="contextDescriptor">The context descriptor.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="selectExprProcessorCallback">The select expr processor callback.</param>
/// <param name="namedWindowService">The named window service.</param>
/// <param name="intoTableClause">The into table clause.</param>
/// <returns>
/// select-clause expression processor
/// </returns>
/// <exception cref="ExprValidationException">Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'
/// or
/// The for-clause with the + ForClauseKeyword.GROUPED_DELIVERY.Name + keyword requires one or more grouping expressions
/// or
/// The for-clause with the + ForClauseKeyword.DISCRETE_DELIVERY.Name + keyword does not allow grouping expressions
/// or
/// The for-clause with delivery keywords may only occur once in a statement
/// or
/// Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'</exception>
/// <throws>ExprValidationException to indicate the select expression cannot be validated</throws>
public static SelectExprProcessor GetProcessor(
ICollection <int> assignedTypeNumberStack,
SelectClauseElementCompiled[] selectionList,
bool isUsingWildcard,
InsertIntoDesc insertIntoDesc,
EventType optionalInsertIntoEventType,
ForClauseSpec forClauseSpec,
StreamTypeService typeService,
EventAdapterService eventAdapterService,
StatementResultService statementResultService,
ValueAddEventService valueAddEventService,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
MethodResolutionService methodResolutionService,
ExprEvaluatorContext exprEvaluatorContext,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
TimeProvider timeProvider,
string engineURI,
string statementId,
string statementName,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
ConfigurationInformation configuration,
SelectExprProcessorDeliveryCallback selectExprProcessorCallback,
NamedWindowService namedWindowService,
IntoTableSpec intoTableClause)
{
if (selectExprProcessorCallback != null)
{
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
IDictionary <string, object> properties = new LinkedHashMap <string, object>();
for (var i = 0; i < bindProcessor.ColumnNamesAssigned.Length; i++)
{
properties.Put(bindProcessor.ColumnNamesAssigned[i], bindProcessor.ExpressionTypes[i]);
}
var eventType = eventAdapterService.CreateAnonymousObjectArrayType("Output_" + statementName, properties);
return(new SelectExprProcessorWDeliveryCallback(eventType, bindProcessor, selectExprProcessorCallback));
}
var synthetic = GetProcessorInternal(assignedTypeNumberStack, selectionList, isUsingWildcard, insertIntoDesc, optionalInsertIntoEventType, typeService, eventAdapterService, valueAddEventService, selectExprEventTypeRegistry, methodResolutionService, statementId, annotations, configuration, namedWindowService, tableService);
// Handle table as an optional service
if (statementResultService != null)
{
// Handle for-clause delivery contract checking
ExprNode[] groupedDeliveryExpr = null;
var forDelivery = false;
if (forClauseSpec != null)
{
foreach (var item in forClauseSpec.Clauses)
{
if (item.Keyword == null)
{
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'");
}
try
{
ForClauseKeyword keyword = EnumHelper.Parse <ForClauseKeyword>(item.Keyword);
if ((keyword == ForClauseKeyword.GROUPED_DELIVERY) && (item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.GROUPED_DELIVERY.GetName() +
" keyword requires one or more grouping expressions");
}
if ((keyword == ForClauseKeyword.DISCRETE_DELIVERY) && (!item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.DISCRETE_DELIVERY.GetName() +
" keyword does not allow grouping expressions");
}
if (forDelivery)
{
throw new ExprValidationException(
"The for-clause with delivery keywords may only occur once in a statement");
}
}
catch (ExprValidationException) {
throw;
}
catch (EPException) {
throw;
}
catch (Exception ex) {
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'", ex);
}
StreamTypeService type = new StreamTypeServiceImpl(synthetic.ResultEventType, null, false, engineURI);
groupedDeliveryExpr = new ExprNode[item.Expressions.Count];
var validationContext = new ExprValidationContext(type, methodResolutionService, null, timeProvider, variableService, tableService, exprEvaluatorContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, intoTableClause == null ? null : intoTableClause.Name, false); // no context descriptor available
for (var i = 0; i < item.Expressions.Count; i++)
{
groupedDeliveryExpr[i] = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.FORCLAUSE, item.Expressions[i], validationContext);
}
forDelivery = true;
}
}
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
statementResultService.SetSelectClause(bindProcessor.ExpressionTypes, bindProcessor.ColumnNamesAssigned, forDelivery, ExprNodeUtility.GetEvaluators(groupedDeliveryExpr), exprEvaluatorContext);
return(new SelectExprResultProcessor(statementResultService, synthetic, bindProcessor));
}
return(synthetic);
}
public AvroEventBeanCopyMethod(AvroEventType avroEventType, EventAdapterService eventAdapterService)
{
_avroEventType = avroEventType;
_eventAdapterService = eventAdapterService;
}
private static SelectExprProcessor GetProcessorInternal(
ICollection <int> assignedTypeNumberStack,
SelectClauseElementCompiled[] selectionList,
bool isUsingWildcard,
InsertIntoDesc insertIntoDesc,
EventType optionalInsertIntoEventType,
StreamTypeService typeService,
EventAdapterService eventAdapterService,
ValueAddEventService valueAddEventService,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
MethodResolutionService methodResolutionService,
string statementId,
Attribute[] annotations,
ConfigurationInformation configuration,
NamedWindowService namedWindowService,
TableService tableService)
{
// Wildcard not allowed when insert into specifies column order
if (isUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty())
{
throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order");
}
// Determine wildcard processor (select *)
if (IsWildcardsOnly(selectionList))
{
// For joins
if (typeService.StreamNames.Length > 1)
{
Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor");
return(SelectExprJoinWildcardProcessorFactory.Create(
assignedTypeNumberStack, statementId, typeService.StreamNames, typeService.EventTypes,
eventAdapterService, insertIntoDesc, selectExprEventTypeRegistry, methodResolutionService,
annotations, configuration, tableService));
}
// Single-table selects with no insert-into
// don't need extra processing
else if (insertIntoDesc == null)
{
Log.Debug(".getProcessor Using wildcard processor");
if (typeService.HasTableTypes)
{
var tableName = TableServiceUtil.GetTableNameFromEventType(typeService.EventTypes[0]);
return(new SelectExprWildcardTableProcessor(tableName, tableService));
}
return(new SelectExprWildcardProcessor(typeService.EventTypes[0]));
}
}
// Verify the assigned or name used is unique
if (insertIntoDesc == null)
{
VerifyNameUniqueness(selectionList);
}
// Construct processor
var buckets = GetSelectExpressionBuckets(selectionList);
var factory = new SelectExprProcessorHelper(
assignedTypeNumberStack, buckets.Expressions, buckets.SelectedStreams, insertIntoDesc,
optionalInsertIntoEventType, isUsingWildcard, typeService, eventAdapterService, valueAddEventService,
selectExprEventTypeRegistry, methodResolutionService, statementId, annotations, configuration,
namedWindowService, tableService);
SelectExprProcessor processor = factory.Evaluator;
// add reference to the type obtained
var type = (EventTypeSPI)processor.ResultEventType;
if (!typeService.IsOnDemandStreams && type.Metadata.TypeClass != TypeClass.ANONYMOUS)
{
selectExprEventTypeRegistry.Add(processor.ResultEventType);
}
return(processor);
}
/// <summary>
/// Makes the property evaluator.
/// </summary>
/// <param name="spec">is the property specification</param>
/// <param name="sourceEventType">the event type</param>
/// <param name="optionalSourceStreamName">the source stream name</param>
/// <param name="eventAdapterService">for event instances</param>
/// <param name="methodResolutionService">for resolving UDF</param>
/// <param name="timeProvider">provides time</param>
/// <param name="variableService">for resolving variables</param>
/// <param name="tableService">The table service.</param>
/// <param name="engineURI">engine URI</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="statementName">Name of the statement.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="namedWindowService">The named window service.</param>
/// <returns>
/// propert evaluator
/// </returns>
/// <exception cref="ExprValidationException">
/// Missing @type(name) declaration providing the event type name of the return type for expression ' +
/// ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + '
/// or
/// Event type by name ' + atom.OptionalResultEventType + ' could not be found
/// or
/// Event type ' + streamEventType.Name + ' underlying type + streamEventType.UnderlyingType.Name +
/// cannot be assigned a value of type + returnType.GetTypeNameFullyQualPretty()
/// or
/// Return type of expression ' + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + ' is ' + returnType.Name + ', expected an Iterable or array result
/// or
/// Property rename ' + rawStreamSpec.MaskTypeName + ' not found in path
/// or
/// Expression in a property-selection may not utilize + isMinimal
/// </exception>
/// <exception cref="IllegalStateException">Unknown select clause item: + raw</exception>
/// <throws>ExprValidationException if any expressions could not be verified</throws>
public static PropertyEvaluator MakeEvaluator(
PropertyEvalSpec spec,
EventType sourceEventType,
string optionalSourceStreamName,
EventAdapterService eventAdapterService,
MethodResolutionService methodResolutionService,
TimeProvider timeProvider,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
string engineURI,
string statementId,
string statementName,
Attribute[] annotations,
ICollection <int> assignedTypeNumberStack,
ConfigurationInformation configuration,
NamedWindowService namedWindowService)
{
var length = spec.Atoms.Count;
var containedEventEvals = new ContainedEventEval[length];
var fragmentEventTypes = new FragmentEventType[length];
var currentEventType = sourceEventType;
var whereClauses = new ExprEvaluator[length];
var streamEventTypes = new List <EventType>();
var streamNames = new List <string>();
var streamNameAndNumber = new Dictionary <string, int>().WithNullSupport();
var expressionTexts = new List <string>();
var validateContext = new ExprEvaluatorContextTimeOnly(timeProvider);
streamEventTypes.Add(sourceEventType);
streamNames.Add(optionalSourceStreamName);
streamNameAndNumber.Put(optionalSourceStreamName, 0);
expressionTexts.Add(sourceEventType.Name);
IList <SelectClauseElementCompiled> cumulativeSelectClause = new List <SelectClauseElementCompiled>();
for (var i = 0; i < length; i++)
{
var atom = spec.Atoms[i];
ContainedEventEval containedEventEval = null;
string expressionText = null;
EventType streamEventType = null;
FragmentEventType fragmentEventType = null;
// Resolve directly as fragment event type if possible
if (atom.SplitterExpression is ExprIdentNode)
{
var propertyName = ((ExprIdentNode)atom.SplitterExpression).FullUnresolvedName;
fragmentEventType = currentEventType.GetFragmentType(propertyName);
if (fragmentEventType != null)
{
var getter = currentEventType.GetGetter(propertyName);
if (getter != null)
{
containedEventEval = new ContainedEventEvalGetter(getter);
expressionText = propertyName;
streamEventType = fragmentEventType.FragmentType;
}
}
}
// evaluate splitter expression
if (containedEventEval == null)
{
ExprNodeUtility.ValidatePlainExpression(
ExprNodeOrigin.CONTAINEDEVENT, ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression),
atom.SplitterExpression);
var availableTypes = streamEventTypes.ToArray();
var availableStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
availableTypes, availableStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, methodResolutionService, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
var validatedExprNode = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, atom.SplitterExpression, validationContext);
var evaluator = validatedExprNode.ExprEvaluator;
// determine result type
if (atom.OptionalResultEventType == null)
{
throw new ExprValidationException(
"Missing @type(name) declaration providing the event type name of the return type for expression '" +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "'");
}
streamEventType = eventAdapterService.GetEventTypeByName(atom.OptionalResultEventType);
if (streamEventType == null)
{
throw new ExprValidationException(
"Event type by name '" + atom.OptionalResultEventType + "' could not be found");
}
var returnType = evaluator.ReturnType;
// when the expression returns an array, allow array values to become the column of the single-column event type
if (returnType.IsArray &&
streamEventType.PropertyNames.Length == 1 &&
TypeHelper.IsSubclassOrImplementsInterface(TypeHelper.GetBoxedType(returnType.GetElementType()), TypeHelper.GetBoxedType(streamEventType.GetPropertyType(streamEventType.PropertyNames[0]))))
{
var writables = eventAdapterService.GetWriteableProperties(streamEventType, false);
if (!writables.IsEmpty())
{
try {
EventBeanManufacturer manufacturer = EventAdapterServiceHelper.GetManufacturer(eventAdapterService, streamEventType, new WriteablePropertyDescriptor[] { writables.First() }, methodResolutionService.EngineImportService, false);
containedEventEval = new ContainedEventEvalArrayToEvent(evaluator, manufacturer);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException("Event type '" + streamEventType.Name + "' cannot be populated: " + e.Message, e);
}
}
else
{
throw new ExprValidationException("Event type '" + streamEventType.Name + "' cannot be written to");
}
}
else
{
EventBeanFactory eventBeanFactory = EventAdapterServiceHelper.GetFactoryForType(streamEventType, eventAdapterService);
// check expression result type against eventtype expected underlying type
if (returnType.IsArray())
{
if ((!TypeHelper.IsSubclassOrImplementsInterface(returnType.GetElementType(), streamEventType.UnderlyingType)))
{
throw new ExprValidationException("Event type '" + streamEventType.Name + "' underlying type " + streamEventType.UnderlyingType.FullName +
" cannot be assigned a value of type " + TypeHelper.GetTypeNameFullyQualPretty(returnType));
}
}
else if (GenericExtensions.IsGenericEnumerable(returnType))
{
// fine, assumed to return the right type
}
else
{
throw new ExprValidationException("Return type of expression '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "' is '" + returnType.FullName + "', expected an Iterable or array result");
}
containedEventEval = new ContainedEventEvalExprNode(evaluator, eventBeanFactory);
}
expressionText = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validatedExprNode);
fragmentEventType = new FragmentEventType(streamEventType, true, false);
}
// validate where clause, if any
streamEventTypes.Add(streamEventType);
streamNames.Add(atom.OptionalAsName);
streamNameAndNumber.Put(atom.OptionalAsName, i + 1);
expressionTexts.Add(expressionText);
if (atom.OptionalWhereClause != null)
{
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, methodResolutionService, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
whereClauses[i] =
ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, atom.OptionalWhereClause, validationContext).ExprEvaluator;
}
// validate select clause
if (atom.OptionalSelectClause != null)
{
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var validationContext = new ExprValidationContext(
streamTypeService, methodResolutionService, null, timeProvider, variableService, tableService,
validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService,
false, false, true, false, null, false);
foreach (var raw in atom.OptionalSelectClause.SelectExprList)
{
if (raw is SelectClauseStreamRawSpec)
{
var rawStreamSpec = (SelectClauseStreamRawSpec)raw;
if (!streamNames.Contains(rawStreamSpec.StreamName))
{
throw new ExprValidationException(
"Property rename '" + rawStreamSpec.StreamName + "' not found in path");
}
var streamSpec = new SelectClauseStreamCompiledSpec(
rawStreamSpec.StreamName, rawStreamSpec.OptionalAsName);
int streamNumber = streamNameAndNumber.Get(rawStreamSpec.StreamName);
streamSpec.StreamNumber = streamNumber;
cumulativeSelectClause.Add(streamSpec);
}
else if (raw is SelectClauseExprRawSpec)
{
var exprSpec = (SelectClauseExprRawSpec)raw;
var exprCompiled = ExprNodeUtility.GetValidatedSubtree(
ExprNodeOrigin.CONTAINEDEVENT, exprSpec.SelectExpression, validationContext);
var resultName = exprSpec.OptionalAsName;
if (resultName == null)
{
resultName = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprCompiled);
}
cumulativeSelectClause.Add(
new SelectClauseExprCompiledSpec(
exprCompiled, resultName, exprSpec.OptionalAsName, exprSpec.IsEvents));
var isMinimal = ExprNodeUtility.IsMinimalExpression(exprCompiled);
if (isMinimal != null)
{
throw new ExprValidationException(
"Expression in a property-selection may not utilize " + isMinimal);
}
}
else if (raw is SelectClauseElementWildcard)
{
// wildcards are stream selects: we assign a stream name (any) and add a stream wildcard select
var streamNameAtom = atom.OptionalAsName;
if (streamNameAtom == null)
{
streamNameAtom = UuidGenerator.Generate();
}
var streamSpec = new SelectClauseStreamCompiledSpec(streamNameAtom, atom.OptionalAsName);
var streamNumber = i + 1;
streamSpec.StreamNumber = streamNumber;
cumulativeSelectClause.Add(streamSpec);
}
else
{
throw new IllegalStateException("Unknown select clause item:" + raw);
}
}
}
currentEventType = fragmentEventType.FragmentType;
fragmentEventTypes[i] = fragmentEventType;
containedEventEvals[i] = containedEventEval;
}
if (cumulativeSelectClause.IsEmpty())
{
if (length == 1)
{
return(new PropertyEvaluatorSimple(
containedEventEvals[0], fragmentEventTypes[0], whereClauses[0], expressionTexts[0]));
}
else
{
return(new PropertyEvaluatorNested(containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts));
}
}
else
{
var accumulative = new PropertyEvaluatorAccumulative(
containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts);
var whereTypes = streamEventTypes.ToArray();
var whereStreamNames = streamNames.ToArray();
var isIStreamOnly = new bool[streamNames.Count];
isIStreamOnly.Fill(true);
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
whereTypes, whereStreamNames, isIStreamOnly, engineURI, false);
var cumulativeSelectArr = cumulativeSelectClause.ToArray();
var selectExpr = SelectExprProcessorFactory.GetProcessor(
assignedTypeNumberStack, cumulativeSelectArr, false, null, null, null, streamTypeService,
eventAdapterService, null, null, null, methodResolutionService, validateContext, variableService, scriptingService,
tableService, timeProvider, engineURI, statementId, statementName, annotations, null, configuration, null,
namedWindowService, null);
return(new PropertyEvaluatorSelect(selectExpr, accumulative));
}
}
public EventType GetEventTypeSingle(EventAdapterService eventAdapterService, String statementId)
{
return(_innerEvaluatorLambda != null?_innerEvaluatorLambda.GetEventTypeSingle(eventAdapterService, statementId) : null);
}
static SupportEventAdapterService()
{
_eventAdapterService = new EventAdapterServiceImpl(new EventTypeIdGeneratorImpl(), 5);
}
public override EventPropertyGetter GetGetter(BeanEventType eventType, EventAdapterService eventAdapterService)
{
FastClass fastClass = eventType.FastClass;
InternalEventPropDescriptor propertyDesc = eventType.GetIndexedProperty(PropertyNameAtomic);
if (propertyDesc != null)
{
if (fastClass != null)
{
MethodInfo method = propertyDesc.ReadMethod;
FastMethod fastMethod = fastClass.GetMethod(method);
return(new KeyedFastPropertyGetter(fastMethod, _index, eventAdapterService));
}
else
{
return(new KeyedMethodPropertyGetter(propertyDesc.ReadMethod, _index, eventAdapterService));
}
}
// Try the array as a simple property
propertyDesc = eventType.GetSimpleProperty(PropertyNameAtomic);
if (propertyDesc == null)
{
return(null);
}
Type returnType = propertyDesc.ReturnType;
if (returnType == typeof(string))
{
if (propertyDesc.ReadMethod != null)
{
MethodInfo method = propertyDesc.ReadMethod;
if (fastClass != null)
{
FastMethod fastMethod = fastClass.GetMethod(method);
return(new StringFastPropertyGetter(fastMethod, _index, eventAdapterService));
}
else
{
return(new StringMethodPropertyGetter(method, _index, eventAdapterService));
}
}
else
{
FieldInfo field = propertyDesc.AccessorField;
return(new StringFieldPropertyGetter(field, _index, eventAdapterService));
}
}
else if (returnType.IsArray)
{
if (propertyDesc.ReadMethod != null)
{
MethodInfo method = propertyDesc.ReadMethod;
if (fastClass != null)
{
FastMethod fastMethod = fastClass.GetMethod(method);
return(new ArrayFastPropertyGetter(fastMethod, _index, eventAdapterService));
}
else
{
return(new ArrayMethodPropertyGetter(method, _index, eventAdapterService));
}
}
else
{
FieldInfo field = propertyDesc.AccessorField;
return(new ArrayFieldPropertyGetter(field, _index, eventAdapterService));
}
}
else if (returnType.IsGenericDictionary())
{
}
else if (returnType.IsGenericList())
{
if (propertyDesc.ReadMethod != null)
{
MethodInfo method = propertyDesc.ReadMethod;
if (fastClass != null)
{
FastMethod fastMethod = fastClass.GetMethod(method);
return(new ListFastPropertyGetter(method, fastMethod, _index, eventAdapterService));
}
else
{
return(new ListMethodPropertyGetter(method, _index, eventAdapterService));
}
}
else
{
FieldInfo field = propertyDesc.AccessorField;
return(new ListFieldPropertyGetter(field, _index, eventAdapterService));
}
}
else if (returnType.IsImplementsInterface(typeof(IEnumerable)))
{
if (propertyDesc.ReadMethod != null)
{
MethodInfo method = propertyDesc.ReadMethod;
if (fastClass != null)
{
FastMethod fastMethod = fastClass.GetMethod(method);
return(new EnumerableFastPropertyGetter(method, fastMethod, _index, eventAdapterService));
}
else
{
return(new EnumerableMethodPropertyGetter(method, _index, eventAdapterService));
}
}
else
{
FieldInfo field = propertyDesc.AccessorField;
return(new EnumerableFieldPropertyGetter(field, _index, eventAdapterService));
}
}
return(null);
}
public static void Reset()
{
_eventAdapterService = new EventAdapterServiceImpl(new EventTypeIdGeneratorImpl(), 5);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="field">is the field to use to retrieve a value from the object.</param>
/// <param name="key">is the key to supply as parameter to the mapped property getter</param>
/// <param name="eventAdapterService">factory for event beans and event types</param>
public KeyedMapFieldPropertyGetter(FieldInfo field, Object key, EventAdapterService eventAdapterService)
: base(eventAdapterService, TypeHelper.GetGenericFieldTypeMap(field, false), null)
{
this._key = key;
this._field = field;
}
public EventType GetEventTypeCollection(EventAdapterService eventAdapterService, int statementId)
{
return(_fragmentType);
}
internal static void AssembleField(
string propertyName,
Object propertyType,
JArray assembler,
Attribute[] annotations,
ConfigurationEngineDefaults.AvroSettings avroSettings,
EventAdapterService eventAdapterService,
string statementName,
string engineURI,
TypeRepresentationMapper optionalMapper)
{
if (propertyName.Contains("."))
{
throw new EPException(
"Invalid property name as Avro does not allow dot '.' in field names (property '" + propertyName +
"')");
}
Schema schema = GetAnnotationSchema(propertyName, annotations);
if (schema != null)
{
assembler.Add(TypeBuilder.Field(propertyName, schema));
// assembler.Name(propertyName).Type(schema).NoDefault();
return;
}
if (optionalMapper != null && propertyType is Type)
{
var result = (Schema) optionalMapper.Map(
new TypeRepresentationMapperContext(
(Type) propertyType, propertyName, statementName, engineURI));
if (result != null)
{
assembler.Add(TypeBuilder.Field(propertyName, result));
// assembler.Name(propertyName).Type(result).NoDefault();
return;
}
}
if (propertyType == null)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.NullType()));
// assembler.Name(propertyName).Type("null");
}
else if (propertyType is string)
{
string propertyTypeName = propertyType.ToString();
bool isArray = EventTypeUtility.IsPropertyArray(propertyTypeName);
if (isArray)
{
propertyTypeName = EventTypeUtility.GetPropertyRemoveArray(propertyTypeName);
}
// Add EventType itself as a property
EventType eventType = eventAdapterService.GetEventTypeByName(propertyTypeName);
if (!(eventType is AvroEventType))
{
throw new EPException(
"Type definition encountered an unexpected property type name '"
+ propertyType + "' for property '" + propertyName +
"', expected the name of a previously-declared Avro type");
}
schema = ((AvroEventType) eventType).SchemaAvro;
if (!isArray)
{
assembler.Add(TypeBuilder.Field(propertyName, schema));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema)));
}
}
else if (propertyType is EventType)
{
var eventType = (EventType) propertyType;
CheckCompatibleType(eventType);
if (eventType is AvroEventType)
{
schema = ((AvroEventType) eventType).SchemaAvro;
assembler.Add(TypeBuilder.Field(propertyName, schema));
}
else if (eventType is MapEventType)
{
var mapEventType = (MapEventType) eventType;
var nestedSchema = AssembleNestedSchema(
mapEventType, avroSettings, annotations, eventAdapterService, statementName, engineURI,
optionalMapper);
assembler.Add(TypeBuilder.Field(propertyName, nestedSchema));
}
else
{
throw new IllegalStateException("Unrecognized event type " + eventType);
}
}
else if (propertyType is EventType[])
{
EventType eventType = ((EventType[]) propertyType)[0];
CheckCompatibleType(eventType);
if (eventType is AvroEventType)
{
schema = ((AvroEventType) eventType).SchemaAvro;
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(schema)));
}
else if (eventType is MapEventType)
{
var mapEventType = (MapEventType) eventType;
var nestedSchema = AssembleNestedSchema(
mapEventType, avroSettings, annotations, eventAdapterService, statementName, engineURI,
optionalMapper);
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Array(nestedSchema)));
}
else
{
throw new IllegalStateException("Unrecognized event type " + eventType);
}
}
else if (propertyType is Type)
{
var propertyClass = (Type) propertyType;
var propertyClassBoxed = propertyClass.GetBoxedType();
bool nullable = propertyClass == propertyClassBoxed;
bool preferNonNull = avroSettings.IsEnableSchemaDefaultNonNull;
if (propertyClassBoxed == typeof (bool?))
{
AssemblePrimitive(nullable, REQ_BOOLEAN, OPT_BOOLEAN, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (int?) || propertyClassBoxed == typeof (byte?))
{
AssemblePrimitive(nullable, REQ_INT, OPT_INT, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (long?))
{
AssemblePrimitive(nullable, REQ_LONG, OPT_LONG, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (float?))
{
AssemblePrimitive(nullable, REQ_FLOAT, OPT_FLOAT, assembler, propertyName, preferNonNull);
}
else if (propertyClassBoxed == typeof (double?))
{
AssemblePrimitive(nullable, REQ_DOUBLE, OPT_DOUBLE, assembler, propertyName, preferNonNull);
}
else if (propertyClass == typeof (string))
{
if (avroSettings.IsEnableNativeString)
{
if (preferNonNull)
{
assembler.Add(
TypeBuilder.Field(propertyName,
TypeBuilder.Primitive("string",
TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE))));
}
else
{
assembler.Add(
TypeBuilder.Field(
propertyName,
TypeBuilder.Union(
TypeBuilder.NullType(),
TypeBuilder.StringType(
TypeBuilder.Property(
AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)))));
}
}
else
{
AssemblePrimitive(nullable, REQ_STRING, OPT_STRING, assembler, propertyName, preferNonNull);
}
}
else if (propertyClass == typeof (byte[]))
{
if (preferNonNull)
{
assembler.Add(TypeBuilder.RequiredBytes(propertyName));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.NullType(), TypeBuilder.BytesType())));
}
}
else if (propertyClass.IsArray)
{
var componentType = propertyClass.GetElementType();
var componentTypeBoxed = componentType.GetBoxedType();
var nullableElements = componentType == componentTypeBoxed;
if (componentTypeBoxed == typeof (bool?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_BOOLEAN, ARRAY_OF_OPT_BOOLEAN, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (int?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (long?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_LONG, ARRAY_OF_OPT_LONG, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (float?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_FLOAT, ARRAY_OF_OPT_FLOAT, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof(double?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_DOUBLE, ARRAY_OF_OPT_DOUBLE, assembler, propertyName, preferNonNull);
}
else if (componentTypeBoxed == typeof (byte?))
{
AssembleArray(
nullableElements, ARRAY_OF_REQ_INT, ARRAY_OF_OPT_INT, assembler, propertyName, preferNonNull);
}
else if (propertyClass == typeof (string[]))
{
JObject array;
if (avroSettings.IsEnableNativeString)
{
array = TypeBuilder.Array(TypeBuilder.StringType(TypeBuilder.Property(
AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE)));
}
else
{
array = TypeBuilder.Array(TypeBuilder.StringType());
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, array));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.NullType(), array)));
}
}
else if (propertyClass.CanUnwrap<object>())
{
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
else if (propertyClass.IsGenericDictionary())
{
JToken value;
if (avroSettings.IsEnableNativeString)
{
value = TypeBuilder.StringType(
TypeBuilder.Property(AvroConstant.PROP_STRING_KEY, AvroConstant.PROP_STRING_VALUE));
}
else
{
value = TypeBuilder.StringType();
}
if (preferNonNull)
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Map(value)));
}
else
{
assembler.Add(TypeBuilder.Field(propertyName, TypeBuilder.Union(
TypeBuilder.NullType(), TypeBuilder.Map(value))));
}
}
else if (propertyClass.IsGenericCollection())
{
AssembleFieldForCollection(propertyName, propertyType, assembler, avroSettings, propertyClass, preferNonNull);
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
else
{
throw MakeEPException(propertyName, propertyType);
}
}
public EventPropertyGetter GetGetterIndexedEntryPONO(String propertyNameAtomic, int index, BeanEventPropertyGetter nestedGetter, EventAdapterService eventAdapterService, Type propertyTypeGetter)
{
int propertyIndex = GetAssertIndex(propertyNameAtomic);
return(new ObjectArrayArrayPONOBeanEntryIndexedPropertyGetter(propertyIndex, index, nestedGetter, eventAdapterService, propertyTypeGetter));
}
public MapPropertyGetterDefaultMap(String propertyName, EventType fragmentEventType, EventAdapterService eventAdapterService)
: base(propertyName, fragmentEventType, eventAdapterService)
{
}
public EventPropertyGetter GetGetterNestedEntryBeanArray(String propertyNameAtomic, int index, EventPropertyGetter getter, EventType innerType, EventAdapterService eventAdapterService)
{
int propertyIndex = GetAssertIndex(propertyNameAtomic);
if (getter is ObjectArrayEventPropertyGetter)
{
return(new ObjectArrayNestedEntryPropertyGetterArrayObjectArray(propertyIndex, innerType, eventAdapterService, index, (ObjectArrayEventPropertyGetter)getter));
}
return(new ObjectArrayNestedEntryPropertyGetterArrayMap(propertyIndex, innerType, eventAdapterService, index, (MapEventPropertyGetter)getter));
}
/// <summary>Build the event type for built-in properties. </summary>
/// <param name="eventAdapterService">event adapters</param>
/// <returns>event type</returns>
public static EventType GetBuiltInEventType(EventAdapterService eventAdapterService)
{
return(eventAdapterService.CreateAnonymousObjectArrayType(
typeof(OutputConditionExpressionFactory).FullName, OutputConditionExpressionTypeUtil.TYPEINFO));
}
public EventPropertyGetterIndexed GetPropertyProvidedGetterIndexed(IDictionary <String, Object> nestableTypes, String indexedPropertyName, IndexedProperty indexedProperty, EventAdapterService eventAdapterService)
{
return((EventPropertyGetterIndexed)indexedProperty.GetGetterObjectArray(PropertiesIndex, nestableTypes, eventAdapterService));
}
public EventBeanFactoryAvro(EventType type, EventAdapterService eventAdapterService)
{
this._type = type;
this._eventAdapterService = eventAdapterService;
}
public EventPropertyGetter GetGetterProperty(String name, BeanEventType nativeFragmentType, EventAdapterService eventAdapterService)
{
int index = GetAssertIndex(name);
return(new ObjectArrayEntryPropertyGetter(index, nativeFragmentType, eventAdapterService));
}
/// <summary>Resolves a given event name to an event type. </summary>
/// <param name="eventName">is the name to resolve</param>
/// <param name="eventAdapterService">for resolving event types</param>
/// <param name="engineURI">the provider URI</param>
/// <param name="optionalResolutionURIs">is URIs for resolving the event name against plug-inn event representations, if any</param>
/// <returns>event type</returns>
/// <throws>ExprValidationException if the info cannot be resolved</throws>
public static EventType ResolveType(String engineURI, String eventName, EventAdapterService eventAdapterService, IList <Uri> optionalResolutionURIs)
{
var eventType = eventAdapterService.GetEventTypeByName(eventName);
// may already be known
if (eventType != null)
{
return(eventType);
}
var engineURIQualifier = engineURI;
if (engineURI == null || EPServiceProviderConstants.DEFAULT_ENGINE_URI.Equals(engineURI))
{
engineURIQualifier = EPServiceProviderConstants.DEFAULT_ENGINE_URI__QUALIFIER;
}
// The event name can be prefixed by the engine URI, i.e. "select * from default.MyEvent"
if (eventName.StartsWith(engineURIQualifier))
{
var indexDot = eventName.IndexOf('.');
if (indexDot > 0)
{
var eventNameURI = eventName.Substring(0, indexDot);
var eventNameRemainder = eventName.Substring(indexDot + 1);
if (engineURIQualifier.Equals(eventNameURI))
{
eventType = eventAdapterService.GetEventTypeByName(eventNameRemainder);
}
}
}
// may now be known
if (eventType != null)
{
return(eventType);
}
// The type is not known yet, attempt to add as an object type with the same name
String message = null;
try
{
eventType = eventAdapterService.AddBeanType(eventName, eventName, true, false, false, false);
}
catch (EventAdapterException ex)
{
Log.Debug(".resolveType Event type named '" + eventName + "' not resolved as Type event");
message = "Failed to resolve event type: " + ex.Message;
}
// Attempt to use plug-in event types
try
{
eventType = eventAdapterService.AddPlugInEventType(eventName, optionalResolutionURIs, null);
}
catch (EventAdapterException)
{
Log.Debug(".resolveType Event type named '" + eventName + "' not resolved by plug-in event representations");
// remains unresolved
}
if (eventType == null)
{
throw new ExprValidationException(message);
}
return(eventType);
}
public EventPropertyGetter GetGetterIndexedUnderlyingArray(String propertyNameAtomic, int index, EventAdapterService eventAdapterService, EventType innerType)
{
int propertyIndex = GetAssertIndex(propertyNameAtomic);
return(new ObjectArrayArrayPropertyGetter(propertyIndex, index, eventAdapterService, innerType));
}
public EventPropertyGetter GetGetterIndexedPONO(String propertyNameAtomic, int index, EventAdapterService eventAdapterService, Type componentType)
{
int propertyIndex = GetAssertIndex(propertyNameAtomic);
return(new ObjectArrayArrayPONOEntryIndexedPropertyGetter(propertyIndex, index, eventAdapterService, componentType));
}
