public static Pair <ExprTableAccessNode, ExprDotNode> MapPropertyToTableNested(
TableCompileTimeResolver resolver,
string stream,
string subproperty)
{
var table = resolver.Resolve(stream);
int?indexIfIndexed = null;
if (table == null)
{
// try indexed property
var pair = MapPropertyToTable(stream, resolver);
if (pair == null)
{
return(null);
}
table = pair.Second;
indexIfIndexed = pair.First.Index;
}
if (table.IsKeyed && indexIfIndexed == null)
{
return(null);
}
if (!table.IsKeyed && indexIfIndexed != null)
{
return(null);
}
var index = StringValue.UnescapedIndexOfDot(subproperty);
if (index == -1)
{
var tableNodeX = new ExprTableAccessNodeSubprop(table.TableName, subproperty);
if (indexIfIndexed != null)
{
tableNodeX.AddChildNode(new ExprConstantNodeImpl(indexIfIndexed));
}
return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNodeX, null));
}
// we have a nested subproperty such as "tablename.subproperty.abc"
IList <Chainable> chainedSpecs = new List <Chainable>(1);
chainedSpecs.Add(new ChainableName(subproperty.Substring(index + 1)));
var tableNode = new ExprTableAccessNodeSubprop(table.TableName, subproperty.Substring(0, index));
if (indexIfIndexed != null)
{
tableNode.AddChildNode(new ExprConstantNodeImpl(indexIfIndexed));
}
ExprDotNode dotNode = new ExprDotNodeImpl(chainedSpecs, false, false);
dotNode.AddChildNode(tableNode);
return(new Pair <ExprTableAccessNode, ExprDotNode>(tableNode, dotNode));
}
private static StreamTableColWStreamName FindTableColumnMayByPrefixed(
StreamTypeService streamTypeService,
string streamAndPropName,
TableCompileTimeResolver resolver)
{
var indexDot = streamAndPropName.IndexOf('.');
if (indexDot == -1)
{
var pair = FindTableColumnAcrossStreams(streamTypeService, streamAndPropName, resolver);
if (pair != null)
{
return(new StreamTableColWStreamName(pair, null));
}
}
else
{
var streamName = streamAndPropName.Substring(0, indexDot);
var colName = streamAndPropName.Substring(indexDot + 1);
var streamNum = streamTypeService.GetStreamNumForStreamName(streamName);
if (streamNum == -1)
{
return(null);
}
var pair = FindTableColumnForType(streamNum, streamTypeService.EventTypes[streamNum], colName, resolver);
if (pair != null)
{
return(new StreamTableColWStreamName(pair, streamName));
}
}
return(null);
}
/// <summary>
/// Handle property "table" or "table[key]" where key is an integer and therefore can be a regular property
/// </summary>
/// <param name="propertyName">property</param>
/// <param name="resolver">resolver</param>
/// <returns>expression null or node</returns>
public static ExprTableAccessNode MapPropertyToTableUnnested(
string propertyName,
TableCompileTimeResolver resolver)
{
// try regular property
var table = resolver.Resolve(propertyName);
if (table != null)
{
return(new ExprTableAccessNodeTopLevel(table.TableName));
}
// try indexed property
var pair = MapPropertyToTable(propertyName, resolver);
if (pair == null)
{
return(null);
}
ExprTableAccessNode tableNode = new ExprTableAccessNodeTopLevel(pair.Second.TableName);
tableNode.AddChildNode(new ExprConstantNodeImpl(pair.First.Index));
return(tableNode);
}
public static ExprTableIdentNode GetTableIdentNode(
StreamTypeService streamTypeService,
string unresolvedPropertyName,
string streamOrPropertyName,
TableCompileTimeResolver resolver)
{
var propertyPrefixed = unresolvedPropertyName;
if (streamOrPropertyName != null)
{
propertyPrefixed = streamOrPropertyName + "." + unresolvedPropertyName;
}
var col = FindTableColumnMayByPrefixed(streamTypeService, propertyPrefixed, resolver);
var pair = col?.Pair;
if (pair?.Column is TableMetadataColumnAggregation)
{
var agg = (TableMetadataColumnAggregation)pair.Column;
var resultType = pair.TableMetadata.PublicEventType.GetPropertyType(agg.ColumnName);
return(new ExprTableIdentNode(
pair.TableMetadata,
streamOrPropertyName,
unresolvedPropertyName,
resultType,
pair.StreamNum,
agg.ColumnName,
agg.Column));
}
return(null);
}
private static Pair <IndexedProperty, TableMetaData> MapPropertyToTable(
string propertyName,
TableCompileTimeResolver resolver)
{
try {
var property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (!(property is IndexedProperty))
{
return(null);
}
var name = property.PropertyNameAtomic;
var table = resolver.Resolve(name);
if (table == null)
{
return(null);
}
return(new Pair <IndexedProperty, TableMetaData>((IndexedProperty)property, table));
}
catch (PropertyAccessException) {
// possible
}
return(null);
}
public static void ValidateTableExists(
TableCompileTimeResolver tableCompileTimeResolver,
string name)
{
if (tableCompileTimeResolver.Resolve(name) != null) {
throw new ExprValidationException("A table by name '" + name + "' already exists");
}
}
public SelectExprProcessorForge MakeSelectNoWildcard(
SelectExprForgeContext selectExprForgeContext,
ExprForge[] exprForges,
EventType resultEventType,
TableCompileTimeResolver tableService,
string statementName)
{
return new EvalSelectNoWildcardAvro(selectExprForgeContext, exprForges, resultEventType, statementName);
}
private static bool IsInsertIntoTable(
StatementSpecRaw statementSpecRaw,
TableCompileTimeResolver tableCompileTimeResolver)
{
if (statementSpecRaw.InsertIntoDesc == null) {
return false;
}
return tableCompileTimeResolver.Resolve(statementSpecRaw.InsertIntoDesc.EventTypeName) != null;
}
public static Pair <ExprNode, IList <Chainable> > GetTableNodeChainable(
StreamTypeService streamTypeService,
IList <Chainable> chainSpec,
bool allowTableAggReset,
TableCompileTimeResolver tableCompileTimeResolver)
{
chainSpec = new List <Chainable>(chainSpec);
var unresolvedPropertyName = chainSpec[0].GetRootNameOrEmptyString();
var tableStreamNum = streamTypeService.GetStreamNumForStreamName(unresolvedPropertyName);
if (chainSpec.Count == 2 && tableStreamNum != -1)
{
var tableMetadata = tableCompileTimeResolver.ResolveTableFromEventType(streamTypeService.EventTypes[tableStreamNum]);
if (tableMetadata != null && chainSpec[1].GetRootNameOrEmptyString().Equals("reset", StringComparison.InvariantCultureIgnoreCase))
{
if (!allowTableAggReset)
{
throw new ExprValidationException(INVALID_TABLE_AGG_RESET);
}
if (!chainSpec[1].GetParametersOrEmpty().IsEmpty())
{
throw new ExprValidationException(INVALID_TABLE_AGG_RESET_PARAMS);
}
var node = new ExprTableResetRowAggNode(tableMetadata, tableStreamNum);
chainSpec.Clear();
return(new Pair <ExprNode, IList <Chainable> >(node, chainSpec));
}
}
var col = FindTableColumnMayByPrefixed(streamTypeService, unresolvedPropertyName, tableCompileTimeResolver);
var pair = col?.Pair;
if (pair?.Column is TableMetadataColumnAggregation)
{
var agg = (TableMetadataColumnAggregation)pair.Column;
var returnType = pair.TableMetadata.PublicEventType.GetPropertyType(pair.Column.ColumnName);
var node = new ExprTableIdentNode(
pair.TableMetadata,
null,
unresolvedPropertyName,
returnType,
pair.StreamNum,
agg.ColumnName,
agg.Column);
chainSpec.RemoveAt(0);
return(new Pair <ExprNode, IList <Chainable> >(node, chainSpec));
}
return(null);
}
private static bool CheckOnTriggerMergeAction(
OnTriggerMergeAction action,
TableCompileTimeResolver tableCompileTimeResolver)
{
var insert = action as OnTriggerMergeActionInsert;
if (insert?.OptionalStreamName != null && IsTable(insert.OptionalStreamName, tableCompileTimeResolver)) {
return true;
}
return false;
}
public SelectEvalJoinWildcardProcessorTableRows(
EventType[] types,
SelectExprProcessorForge inner,
TableCompileTimeResolver tableResolver)
{
this.types = types;
this.innerForge = inner;
tables = new TableMetaData[types.Length];
for (int i = 0; i < types.Length; i++) {
tables[i] = tableResolver.ResolveTableFromEventType(types[i]);
}
}
public static bool IsSubqueryWithTable(
IList<ExprSubselectNode> subselectNodes,
TableCompileTimeResolver tableCompileTimeResolver)
{
foreach (var node in subselectNodes) {
var spec = (FilterStreamSpecRaw) node.StatementSpecRaw.StreamSpecs[0];
if (tableCompileTimeResolver.Resolve(spec.RawFilterSpec.EventTypeName) != null) {
return true;
}
}
return false;
}
public static bool DetermineHasTableAccess(
IList<ExprSubselectNode> subselectNodes,
StatementSpecRaw statementSpecRaw,
TableCompileTimeResolver tableCompileTimeResolver)
{
var hasTableAccess =
statementSpecRaw.TableExpressions != null && !statementSpecRaw.TableExpressions.IsEmpty() ||
statementSpecRaw.IntoTableSpec != null;
hasTableAccess = hasTableAccess ||
IsJoinWithTable(statementSpecRaw, tableCompileTimeResolver) ||
IsSubqueryWithTable(subselectNodes, tableCompileTimeResolver) ||
IsInsertIntoTable(statementSpecRaw, tableCompileTimeResolver);
return hasTableAccess;
}
private static bool IsJoinWithTable(
StatementSpecRaw statementSpecRaw,
TableCompileTimeResolver tableCompileTimeResolver)
{
foreach (var stream in statementSpecRaw.StreamSpecs) {
if (stream is FilterStreamSpecRaw) {
var filter = (FilterStreamSpecRaw) stream;
if (tableCompileTimeResolver.Resolve(filter.RawFilterSpec.EventTypeName) != null) {
return true;
}
}
}
return false;
}
public IntervalForge GetForge(
StreamTypeService streamTypeService,
DateTimeMethodEnum method,
string methodNameUsed,
IList<ExprNode> parameters,
TimeAbacus timeAbacus,
TableCompileTimeResolver tableCompileTimeResolver)
{
return new IntervalForgeImpl(
method,
methodNameUsed,
streamTypeService,
parameters,
timeAbacus,
tableCompileTimeResolver);
}
private static StreamTableColPair FindTableColumnForType(
int streamNum,
EventType type,
string columnName,
TableCompileTimeResolver resolver)
{
var tableMetadata = resolver.ResolveTableFromEventType(type);
var column = tableMetadata?.Columns.Get(columnName);
if (column != null)
{
return(new StreamTableColPair(streamNum, column, tableMetadata));
}
return(null);
}
public static Pair <ExprTableAccessNode, IList <Chainable> > CheckTableNameGetLibFunc(
TableCompileTimeResolver tableService,
LazyAllocatedMap <ConfigurationCompilerPlugInAggregationMultiFunction, AggregationMultiFunctionForge> plugInAggregations,
string classIdent,
IList <Chainable> chain)
{
var index = StringValue.UnescapedIndexOfDot(classIdent);
// handle special case "table.keys()" function
if (index == -1)
{
var tableX = tableService.Resolve(classIdent);
if (tableX == null)
{
return(null); // not a table
}
var funcName = chain[1].GetRootNameOrEmptyString();
if (funcName.Equals("keys", StringComparison.InvariantCultureIgnoreCase))
{
var subchain = chain.SubList(2, chain.Count);
var node = new ExprTableAccessNodeKeys(tableX.TableName);
return(new Pair <ExprTableAccessNode, IList <Chainable> >(node, subchain));
}
else
{
throw new ValidationException(
"Invalid use of table '" + classIdent + "', unrecognized use of function '" + funcName + "', expected 'keys()'");
}
}
// Handle "table.property" (without the variable[...] syntax since this is ungrouped use)
var tableName = StringValue.UnescapeDot(classIdent.Substring(0, index));
var table = tableService.Resolve(tableName);
if (table == null)
{
return(null);
}
// this is a table access expression
var sub = classIdent.Substring(index + 1, classIdent.Length);
return(HandleTableAccessNode(plugInAggregations, table.TableName, sub, chain));
}
public StatementSpecMapEnv(
ImportServiceCompileTime importService,
VariableCompileTimeResolver variableCompileTimeResolver,
Configuration configuration,
ExprDeclaredCompileTimeResolver exprDeclaredCompileTimeResolver,
ContextCompileTimeResolver contextCompileTimeResolver,
TableCompileTimeResolver tableCompileTimeResolver,
ScriptCompileTimeResolver scriptCompileTimeResolver,
CompilerServices compilerServices)
{
ImportService = importService;
VariableCompileTimeResolver = variableCompileTimeResolver;
Configuration = configuration;
ExprDeclaredCompileTimeResolver = exprDeclaredCompileTimeResolver;
ContextCompileTimeResolver = contextCompileTimeResolver;
TableCompileTimeResolver = tableCompileTimeResolver;
ScriptCompileTimeResolver = scriptCompileTimeResolver;
CompilerServices = compilerServices;
}
public static Pair<PropertyResolutionDescriptor, string> GetTypeFromStream(
StreamTypeService streamTypeService,
string propertyNameNestable,
bool explicitPropertiesOnly,
bool obtainFragment,
TableCompileTimeResolver tableCompileTimeResolver)
{
string streamOrProp = null;
var prop = propertyNameNestable;
if (propertyNameNestable.IndexOf('.') != -1) {
prop = propertyNameNestable.Substring(propertyNameNestable.IndexOf('.') + 1);
streamOrProp = propertyNameNestable.Substring(0, propertyNameNestable.IndexOf('.'));
}
if (explicitPropertiesOnly) {
return GetTypeFromStreamExplicitProperties(streamTypeService, prop, streamOrProp, obtainFragment);
}
return GetTypeFromStream(streamTypeService, prop, streamOrProp, obtainFragment, tableCompileTimeResolver);
}
public static void ValidateAlreadyExistsTableOrVariable(
string name,
VariableCompileTimeResolver variableCompileTimeResolver,
TableCompileTimeResolver tableCompileTimeResolver,
EventTypeCompileTimeResolver eventTypeCompileTimeResolver)
{
var existingTable = tableCompileTimeResolver.Resolve(name);
if (existingTable != null) {
throw new ExprValidationException("A table by name '" + name + "' has already been declared");
}
var existingVariable = variableCompileTimeResolver.Resolve(name);
if (existingVariable != null) {
throw new ExprValidationException("A variable by name '" + name + "' has already been declared");
}
var existingEventType = eventTypeCompileTimeResolver.GetTypeByName(name);
if (existingEventType != null) {
throw new ExprValidationException("An event type by name '" + name + "' has already been declared");
}
}
private static StreamTableColPair FindTableColumnAcrossStreams(
StreamTypeService streamTypeService,
string columnName,
TableCompileTimeResolver resolver)
{
StreamTableColPair found = null;
for (var i = 0; i < streamTypeService.EventTypes.Length; i++)
{
var type = streamTypeService.EventTypes[i];
if (type == null)
{
continue;
}
var pair = FindTableColumnForType(i, type, columnName, resolver);
if (pair == null)
{
continue;
}
if (found != null)
{
if (streamTypeService.IsStreamZeroUnambigous && found.StreamNum == 0)
{
continue;
}
throw new ExprValidationException("Ambiguous table column '" + columnName + "' should be prefixed by a stream name");
}
found = pair;
}
return(found);
}
public static AggregationServiceForgeDesc GetService(
IList<ExprAggregateNode> selectAggregateExprNodes,
IDictionary<ExprNode, string> selectClauseNamedNodes,
IList<ExprDeclaredNode> declaredExpressions,
ExprNode[] groupByNodes,
MultiKeyClassRef groupByMultiKey,
IList<ExprAggregateNode> havingAggregateExprNodes,
IList<ExprAggregateNode> orderByAggregateExprNodes,
IList<ExprAggregateNodeGroupKey> groupKeyExpressions,
bool hasGroupByClause,
Attribute[] annotations,
VariableCompileTimeResolver variableCompileTimeResolver,
bool isDisallowNoReclaim,
ExprNode whereClause,
ExprNode havingClause,
EventType[] typesPerStream,
AggregationGroupByRollupDescForge groupByRollupDesc,
string optionalContextName,
IntoTableSpec intoTableSpec,
TableCompileTimeResolver tableCompileTimeResolver,
bool isUnidirectional,
bool isFireAndForget,
bool isOnSelect,
ImportServiceCompileTime importService,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
// No aggregates used, we do not need this service
if (selectAggregateExprNodes.IsEmpty() && havingAggregateExprNodes.IsEmpty()) {
if (intoTableSpec != null) {
throw new ExprValidationException("Into-table requires at least one aggregation function");
}
return new AggregationServiceForgeDesc(
AggregationServiceNullFactory.INSTANCE,
EmptyList<AggregationServiceAggExpressionDesc>.Instance,
EmptyList<ExprAggregateNodeGroupKey>.Instance,
EmptyList<StmtClassForgeableFactory>.Instance);
}
// Validate the absence of "prev" function in where-clause:
// Since the "previous" function does not post remove stream results, disallow when used with aggregations.
if (whereClause != null || havingClause != null) {
var visitor = new ExprNodePreviousVisitorWParent();
whereClause?.Accept(visitor);
havingClause?.Accept(visitor);
if (visitor.Previous != null && !visitor.Previous.IsEmpty()) {
string funcname = visitor.Previous[0]
.Second.PreviousType.ToString()
.ToLowerInvariant();
throw new ExprValidationException(
"The '" +
funcname +
"' function may not occur in the where-clause or having-clause of a statement with aggregations as 'previous' does not provide remove stream data; Use the 'first','last','window' or 'count' aggregation functions instead");
}
}
// Compile a map of aggregation nodes and equivalent-to aggregation nodes.
// Equivalent-to functions are for example "select sum(a*b), 5*sum(a*b)".
// Reducing the total number of aggregation functions.
var aggregations = new List<AggregationServiceAggExpressionDesc>();
var intoTableNonRollup = groupByRollupDesc == null && intoTableSpec != null;
foreach (var selectAggNode in selectAggregateExprNodes) {
AddEquivalent(selectAggNode, aggregations, intoTableNonRollup);
}
foreach (var havingAggNode in havingAggregateExprNodes) {
AddEquivalent(havingAggNode, aggregations, intoTableNonRollup);
}
foreach (var orderByAggNode in orderByAggregateExprNodes) {
AddEquivalent(orderByAggNode, aggregations, intoTableNonRollup);
}
// Construct a list of evaluation node for the aggregation functions (regular agg).
// For example "sum(2 * 3)" would make the sum an evaluation node.
IList<ExprForge[]> methodAggForgesList = new List<ExprForge[]>();
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
var forges = aggregateNode.Factory.GetMethodAggregationForge(
typesPerStream.Length > 1,
typesPerStream);
methodAggForgesList.Add(forges);
}
}
// determine local group-by, report when hook provided
var localGroupDesc = AnalyzeLocalGroupBy(aggregations, groupByNodes, groupByRollupDesc, intoTableSpec);
// determine binding
if (intoTableSpec != null) {
// obtain metadata
var metadata = tableCompileTimeResolver.Resolve(intoTableSpec.Name);
if (metadata == null) {
throw new ExprValidationException(
"Invalid into-table clause: Failed to find table by name '" + intoTableSpec.Name + "'");
}
EPLValidationUtil.ValidateContextName(
true,
intoTableSpec.Name,
metadata.OptionalContextName,
optionalContextName,
false);
// validate group keys
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupByNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(
intoTableSpec.Name,
groupByTypes,
"group-by",
groupByNodes,
keyTypes,
"group-by");
// determine how this binds to existing aggregations, assign column numbers
var bindingMatchResult = MatchBindingsAssignColumnNumbers(
intoTableSpec,
metadata,
aggregations,
selectClauseNamedNodes,
methodAggForgesList,
declaredExpressions,
importService,
raw.StatementName);
// return factory
AggregationServiceFactoryForge serviceForgeX = new AggregationServiceFactoryForgeTable(
metadata,
bindingMatchResult.MethodPairs,
bindingMatchResult.TargetStates,
bindingMatchResult.Agents,
groupByRollupDesc);
return new AggregationServiceForgeDesc(serviceForgeX, aggregations, groupKeyExpressions, EmptyList<StmtClassForgeableFactory>.Instance);
}
// Assign a column number to each aggregation node. The regular aggregation goes first followed by access-aggregation.
var columnNumber = 0;
foreach (var entry in aggregations) {
if (!entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
foreach (var entry in aggregations) {
if (entry.Factory.IsAccessAggregation) {
entry.SetColumnNum(columnNumber++);
}
}
// determine method aggregation factories and evaluators(non-access)
var methodAggForges = methodAggForgesList.ToArray();
var methodAggFactories = new AggregationForgeFactory[methodAggForges.Length];
var count = 0;
foreach (var aggregation in aggregations) {
var aggregateNode = aggregation.AggregationNode;
if (!aggregateNode.Factory.IsAccessAggregation) {
methodAggFactories[count] = aggregateNode.Factory;
count++;
}
}
// handle access aggregations
var multiFunctionAggPlan = AggregationMultiFunctionAnalysisHelper.AnalyzeAccessAggregations(
aggregations,
importService,
isFireAndForget,
raw.StatementName,
groupByNodes);
var accessorPairsForge = multiFunctionAggPlan.AccessorPairsForge;
var accessFactories = multiFunctionAggPlan.StateFactoryForges;
var hasAccessAgg = accessorPairsForge.Length > 0;
var hasMethodAgg = methodAggFactories.Length > 0;
AggregationServiceFactoryForge serviceForge;
var useFlags = new AggregationUseFlags(isUnidirectional, isFireAndForget, isOnSelect);
var additionalForgeables = new List<StmtClassForgeableFactory>();
// analyze local group by
AggregationLocalGroupByPlanForge localGroupByPlan = null;
if (localGroupDesc != null) {
AggregationLocalGroupByPlanDesc plan = AggregationGroupByLocalGroupByAnalyzer.Analyze(
methodAggForges,
methodAggFactories,
accessFactories,
localGroupDesc,
groupByNodes,
groupByMultiKey,
accessorPairsForge,
raw,
serdeResolver);
localGroupByPlan = plan.Forge;
additionalForgeables.AddAll(plan.AdditionalForgeables);
try {
var hook = (AggregationLocalLevelHook) ImportUtil.GetAnnotationHook(
annotations,
HookType.INTERNAL_AGGLOCALLEVEL,
typeof(AggregationLocalLevelHook),
importService);
hook?.Planned(localGroupDesc, localGroupByPlan);
}
catch (ExprValidationException) {
throw new EPException("Failed to obtain hook for " + HookType.INTERNAL_AGGLOCALLEVEL);
}
}
// Handle without a group-by clause: we group all into the same pot
var rowStateDesc = new AggregationRowStateForgeDesc(
hasMethodAgg ? methodAggFactories : null,
hasMethodAgg ? methodAggForges : null,
hasAccessAgg ? accessFactories : null,
hasAccessAgg ? accessorPairsForge : null,
useFlags);
if (!hasGroupByClause) {
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(false, localGroupByPlan, useFlags);
}
else {
serviceForge = new AggregationServiceGroupAllForge(rowStateDesc);
}
}
else {
var groupDesc = new AggGroupByDesc(
rowStateDesc,
isUnidirectional,
isFireAndForget,
isOnSelect,
groupByNodes,
groupByMultiKey);
var hasNoReclaim = HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annotations) != null;
var reclaimGroupAged = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
var reclaimGroupFrequency = HintEnum.RECLAIM_GROUP_AGED.GetHint(annotations);
if (localGroupByPlan != null) {
serviceForge = new AggSvcLocalGroupByForge(true, localGroupByPlan, useFlags);
}
else {
if (!isDisallowNoReclaim && hasNoReclaim) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (!isDisallowNoReclaim && reclaimGroupAged != null) {
if (groupByRollupDesc != null) {
throw GetRollupReclaimEx();
}
CompileReclaim(
groupDesc,
reclaimGroupAged,
reclaimGroupFrequency,
variableCompileTimeResolver,
optionalContextName);
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
else if (groupByRollupDesc != null) {
serviceForge = new AggSvcGroupByRollupForge(rowStateDesc, groupByRollupDesc, groupByNodes);
}
else {
groupDesc.IsRefcounted = true;
serviceForge = new AggregationServiceGroupByForge(groupDesc, importService.TimeAbacus);
}
}
}
return new AggregationServiceForgeDesc(serviceForge, aggregations, groupKeyExpressions, additionalForgeables);
}
public static ExprDotDTMethodDesc ValidateMake(
StreamTypeService streamTypeService,
Deque<ExprChainedSpec> chainSpecStack,
DateTimeMethodEnum dtMethod,
string dtMethodName,
EPType inputType,
IList<ExprNode> parameters,
ExprDotNodeFilterAnalyzerInput inputDesc,
TimeAbacus timeAbacus,
ExprEvaluatorContext exprEvaluatorContext,
TableCompileTimeResolver tableCompileTimeResolver)
{
// verify input
var message = "Date-time enumeration method '" +
dtMethodName +
"' requires either a DateTimeEx, DateTimeOffset, DateTime, or long value as input or events of an event type that declares a timestamp property";
if (inputType is EventEPType) {
if (((EventEPType) inputType).EventType.StartTimestampPropertyName == null) {
throw new ExprValidationException(message);
}
}
else {
if (!(inputType is ClassEPType || inputType is NullEPType)) {
throw new ExprValidationException(
message + " but received " + inputType.ToTypeDescriptive());
}
if (inputType is ClassEPType) {
var classEPType = (ClassEPType) inputType;
if (!TypeHelper.IsDateTime(classEPType.Clazz)) {
throw new ExprValidationException(
message + " but received " + classEPType.Clazz.CleanName());
}
}
}
IList<CalendarForge> calendarForges = new List<CalendarForge>();
ReformatForge reformatForge = null;
IntervalForge intervalForge = null;
var currentMethod = dtMethod;
var currentParameters = parameters;
var currentMethodName = dtMethodName;
// drain all calendar op
FilterExprAnalyzerAffector filterAnalyzerDesc = null;
while (true) {
// handle the first one only if its a calendar op
var forges = GetForges(currentParameters);
var opFactory = currentMethod.GetForgeFactory();
// compile parameter abstract for validation against available footprints
DotMethodFPProvided footprintProvided = DotMethodUtil.GetProvidedFootprint(currentParameters);
// validate parameters
DotMethodUtil.ValidateParametersDetermineFootprint(
currentMethod.GetFootprints(),
DotMethodTypeEnum.DATETIME,
currentMethodName,
footprintProvided,
DotMethodInputTypeMatcherImpl.DEFAULT_ALL);
if (opFactory is CalendarForgeFactory) {
var calendarForge = ((CalendarForgeFactory) currentMethod.GetForgeFactory()).GetOp(
currentMethod,
currentMethodName,
currentParameters,
forges);
calendarForges.Add(calendarForge);
}
else if (opFactory is ReformatForgeFactory) {
reformatForge = ((ReformatForgeFactory) opFactory).GetForge(
inputType,
timeAbacus,
currentMethod,
currentMethodName,
currentParameters,
exprEvaluatorContext);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = reformatForge.GetFilterDesc(
streamTypeService.EventTypes,
currentMethod,
currentParameters,
inputDesc);
}
else {
filterAnalyzerDesc = null;
}
}
else if (opFactory is IntervalForgeFactory) {
intervalForge = ((IntervalForgeFactory) opFactory).GetForge(
streamTypeService,
currentMethod,
currentMethodName,
currentParameters,
timeAbacus,
tableCompileTimeResolver);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = intervalForge.GetFilterDesc(
streamTypeService.EventTypes,
currentMethod,
currentParameters,
inputDesc);
}
else {
filterAnalyzerDesc = null;
}
}
else {
throw new IllegalStateException("Invalid op factory class " + opFactory);
}
// see if there is more
if (chainSpecStack.IsEmpty() || !DatetimeMethodEnumHelper.IsDateTimeMethod(chainSpecStack.First.Name)) {
break;
}
// pull next
var next = chainSpecStack.RemoveFirst();
currentMethod = DatetimeMethodEnumHelper.FromName(next.Name);
currentParameters = next.Parameters;
currentMethodName = next.Name;
if (reformatForge != null || intervalForge != null) {
throw new ExprValidationException("Invalid input for date-time method '" + next.Name + "'");
}
}
ExprDotForge dotForge;
EPType returnType;
dotForge = new ExprDotDTForge(
calendarForges,
timeAbacus,
reformatForge,
intervalForge,
inputType.GetClassSingleValued(),
inputType.GetEventTypeSingleValued());
returnType = dotForge.TypeInfo;
return new ExprDotDTMethodDesc(dotForge, returnType, filterAnalyzerDesc);
}
public static ExprDotDTMethodDesc ValidateMake(
StreamTypeService streamTypeService,
Deque<Chainable> chainSpecStack,
DatetimeMethodDesc dtMethod,
string dtMethodName,
EPType inputType,
IList<ExprNode> parameters,
ExprDotNodeFilterAnalyzerInput inputDesc,
TimeAbacus timeAbacus,
TableCompileTimeResolver tableCompileTimeResolver,
ImportServiceCompileTime importService,
StatementRawInfo statementRawInfo)
{
// verify input
var message = "Date-time enumeration method '" +
dtMethodName +
"' requires either a DateTimeEx, DateTimeOffset, DateTime, or long value as input or events of an event type that declares a timestamp property";
if (inputType is EventEPType eventEpType) {
if (eventEpType.EventType.StartTimestampPropertyName == null) {
throw new ExprValidationException(message);
}
}
else {
if (!(inputType is ClassEPType || inputType is NullEPType)) {
throw new ExprValidationException(
message + " but received " + inputType.ToTypeDescriptive());
}
if (inputType is ClassEPType classEpType) {
if (!TypeHelper.IsDateTime(classEpType.Clazz)) {
throw new ExprValidationException(
message + " but received " + classEpType.Clazz.CleanName());
}
}
}
IList<CalendarForge> calendarForges = new List<CalendarForge>();
ReformatForge reformatForge = null;
IntervalForge intervalForge = null;
var currentMethod = dtMethod;
var currentParameters = parameters;
var currentMethodName = dtMethodName;
// drain all calendar op
FilterExprAnalyzerAffector filterAnalyzerDesc = null;
while (true) {
// handle the first one only if its a calendar op
var forges = GetForges(currentParameters);
var opFactory = currentMethod.ForgeFactory;
// compile parameter abstract for validation against available footprints
var footprintProvided = DotMethodUtil.GetProvidedFootprint(currentParameters);
// validate parameters
var footprintFound = DotMethodUtil.ValidateParametersDetermineFootprint(
currentMethod.Footprints,
DotMethodTypeEnum.DATETIME,
currentMethodName,
footprintProvided,
DotMethodInputTypeMatcherImpl.DEFAULT_ALL);
if (opFactory is CalendarForgeFactory calendarForgeFactory) {
var calendarForge = calendarForgeFactory.GetOp(
currentMethod,
currentMethodName,
currentParameters,
forges);
calendarForges.Add(calendarForge);
}
else if (opFactory is ReformatForgeFactory reformatForgeFactory) {
reformatForge = reformatForgeFactory.GetForge(
inputType,
timeAbacus,
currentMethod,
currentMethodName,
currentParameters);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = reformatForge.GetFilterDesc(
streamTypeService.EventTypes,
currentMethod,
currentParameters,
inputDesc);
}
else {
filterAnalyzerDesc = null;
}
}
else if (opFactory is IntervalForgeFactory intervalForgeFactory) {
intervalForge = intervalForgeFactory.GetForge(
streamTypeService,
currentMethod,
currentMethodName,
currentParameters,
timeAbacus,
tableCompileTimeResolver);
// compile filter analyzer information if there are no calendar op in the chain
if (calendarForges.IsEmpty()) {
filterAnalyzerDesc = intervalForge.GetFilterDesc(
streamTypeService.EventTypes,
currentMethod,
currentParameters,
inputDesc);
}
}
else if (opFactory is DTMPluginForgeFactory dtmPluginForgeFactory) {
var usageDesc = new DateTimeMethodValidateContext(
footprintFound,
streamTypeService,
currentMethod,
currentParameters,
statementRawInfo);
var ops = dtmPluginForgeFactory.Validate(usageDesc);
if (ops == null) {
throw new ExprValidationException(
"Plug-in datetime method provider " + dtmPluginForgeFactory.GetType() + " returned a null-value for the operations");
}
var input = EPTypeHelper.GetClassSingleValued(inputType);
if (ops is DateTimeMethodOpsModify dateTimeMethodOpsModify) {
calendarForges.Add(new DTMPluginValueChangeForge(input, dateTimeMethodOpsModify, usageDesc.CurrentParameters));
}
else if (ops is DateTimeMethodOpsReformat dateTimeMethodOpsReformat) {
reformatForge = new DTMPluginReformatForge(input, dateTimeMethodOpsReformat, usageDesc.CurrentParameters);
}
else {
throw new ExprValidationException("Plug-in datetime method ops " + ops.GetType() + " is not recognized");
}
// no action
}
else {
throw new IllegalStateException("Invalid op factory class " + opFactory);
}
// see if there is more
if (chainSpecStack.IsEmpty() || !DatetimeMethodResolver.IsDateTimeMethod(chainSpecStack.First.GetRootNameOrEmptyString(), importService)) {
break;
}
// pull next
var next = chainSpecStack.RemoveFirst();
currentMethodName = next.GetRootNameOrEmptyString();
currentMethod = DatetimeMethodResolver.FromName(currentMethodName, importService);
currentParameters = next.GetParametersOrEmpty();
if (reformatForge != null || intervalForge != null) {
throw new ExprValidationException("Invalid input for date-time method '" + currentMethodName + "'");
}
}
var dotForge = new ExprDotDTForge(
calendarForges,
timeAbacus,
reformatForge,
intervalForge,
inputType.GetClassSingleValued(),
inputType.GetEventTypeSingleValued());
var returnType = dotForge.TypeInfo;
return new ExprDotDTMethodDesc(dotForge, returnType, filterAnalyzerDesc);
}
public IntervalForgeImpl(
DateTimeMethodEnum method,
string methodNameUse,
StreamTypeService streamTypeService,
IList<ExprNode> expressions,
TimeAbacus timeAbacus,
TableCompileTimeResolver tableCompileTimeResolver)
{
ExprForge forgeEndTimestamp = null;
Type timestampType;
if (expressions[0] is ExprStreamUnderlyingNode) {
var und = (ExprStreamUnderlyingNode) expressions[0];
parameterStreamNum = und.StreamId;
var type = streamTypeService.EventTypes[parameterStreamNum];
parameterPropertyStart = type.StartTimestampPropertyName;
if (parameterPropertyStart == null) {
throw new ExprValidationException(
"For date-time method '" +
methodNameUse +
"' the first parameter is event type '" +
type.Name +
"', however no timestamp property has been defined for this event type");
}
timestampType = type.GetPropertyType(parameterPropertyStart);
var getter = ((EventTypeSPI) type).GetGetterSPI(parameterPropertyStart);
var getterReturnTypeBoxed = type.GetPropertyType(parameterPropertyStart).GetBoxedType();
ForgeTimestamp = new ExprEvaluatorStreamDTProp(parameterStreamNum, getter, getterReturnTypeBoxed);
if (type.EndTimestampPropertyName != null) {
parameterPropertyEnd = type.EndTimestampPropertyName;
var getterEndTimestamp =
((EventTypeSPI) type).GetGetterSPI(type.EndTimestampPropertyName);
forgeEndTimestamp = new ExprEvaluatorStreamDTProp(
parameterStreamNum,
getterEndTimestamp,
getterReturnTypeBoxed);
}
else {
parameterPropertyEnd = parameterPropertyStart;
}
}
else {
ForgeTimestamp = expressions[0].Forge;
timestampType = ForgeTimestamp.EvaluationType;
string unresolvedPropertyName = null;
if (expressions[0] is ExprIdentNode) {
var identNode = (ExprIdentNode) expressions[0];
parameterStreamNum = identNode.StreamId;
parameterPropertyStart = identNode.ResolvedPropertyName;
parameterPropertyEnd = parameterPropertyStart;
unresolvedPropertyName = identNode.UnresolvedPropertyName;
}
if (!TypeHelper.IsDateTime(ForgeTimestamp.EvaluationType)) {
// ident node may represent a fragment
if (unresolvedPropertyName != null) {
var propertyDesc = ExprIdentNodeUtil.GetTypeFromStream(
streamTypeService,
unresolvedPropertyName,
false,
true,
tableCompileTimeResolver);
if (propertyDesc.First.FragmentEventType != null) {
var type = propertyDesc.First.FragmentEventType.FragmentType;
parameterPropertyStart = type.StartTimestampPropertyName;
if (parameterPropertyStart == null) {
throw new ExprValidationException(
"For date-time method '" +
methodNameUse +
"' the first parameter is event type '" +
type.Name +
"', however no timestamp property has been defined for this event type");
}
timestampType = type.GetPropertyType(parameterPropertyStart);
var getterFragment =
((EventTypeSPI) streamTypeService.EventTypes[parameterStreamNum]).GetGetterSPI(
unresolvedPropertyName);
var getterStartTimestamp =
((EventTypeSPI) type).GetGetterSPI(parameterPropertyStart);
ForgeTimestamp = new ExprEvaluatorStreamDTPropFragment(
parameterStreamNum,
getterFragment,
getterStartTimestamp);
if (type.EndTimestampPropertyName != null) {
parameterPropertyEnd = type.EndTimestampPropertyName;
var getterEndTimestamp =
((EventTypeSPI) type).GetGetterSPI(type.EndTimestampPropertyName);
forgeEndTimestamp = new ExprEvaluatorStreamDTPropFragment(
parameterStreamNum,
getterFragment,
getterEndTimestamp);
}
else {
parameterPropertyEnd = parameterPropertyStart;
}
}
}
else {
throw new ExprValidationException(
"For date-time method '" +
methodNameUse +
"' the first parameter expression returns '" +
ForgeTimestamp.EvaluationType +
"', however requires a Date, DateTimeEx, Long-type return value or event (with timestamp)");
}
}
}
var intervalComputerForge =
IntervalComputerForgeFactory.Make(method, expressions, timeAbacus);
// evaluation without end timestamp
var timestampTypeBoxed = timestampType.GetBoxedType();
if (forgeEndTimestamp == null) {
if (TypeHelper.IsSubclassOrImplementsInterface(timestampType, typeof(DateTimeEx))) {
IntervalOpForge = new IntervalOpDateTimeExForge(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(long?)) {
IntervalOpForge = new IntervalOpForgeLong(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(DateTimeOffset?)) {
IntervalOpForge = new IntervalOpDateTimeOffsetForge(intervalComputerForge);
}
else if (timestampTypeBoxed == typeof(DateTime?)) {
IntervalOpForge = new IntervalOpDateTimeForge(intervalComputerForge);
}
else {
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
else {
if (TypeHelper.IsSubclassOrImplementsInterface(timestampType, typeof(DateTimeEx))) {
IntervalOpForge = new IntervalOpDateTimeExWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(long?)) {
IntervalOpForge = new IntervalOpLongWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(DateTimeOffset?)) {
IntervalOpForge = new IntervalOpDateTimeOffsetWithEndForge(
intervalComputerForge,
forgeEndTimestamp);
}
else if (timestampTypeBoxed == typeof(DateTime?)) {
IntervalOpForge = new IntervalOpDateTimeWithEndForge(intervalComputerForge, forgeEndTimestamp);
}
else {
throw new ArgumentException("Invalid interval first parameter type '" + timestampType + "'");
}
}
}
public ModuleCompileTimeServices(
IContainer container,
CompilerServices compilerServices,
Configuration configuration,
ContextCompileTimeRegistry contextCompileTimeRegistry,
ContextCompileTimeResolver contextCompileTimeResolver,
BeanEventTypeStemService beanEventTypeStemService,
BeanEventTypeFactoryPrivate beanEventTypeFactoryPrivate,
ClassProvidedCompileTimeRegistry classProvidedCompileTimeRegistry,
ClassProvidedCompileTimeResolver classProvidedCompileTimeResolver,
DatabaseConfigServiceCompileTime databaseConfigServiceCompileTime,
ImportServiceCompileTime importService,
ExprDeclaredCompileTimeRegistry exprDeclaredCompileTimeRegistry,
ExprDeclaredCompileTimeResolver exprDeclaredCompileTimeResolver,
EventTypeAvroHandler eventTypeAvroHandler,
EventTypeCompileTimeRegistry eventTypeCompileTimeRegistry,
EventTypeCompileTimeResolver eventTypeCompileTimeResolver,
EventTypeRepositoryImpl eventTypeRepositoryPreconfigured,
bool fireAndForget,
IndexCompileTimeRegistry indexCompileTimeRegistry,
ModuleDependenciesCompileTime moduleDependencies,
ModuleAccessModifierService moduleVisibilityRules,
NamedWindowCompileTimeResolver namedWindowCompileTimeResolver,
NamedWindowCompileTimeRegistry namedWindowCompileTimeRegistry,
ParentClassLoader parentClassLoader,
PatternObjectResolutionService patternObjectResolutionService,
ScriptCompileTimeRegistry scriptCompileTimeRegistry,
ScriptCompileTimeResolver scriptCompileTimeResolver,
ScriptCompiler scriptCompiler,
SerdeEventTypeCompileTimeRegistry serdeEventTypeRegistry,
SerdeCompileTimeResolver serdeResolver,
TableCompileTimeRegistry tableCompileTimeRegistry,
TableCompileTimeResolver tableCompileTimeResolver,
VariableCompileTimeRegistry variableCompileTimeRegistry,
VariableCompileTimeResolver variableCompileTimeResolver,
ViewResolutionService viewResolutionService,
XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory)
{
var generation = Interlocked.Increment(ref _generation);
Namespace = $"generation_{generation}";
Container = container;
CompilerServices = compilerServices;
Configuration = configuration;
ContextCompileTimeRegistry = contextCompileTimeRegistry;
ContextCompileTimeResolver = contextCompileTimeResolver;
BeanEventTypeStemService = beanEventTypeStemService;
BeanEventTypeFactoryPrivate = beanEventTypeFactoryPrivate;
DatabaseConfigServiceCompileTime = databaseConfigServiceCompileTime;
ImportServiceCompileTime = importService;
ExprDeclaredCompileTimeRegistry = exprDeclaredCompileTimeRegistry;
ExprDeclaredCompileTimeResolver = exprDeclaredCompileTimeResolver;
EventTypeAvroHandler = eventTypeAvroHandler;
EventTypeCompileTimeRegistry = eventTypeCompileTimeRegistry;
EventTypeCompileTimeResolver = eventTypeCompileTimeResolver;
EventTypeRepositoryPreconfigured = eventTypeRepositoryPreconfigured;
IndexCompileTimeRegistry = indexCompileTimeRegistry;
ModuleDependencies = moduleDependencies;
ModuleVisibilityRules = moduleVisibilityRules;
NamedWindowCompileTimeResolver = namedWindowCompileTimeResolver;
NamedWindowCompileTimeRegistry = namedWindowCompileTimeRegistry;
ParentClassLoader = parentClassLoader;
PatternObjectResolutionService = patternObjectResolutionService;
ScriptCompileTimeRegistry = scriptCompileTimeRegistry;
ScriptCompileTimeResolver = scriptCompileTimeResolver;
ScriptCompiler = scriptCompiler;
TableCompileTimeRegistry = tableCompileTimeRegistry;
TableCompileTimeResolver = tableCompileTimeResolver;
VariableCompileTimeRegistry = variableCompileTimeRegistry;
VariableCompileTimeResolver = variableCompileTimeResolver;
ViewResolutionService = viewResolutionService;
XmlFragmentEventTypeFactory = xmlFragmentEventTypeFactory;
#region ESPER_8.5.1
ClassProvidedCompileTimeRegistry = classProvidedCompileTimeRegistry;
ClassProvidedCompileTimeResolver = classProvidedCompileTimeResolver;
SerdeEventTypeRegistry = serdeEventTypeRegistry;
SerdeResolver = serdeResolver;
IsFireAndForget = fireAndForget;
#endregion
}
protected internal static Pair<PropertyResolutionDescriptor, string> GetTypeFromStream(
StreamTypeService streamTypeService,
string unresolvedPropertyName,
string streamOrPropertyNameMayEscaped,
bool obtainFragment,
TableCompileTimeResolver tableCompileTimeResolver)
{
PropertyResolutionDescriptor propertyInfo = null;
// no stream/property name supplied
if (streamOrPropertyNameMayEscaped == null) {
try {
propertyInfo = streamTypeService.ResolveByPropertyName(unresolvedPropertyName, obtainFragment);
}
catch (StreamTypesException ex) {
throw GetSuggestionException(ex);
}
catch (PropertyAccessException ex) {
throw new ExprValidationPropertyException(
"Failed to find property '" +
unresolvedPropertyName +
"', the property name does not parse (are you sure?): " +
ex.Message,
ex);
}
// resolves without a stream name, return descriptor and null stream name
return new Pair<PropertyResolutionDescriptor, string>(propertyInfo, propertyInfo.StreamName);
}
// try to resolve the property name and stream name as it is (ie. stream name as a stream name)
StreamTypesException typeExceptionOne;
var streamOrPropertyName = StringValue.UnescapeBacktick(streamOrPropertyNameMayEscaped);
try {
propertyInfo = streamTypeService.ResolveByStreamAndPropName(
streamOrPropertyName,
unresolvedPropertyName,
obtainFragment);
// resolves with a stream name, return descriptor and stream name
return new Pair<PropertyResolutionDescriptor, string>(propertyInfo, streamOrPropertyName);
}
catch (StreamTypesException ex) {
typeExceptionOne = ex;
}
// try to resolve the property name to a nested property 's0.p0'
StreamTypesException typeExceptionTwo;
var propertyNameCandidate = streamOrPropertyName + '.' + unresolvedPropertyName;
try {
propertyInfo = streamTypeService.ResolveByPropertyName(propertyNameCandidate, obtainFragment);
// resolves without a stream name, return null for stream name
return new Pair<PropertyResolutionDescriptor, string>(propertyInfo, null);
}
catch (StreamTypesException ex) {
typeExceptionTwo = ex;
}
// not resolved yet, perhaps the table name did not match an event type
if (streamTypeService.HasTableTypes && streamOrPropertyName != null) {
for (var i = 0; i < streamTypeService.EventTypes.Length; i++) {
var eventType = streamTypeService.EventTypes[i];
var table = tableCompileTimeResolver.ResolveTableFromEventType(eventType);
if (table != null && table.TableName.Equals(streamOrPropertyName)) {
try {
propertyInfo = streamTypeService.ResolveByStreamAndPropName(
eventType.Name,
unresolvedPropertyName,
obtainFragment);
}
catch (Exception) {
}
if (propertyInfo != null) {
return new Pair<PropertyResolutionDescriptor, string>(propertyInfo, streamOrPropertyName);
}
}
}
}
// see if the stream or property name (the prefix) can be resolved by itself, without suffix
// the property available may be indexed or mapped
try {
var desc = streamTypeService.ResolveByPropertyName(streamOrPropertyName, false);
if (desc != null) {
var d2 = desc.StreamEventType.GetPropertyDescriptor(streamOrPropertyName);
if (d2 != null) {
string text = null;
if (d2.IsIndexed) {
text = "an indexed property and requires an index or enumeration method to access values";
}
if (d2.IsMapped) {
text = "a mapped property and requires keyed access";
}
if (text != null) {
throw new ExprValidationPropertyException(
"Failed to resolve property '" +
propertyNameCandidate +
"' (property '" +
streamOrPropertyName +
"' is " +
text +
")");
}
}
}
}
catch (StreamTypesException) {
// need not be handled
}
throw GetSuggestionExceptionSecondStep(propertyNameCandidate, typeExceptionOne, typeExceptionTwo);
}
private static bool IsTable(
string name,
TableCompileTimeResolver tableCompileTimeResolver)
{
return tableCompileTimeResolver.Resolve(name) != null;
}
public BindProcessorForge(
SelectExprProcessorForge synthetic,
SelectClauseElementCompiled[] selectionList,
EventType[] typesPerStream,
string[] streamNames,
TableCompileTimeResolver tableService)
{
var expressions = new List<ExprForge>();
var types = new List<Type>();
var columnNames = new List<string>();
foreach (var element in selectionList) {
// handle wildcards by outputting each stream's underlying event
if (element is SelectClauseElementWildcard) {
for (var i = 0; i < typesPerStream.Length; i++) {
var returnType = typesPerStream[i].UnderlyingType;
var tableMetadata = tableService.ResolveTableFromEventType(typesPerStream[i]);
ExprForge forge;
if (tableMetadata != null) {
forge = new BindProcessorStreamTable(i, returnType, tableMetadata);
}
else {
forge = new BindProcessorStream(i, returnType);
}
expressions.Add(forge);
types.Add(returnType);
columnNames.Add(streamNames[i]);
}
}
else if (element is SelectClauseStreamCompiledSpec) {
// handle stream wildcards by outputting the stream underlying event
var streamSpec = (SelectClauseStreamCompiledSpec) element;
var type = typesPerStream[streamSpec.StreamNumber];
var returnType = type.UnderlyingType;
var tableMetadata = tableService.ResolveTableFromEventType(type);
ExprForge forge;
if (tableMetadata != null) {
forge = new BindProcessorStreamTable(streamSpec.StreamNumber, returnType, tableMetadata);
}
else {
forge = new BindProcessorStream(streamSpec.StreamNumber, returnType);
}
expressions.Add(forge);
types.Add(returnType);
columnNames.Add(streamNames[streamSpec.StreamNumber]);
}
else if (element is SelectClauseExprCompiledSpec) {
// handle expressions
var expr = (SelectClauseExprCompiledSpec) element;
var forge = expr.SelectExpression.Forge;
expressions.Add(forge);
types.Add(forge.EvaluationType);
if (expr.AssignedName != null) {
columnNames.Add(expr.AssignedName);
}
else {
columnNames.Add(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expr.SelectExpression));
}
}
else {
throw new IllegalStateException(
"Unrecognized select expression element of type " + element.GetType());
}
}
ExpressionForges = expressions.ToArray();
ExpressionTypes = types.ToArray();
ColumnNamesAssigned = columnNames.ToArray();
}
public static bool IsWritesToTables(
StatementSpecRaw statementSpec,
TableCompileTimeResolver tableCompileTimeResolver)
{
// determine if writing to a table:
// insert-into (single)
if (statementSpec.InsertIntoDesc != null) {
if (IsTable(statementSpec.InsertIntoDesc.EventTypeName, tableCompileTimeResolver)) {
return true;
}
}
// into-table
if (statementSpec.IntoTableSpec != null) {
return true;
}
// triggers
if (statementSpec.OnTriggerDesc != null) {
var onTriggerDesc = statementSpec.OnTriggerDesc;
// split-stream insert-into
if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_SPLITSTREAM) {
var split = (OnTriggerSplitStreamDesc) onTriggerDesc;
foreach (var stream in split.SplitStreams) {
if (stream.InsertInto != null &&
IsTable(stream.InsertInto.EventTypeName, tableCompileTimeResolver)) {
return true;
}
}
}
// on-delete/update/merge/on-selectdelete
if (onTriggerDesc is OnTriggerWindowDesc) {
var window = (OnTriggerWindowDesc) onTriggerDesc;
if (onTriggerDesc.OnTriggerType == OnTriggerType.ON_DELETE ||
onTriggerDesc.OnTriggerType == OnTriggerType.ON_UPDATE ||
onTriggerDesc.OnTriggerType == OnTriggerType.ON_MERGE ||
window.IsDeleteAndSelect) {
if (IsTable(window.WindowName, tableCompileTimeResolver)) {
return true;
}
}
}
// on-merge with insert-action
if (onTriggerDesc is OnTriggerMergeDesc) {
var merge = (OnTriggerMergeDesc) onTriggerDesc;
foreach (var item in merge.Items) {
foreach (var action in item.Actions) {
if (CheckOnTriggerMergeAction(action, tableCompileTimeResolver)) {
return true;
}
}
}
if (merge.OptionalInsertNoMatch != null &&
CheckOnTriggerMergeAction(merge.OptionalInsertNoMatch, tableCompileTimeResolver)) {
return true;
}
}
} // end of trigger handling
// fire-and-forget insert/update/delete
if (statementSpec.FireAndForgetSpec != null) {
var faf = statementSpec.FireAndForgetSpec;
if (faf is FireAndForgetSpecDelete ||
faf is FireAndForgetSpecInsert ||
faf is FireAndForgetSpecUpdate) {
if (statementSpec.StreamSpecs.Count == 1) {
return IsTable(
((FilterStreamSpecRaw) statementSpec.StreamSpecs[0]).RawFilterSpec.EventTypeName,
tableCompileTimeResolver);
}
}
}
return false;
}
