private static ObjectArrayEventType MakeTransientOATypeInternal(
string enumMethod,
IDictionary <string, object> boxedPropertyTypes,
string eventTypeNameUUid,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, eventTypeNameUUid);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
boxedPropertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return(oatype);
}
public static ExprForge[] CrontabScheduleValidate(
ExprNodeOrigin origin,
IList<ExprNode> scheduleSpecExpressionList,
bool allowBindingConsumption,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// Validate the expressions
ExprForge[] expressions = new ExprForge[scheduleSpecExpressionList.Count];
int count = 0;
ExprValidationContext validationContext =
new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services)
.WithAllowBindingConsumption(allowBindingConsumption)
.Build();
foreach (ExprNode parameters in scheduleSpecExpressionList) {
ExprNode node = ExprNodeUtilityValidate.GetValidatedSubtree(origin, parameters, validationContext);
expressions[count++] = node.Forge;
}
if (expressions.Length <= 4 || expressions.Length >= 8) {
throw new ExprValidationException(
"Invalid schedule specification: " +
ScheduleSpecUtil.GetExpressionCountException(expressions.Length));
}
return expressions;
}
public override EventType[] GetAddStreamTypes(
string enumMethodUsedName,
IList<string> goesToNames,
EventType inputEventType,
Type collectionComponentType,
IList<ExprDotEvalParam> bodiesAndParameters,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
EventType evalEventType;
if (inputEventType == null) {
evalEventType = ExprDotNodeUtility.MakeTransientOAType(
enumMethodUsedName,
goesToNames[1],
collectionComponentType,
statementRawInfo,
services);
}
else {
evalEventType = inputEventType;
}
var initializationType = bodiesAndParameters[0].BodyForge.EvaluationType;
EventType typeResult = ExprDotNodeUtility.MakeTransientOAType(
enumMethodUsedName,
goesToNames[0],
initializationType,
statementRawInfo,
services);
return new[] {typeResult, evalEventType};
}
public override EventType[] GetAddStreamTypes(
string enumMethodUsedName,
IList<string> goesToNames,
EventType inputEventType,
Type collectionComponentType,
IList<ExprDotEvalParam> bodiesAndParameters,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
EventType firstParamType;
if (inputEventType == null) {
firstParamType = ExprDotNodeUtility.MakeTransientOAType(
enumMethodUsedName,
goesToNames[0],
collectionComponentType,
statementRawInfo,
services);
}
else {
firstParamType = inputEventType;
}
if (goesToNames.Count == 1) {
return new EventType[] {firstParamType};
}
var indexEventType = ExprDotNodeUtility.MakeTransientOAType(
enumMethodUsedName,
goesToNames[1],
typeof(int),
statementRawInfo,
services);
return new EventType[] {firstParamType, indexEventType};
}
public DataInputOutputSerdeForge SerdeForVariable(
Type type,
string variableName,
StatementRawInfo raw)
{
return(SerdeForClass(type, new SerdeProviderAdditionalInfoVariable(raw, variableName)));
}
/// <summary>
/// Walks the chain of lookups and constructs lookup strategy and plan specification based
/// on the index specifications.
/// </summary>
/// <param name="lookupStream">the stream to construct the query plan for</param>
/// <param name="bestChain">the chain that the lookup follows to make best use of indexes</param>
/// <param name="queryGraph">the repository for key properties to indexes</param>
/// <param name="indexSpecsPerStream">specifications of indexes</param>
/// <param name="typesPerStream">event types for each stream</param>
/// <param name="isHistorical">indicator for each stream if it is a historical streams or not</param>
/// <param name="historicalStreamIndexLists">index management, populated for the query plan</param>
/// <param name="tablesPerStream">tables</param>
/// <param name="streamJoinAnalysisResult">stream join analysis</param>
/// <param name="raw">raw statement information</param>
/// <param name="serdeResolver">serde resolver</param>
/// <returns>NestedIterationNode with lookups attached underneath</returns>
public static QueryPlanNodeForgeDesc CreateStreamPlan(
int lookupStream,
int[] bestChain,
QueryGraphForge queryGraph,
QueryPlanIndexForge[] indexSpecsPerStream,
EventType[] typesPerStream,
bool[] isHistorical,
HistoricalStreamIndexListForge[] historicalStreamIndexLists,
TableMetaData[] tablesPerStream,
StreamJoinAnalysisResultCompileTime streamJoinAnalysisResult,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
var nestedIterNode = new NestedIterationNodeForge(bestChain);
var currentLookupStream = lookupStream;
var additionalForgeables = new List<StmtClassForgeableFactory>();
// Walk through each successive lookup
for (var i = 0; i < bestChain.Length; i++) {
var indexedStream = bestChain[i];
QueryPlanNodeForge node;
if (isHistorical[indexedStream]) {
if (historicalStreamIndexLists[indexedStream] == null) {
historicalStreamIndexLists[indexedStream] = new HistoricalStreamIndexListForge(
indexedStream,
typesPerStream,
queryGraph);
}
historicalStreamIndexLists[indexedStream].AddIndex(currentLookupStream);
node = new HistoricalDataPlanNodeForge(
indexedStream,
lookupStream,
currentLookupStream,
typesPerStream.Length,
null);
}
else {
var tableLookupPlan = CreateLookupPlan(
queryGraph,
currentLookupStream,
indexedStream,
streamJoinAnalysisResult.IsVirtualDW(indexedStream),
indexSpecsPerStream[indexedStream],
typesPerStream,
tablesPerStream[indexedStream],
raw,
serdeResolver);
node = new TableLookupNodeForge(tableLookupPlan.Forge);
additionalForgeables.AddAll(tableLookupPlan.AdditionalForgeables);
}
nestedIterNode.AddChildNode(node);
currentLookupStream = bestChain[i];
}
return new QueryPlanNodeForgeDesc(nestedIterNode, additionalForgeables);
}
public override void Initialize(
DotMethodFP footprint,
EnumMethodEnum enumMethod,
string enumMethodUsedName,
EventType inputEventType,
Type collectionComponentType,
IList<ExprNode> parameters,
StreamTypeService streamTypeService,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// validate
var ctx = new EnumMethodValidateContext(
footprint,
inputEventType,
collectionComponentType,
streamTypeService,
enumMethod,
parameters,
statementRawInfo);
var enumMethodMode = _forgeFactory.Validate(ctx);
if (!(enumMethodMode is EnumMethodModeStaticMethod)) {
throw new ExprValidationException("Unexpected EnumMethodMode implementation, expected a provided implementation");
}
Mode = (EnumMethodModeStaticMethod) enumMethodMode;
}
public static IList <StmtClassForgeableFactory> Plan(
EventType eventType,
StatementRawInfo raw,
SerdeEventTypeCompileTimeRegistry registry,
SerdeCompileTimeResolver resolver)
{
// there is no need to register a serde when not using HA, or when it is already registered, or for table-internal type
var typeClass = eventType.Metadata.TypeClass;
if (!registry.IsTargetHA || registry.EventTypes.ContainsKey(eventType) || typeClass == EventTypeTypeClass.TABLE_INTERNAL)
{
return(EmptyList <StmtClassForgeableFactory> .Instance);
}
// there is also no need to register a serde when using a public object
var statementType = raw.StatementType;
if ((typeClass == EventTypeTypeClass.NAMED_WINDOW && statementType != StatementType.CREATE_WINDOW) ||
(typeClass == EventTypeTypeClass.TABLE_PUBLIC && statementType != StatementType.CREATE_TABLE))
{
return(EmptyList <StmtClassForgeableFactory> .Instance);
}
IList <StmtClassForgeableFactory> forgeables = new List <StmtClassForgeableFactory>(2);
PlanRecursive(forgeables, eventType, raw, registry, resolver);
return(forgeables);
}
public ExprNode MakeExprNode(
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices)
{
ExprNode representativeNode = new ExprEqualsNodeImpl(false, false);
representativeNode.AddChildNode(OptLeftNode);
representativeNode.AddChildNode(OptRightNode);
if (AdditionalLeftNodes == null) {
TopValidate(representativeNode, statementRawInfo, compileTimeServices);
return representativeNode;
}
ExprAndNode andNode = new ExprAndNodeImpl();
TopValidate(representativeNode, statementRawInfo, compileTimeServices);
andNode.AddChildNode(representativeNode);
representativeNode = andNode;
for (var i = 0; i < AdditionalLeftNodes.Length; i++) {
ExprEqualsNode eqNode = new ExprEqualsNodeImpl(false, false);
eqNode.AddChildNode(AdditionalLeftNodes[i]);
eqNode.AddChildNode(AdditionalRightNodes[i]);
TopValidate(eqNode, statementRawInfo, compileTimeServices);
andNode.AddChildNode(eqNode);
}
TopValidate(andNode, statementRawInfo, compileTimeServices);
return representativeNode;
}
public override EnumForge GetEnumForge(
StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// TBD: Look at this closer
// TypeInfo = EPTypeHelper.SingleValue(typeof(IDictionary<string, object>));
TypeInfo = EPTypeHelper.SingleValue(typeof(IDictionary<object, object>));
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
var second = (ExprDotEvalParamLambda) bodiesAndParameters[1];
if (inputEventType == null) {
return new EnumToMapScalarLambdaForge(
first.BodyForge,
first.StreamCountIncoming,
second.BodyForge,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
return new EnumToMapEventsForge(first.BodyForge, first.StreamCountIncoming, second.BodyForge);
}
private static JoinSetComposerPrototypeHistoricalDesc DetermineIndexing(
ExprNode filterForIndexing,
EventType polledViewType,
EventType streamViewType,
int polledViewStreamNum,
int streamViewStreamNum,
string[] streamNames,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
// No filter means unindexed event tables
if (filterForIndexing == null) {
return new JoinSetComposerPrototypeHistoricalDesc(
HistoricalIndexLookupStrategyNoIndexForge.INSTANCE,
PollResultIndexingStrategyNoIndexForge.INSTANCE,
EmptyList<StmtClassForgeableFactory>.Instance);
}
// analyze query graph; Whereas stream0=named window, stream1=delete-expr filter
var hint = ExcludePlanHint.GetHint(streamNames, rawInfo, services);
var queryGraph = new QueryGraphForge(2, hint, false);
FilterExprAnalyzer.Analyze(filterForIndexing, queryGraph, false);
return DetermineIndexing(
queryGraph,
polledViewType,
streamViewType,
polledViewStreamNum,
streamViewStreamNum,
rawInfo,
services.SerdeResolver);
}
private static List<StmtClassForgeableFactory> PlanMultikeys(
QueryPlanIndexForge[] indexSpecs,
StatementRawInfo raw,
StatementCompileTimeServices compileTimeServices)
{
List<StmtClassForgeableFactory> multiKeyForgeables = new List<StmtClassForgeableFactory>();
foreach (QueryPlanIndexForge spec in indexSpecs) {
if (spec == null) {
continue;
}
foreach (var entry in spec.Items) {
QueryPlanIndexItemForge forge = entry.Value;
MultiKeyPlan plan = MultiKeyPlanner.PlanMultiKey(
forge.HashTypes, false, raw, compileTimeServices.SerdeResolver);
multiKeyForgeables.AddAll(plan.MultiKeyForgeables);
forge.HashMultiKeyClasses = plan.ClassRef;
DataInputOutputSerdeForge[] rangeSerdes = new DataInputOutputSerdeForge[forge.RangeTypes.Length];
for (int i = 0; i < forge.RangeTypes.Length; i++) {
rangeSerdes[i] = compileTimeServices.SerdeResolver.SerdeForIndexBtree(forge.RangeTypes[i], raw);
}
forge.RangeSerdes = rangeSerdes;
}
}
return multiKeyForgeables;
}
public static ObjectArrayEventType MakeTransientOAType(
string enumMethod,
string propertyName,
Type type,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> propsResult = new Dictionary<string, object>();
propsResult.Put(propertyName, Boxing.GetBoxedType(type));
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, propertyName);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
propsResult,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return oatype;
}
public DataInputOutputSerdeForge SerdeForVariable(
Type type,
string variableName,
StatementRawInfo raw)
{
return(Noop());
}
public override EventType GetEventTypeCollection(
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices)
{
var rawEventType = RawEventType;
var selectClause = SelectClause;
if (selectClause == null) { // wildcards allowed
return rawEventType;
}
// special case: selecting a single property that is itself an event
if (selectClause.Length == 1 && selectClause[0] is ExprIdentNode) {
var identNode = (ExprIdentNode) selectClause[0];
var fragment = rawEventType.GetFragmentType(identNode.ResolvedPropertyName);
if (fragment != null && !fragment.IsIndexed) {
return fragment.FragmentType;
}
}
// select of a single value otherwise results in a collection of scalar values
if (selectClause.Length == 1) {
return null;
}
// fully-aggregated always returns zero or one row
if (SubselectAggregationType == SubqueryAggregationType.FULLY_AGGREGATED_NOPROPS) {
return null;
}
return GetAssignAnonymousType(statementRawInfo, compileTimeServices);
}
public static void ValidateFilterWQueryGraphSafe(
QueryGraphForge queryGraph,
ExprNode filterExpression,
StreamTypeServiceImpl typeService,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
try {
var validationContext = new ExprValidationContextBuilder(typeService, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.WithIsFilterExpression(true)
.Build();
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FILTER,
filterExpression,
validationContext);
FilterExprAnalyzer.Analyze(validated, queryGraph, false);
}
catch (Exception ex) {
Log.Warn(
"Unexpected exception analyzing filterable expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(filterExpression) +
"': " +
ex.Message,
ex);
}
}
private EventType GetAssignAnonymousType(
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> rowType = RowType;
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeSubselectMultirow(SubselectNumber);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.SUBQDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var maptype = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
rowType,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(maptype);
subselectMultirowType = maptype;
return maptype;
}
public override EnumForge GetEnumForge(
StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (bodiesAndParameters.IsEmpty()) {
var aggMethodFactoryInner = GetAggregatorFactory(collectionComponentType);
TypeInfo = EPTypeHelper.SingleValue(aggMethodFactoryInner.ValueType.GetBoxedType());
return new EnumSumScalarForge(numStreamsIncoming, aggMethodFactoryInner);
}
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
var aggMethodFactory = GetAggregatorFactory(first.BodyForge.EvaluationType);
var returnType = aggMethodFactory.ValueType.GetBoxedType();
TypeInfo = EPTypeHelper.SingleValue(returnType);
if (inputEventType == null) {
return new EnumSumScalarLambdaForge(
first.BodyForge,
first.StreamCountIncoming,
aggMethodFactory,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
return new EnumSumEventsForge(first.BodyForge, first.StreamCountIncoming, aggMethodFactory);
}
public override EnumForge GetEnumForge(StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
TypeInfo = EPTypeHelper.SingleValue(typeof(bool?));
if (inputEventType != null) {
if (EnumMethodEnum == EnumMethodEnum.ALLOF) {
return new EnumAllOfEventsForge(first.BodyForge, first.StreamCountIncoming);
}
return new EnumAnyOfEventsForge(first.BodyForge, first.StreamCountIncoming);
}
if (EnumMethodEnum == EnumMethodEnum.ALLOF) {
return new EnumAllOfScalarForge(
first.BodyForge,
first.StreamCountIncoming,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
return new EnumAnyOfScalarForge(
first.BodyForge,
first.StreamCountIncoming,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
public override void ValidateGetContextProps(
LinkedHashMap<string, object> props,
string contextName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var propertyTypes = ContextControllerKeyedUtil.ValidateContextDesc(contextName, detail);
for (var i = 0; i < detail.Items[0].PropertyNames.Count; i++) {
var propertyName = ContextPropertyEventType.PROP_CTX_KEY_PREFIX + (i + 1);
props.Put(propertyName, propertyTypes[i]);
}
var allTags = new LinkedHashSet<string>();
foreach (var item in detail.Items) {
if (item.AliasName != null) {
allTags.Add(item.AliasName);
}
}
if (detail.OptionalInit != null) {
foreach (var filter in detail.OptionalInit) {
ContextPropertyEventType.AddEndpointTypes(filter, props, allTags);
}
}
}
protected override void InitExec(
string aliasName,
StatementSpecCompiled spec,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
}
public override EnumForge GetEnumForge(StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var max = EnumMethodEnum == EnumMethodEnum.MAX;
if (bodiesAndParameters.IsEmpty()) {
var returnTypeX = Boxing.GetBoxedType(collectionComponentType);
TypeInfo = EPTypeHelper.SingleValue(returnTypeX);
return new EnumMinMaxScalarForge(numStreamsIncoming, max, TypeInfo);
}
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
var returnType = Boxing.GetBoxedType(first.BodyForge.EvaluationType);
TypeInfo = EPTypeHelper.SingleValue(returnType);
if (inputEventType == null) {
return new EnumMinMaxScalarLambdaForge(
first.BodyForge,
first.StreamCountIncoming,
max,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
return new EnumMinMaxEventsForge(first.BodyForge, first.StreamCountIncoming, max);
}
public override EnumForge GetEnumForge(StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var isDescending = EnumMethodEnum == EnumMethodEnum.ORDERBYDESC;
if (bodiesAndParameters.IsEmpty()) {
TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null);
return new EnumOrderByAscDescScalarForge(numStreamsIncoming, isDescending);
}
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
if (inputEventType == null) {
TypeInfo = EPTypeHelper.CollectionOfSingleValue(collectionComponentType, null);
return new EnumOrderByAscDescScalarLambdaForge(
first.BodyForge,
first.StreamCountIncoming,
isDescending,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
TypeInfo = EPTypeHelper.CollectionOfEvents(inputEventType);
return new EnumOrderByAscDescEventsForge(first.BodyForge, first.StreamCountIncoming, isDescending);
}
internal ExprValidationContext(
StreamTypeService streamTypeService,
ViewResourceDelegateExpr viewResourceDelegate,
ContextCompileTimeDescriptor contextDescriptor,
bool disablePropertyExpressionEventCollCache,
bool allowRollupFunctions,
bool allowBindingConsumption,
bool allowTableAggReset,
bool isUnidirectionalJoin,
string intoTableName,
bool isFilterExpression,
ExprValidationMemberName memberName,
bool aggregationFutureNameAlreadySet,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices)
{
StreamTypeService = streamTypeService;
ViewResourceDelegate = viewResourceDelegate;
this.contextDescriptor = contextDescriptor;
IsDisablePropertyExpressionEventCollCache = disablePropertyExpressionEventCollCache;
IsAllowRollupFunctions = allowRollupFunctions;
IsAllowBindingConsumption = allowBindingConsumption;
IsAllowTableAggReset = allowTableAggReset;
IsResettingAggregations = isUnidirectionalJoin;
this.intoTableName = intoTableName;
IsFilterExpression = isFilterExpression;
MemberNames = memberName;
IsAggregationFutureNameAlreadySet = aggregationFutureNameAlreadySet;
StatementRawInfo = statementRawInfo;
StatementCompileTimeService = compileTimeServices;
IsExpressionAudit = AuditEnum.EXPRESSION.GetAudit(statementRawInfo.Annotations) != null;
IsExpressionNestedAudit = AuditEnum.EXPRESSION_NESTED.GetAudit(statementRawInfo.Annotations) != null;
}
public static ExcludePlanHint GetHint(
string[] streamNames,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
IList<string> hints = HintEnum.EXCLUDE_PLAN.GetHintAssignedValues(rawInfo.Annotations);
if (hints == null) {
return null;
}
IList<ExprEvaluator> filters = new List<ExprEvaluator>();
foreach (string hint in hints) {
if (string.IsNullOrWhiteSpace(hint)) {
continue;
}
ExprForge forge = ExcludePlanHintExprUtil.ToExpression(hint, rawInfo, services);
if (Boxing.GetBoxedType(forge.EvaluationType) != typeof(bool?)) {
throw new ExprValidationException(
"Expression provided for hint " + HintEnum.EXCLUDE_PLAN + " must return a boolean value");
}
filters.Add(forge.ExprEvaluator);
}
return new ExcludePlanHint(streamNames, filters, services);
}
public static EPType OptionalFromEnumerationExpr(
StatementRawInfo raw,
StatementCompileTimeServices services,
ExprNode exprNode)
{
if (!(exprNode is ExprEnumerationForge)) {
return null;
}
var enumInfo = (ExprEnumerationForge) exprNode;
if (enumInfo.ComponentTypeCollection != null) {
return CollectionOfSingleValue(
enumInfo.ComponentTypeCollection,
typeof(ICollection<>).MakeGenericType(enumInfo.ComponentTypeCollection));
}
var eventTypeSingle = enumInfo.GetEventTypeSingle(raw, services);
if (eventTypeSingle != null) {
return SingleEvent(eventTypeSingle);
}
var eventTypeColl = enumInfo.GetEventTypeCollection(raw, services);
if (eventTypeColl != null) {
return CollectionOfEvents(eventTypeColl);
}
return null;
}
protected internal static ExprNode ValidateJoinNamedWindow(
ExprNodeOrigin exprNodeOrigin,
ExprNode deleteJoinExpr,
EventType namedWindowType,
string namedWindowStreamName,
string namedWindowName,
EventType filteredType,
string filterStreamName,
string filteredTypeName,
string optionalTableName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices
)
{
if (deleteJoinExpr == null) {
return null;
}
var namesAndTypes = new LinkedHashMap<string, Pair<EventType, string>>();
namesAndTypes.Put(namedWindowStreamName, new Pair<EventType, string>(namedWindowType, namedWindowName));
namesAndTypes.Put(filterStreamName, new Pair<EventType, string>(filteredType, filteredTypeName));
StreamTypeService typeService = new StreamTypeServiceImpl(namesAndTypes, false, false);
var validationContext = new ExprValidationContextBuilder(typeService, statementRawInfo, compileTimeServices)
.WithAllowBindingConsumption(true)
.Build();
return ExprNodeUtilityValidate.GetValidatedSubtree(exprNodeOrigin, deleteJoinExpr, validationContext);
}
public override EnumForge GetEnumForge(StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var initValueParam = bodiesAndParameters[0];
var initValueEval = initValueParam.BodyForge;
TypeInfo = EPTypeHelper.SingleValue(initValueEval.EvaluationType.GetBoxedType());
var resultAndAdd = (ExprDotEvalParamLambda) bodiesAndParameters[1];
if (inputEventType != null) {
return new EnumAggregateEventsForge(
initValueEval,
resultAndAdd.BodyForge,
resultAndAdd.StreamCountIncoming,
(ObjectArrayEventType) resultAndAdd.GoesToTypes[0]);
}
return new EnumAggregateScalarForge(
initValueEval,
resultAndAdd.BodyForge,
resultAndAdd.StreamCountIncoming,
(ObjectArrayEventType) resultAndAdd.GoesToTypes[0],
(ObjectArrayEventType) resultAndAdd.GoesToTypes[1]);
}
public SelectProcessorArgs(
SelectClauseElementCompiled[] selectionList,
GroupByRollupInfo groupByRollupInfo,
bool isUsingWildcard,
EventType optionalInsertIntoEventType,
ForClauseSpec forClauseSpec,
StreamTypeService typeService,
ContextCompileTimeDescriptor contextDescriptor,
bool isFireAndForget,
Attribute[] annotations,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices compileTimeServices)
{
SelectionList = selectionList;
GroupByRollupInfo = groupByRollupInfo;
IsUsingWildcard = isUsingWildcard;
OptionalInsertIntoEventType = optionalInsertIntoEventType;
ForClauseSpec = forClauseSpec;
TypeService = typeService;
ContextDescriptor = contextDescriptor;
IsFireAndForget = isFireAndForget;
Annotations = annotations;
StatementRawInfo = statementRawInfo;
CompileTimeServices = compileTimeServices;
}
