public CodegenExpression ToExpression(
string rowFactory,
string rowSerde,
CodegenExpression groupKeyEval)
{
return NewInstance<AggregationLocalGroupByLevel>(
NewInstance(rowFactory, Ref("this")),
NewInstance(rowSerde, Ref("this")),
Constant(ExprNodeUtilityQuery.GetExprResultTypes(PartitionForges)),
groupKeyEval,
Constant(IsDefaultLevel));
}
private static void AnalyzeInNodeSingleIndex(
ExprInNode inNode,
QueryGraphForge queryGraph)
{
if (!(inNode.ChildNodes[0] is ExprIdentNode)) {
return;
}
var testIdent = (ExprIdentNode) inNode.ChildNodes[0];
var testIdentClass = testIdent.Forge.EvaluationType.GetBoxedType();
var indexedStream = testIdent.StreamId;
var setExpressions = GetInNodeSetExpressions(inNode);
if (setExpressions.Length == 0) {
return;
}
var perStreamExprs = new LinkedHashMap<int?, IList<ExprNode>>();
foreach (var exprNodeSet in setExpressions) {
if (exprNodeSet.Forge.EvaluationType.GetBoxedType() != testIdentClass) {
continue;
}
if (exprNodeSet is ExprIdentNode) {
var setIdent = (ExprIdentNode) exprNodeSet;
AddToList(setIdent.StreamId, setIdent, perStreamExprs);
}
else {
var eligibility = EligibilityUtil.VerifyInputStream(exprNodeSet, indexedStream);
if (!eligibility.Eligibility.IsEligible()) {
continue;
}
AddToList(eligibility.StreamNum, exprNodeSet, perStreamExprs);
}
}
foreach (var entry in perStreamExprs) {
var exprNodes = ExprNodeUtilityQuery.ToArray(entry.Value);
if (entry.Key == null) {
queryGraph.AddInSetSingleIndexUnkeyed(testIdent.StreamId, testIdent, exprNodes);
continue;
}
if (entry.Key != indexedStream) {
queryGraph.AddInSetSingleIndex(testIdent.StreamId, testIdent, entry.Key.Value, exprNodes);
}
}
}
public AggregatorAccessSortedImpl(
bool join,
AggregationStateSortedForge forge,
int col,
CodegenCtor ctor,
CodegenMemberCol membersColumnized,
CodegenClassScope classScope,
ExprNode optionalFilter)
: base(optionalFilter)
{
this.forge = forge;
sorted = membersColumnized.AddMember(col, typeof(OrderedDictionary<object,object>), "sorted");
size = membersColumnized.AddMember(col, typeof(int), "size");
var types = ExprNodeUtilityQuery.GetExprResultTypes(forge.Spec.Criteria);
comparator = classScope.AddOrGetDefaultFieldSharable(
new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
forge.Spec.IsSortUsingCollator,
forge.Spec.SortDescending));
ctor.Block.AssignRef(sorted, NewInstance(typeof(OrderedDictionary<object, object>), comparator));
sortedSerde = classScope.AddOrGetDefaultFieldSharable(
new ProxyCodegenFieldSharable {
ProcType = () => { return typeof(DIOSerdeTreeMapEventsMayDeque); },
ProcInitCtorScoped = () => {
var type = EventTypeUtility.ResolveTypeCodegen(
forge.Spec.StreamEventType,
EPStatementInitServicesConstants.REF);
return ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.DATAINPUTOUTPUTSERDEPROVIDER)
.Add(
"TreeMapEventsMayDeque",
Constant(forge.Spec.CriteriaTypes),
type);
}
});
if (join) {
joinRefs = membersColumnized.AddMember(col, typeof(RefCountedSetAtomicInteger<object>), "refs");
ctor.Block.AssignRef(joinRefs, NewInstance(typeof(RefCountedSetAtomicInteger<object>)));
joinRefsSerde = classScope.AddOrGetDefaultFieldSharable(
new CodegenSharableSerdeEventTyped(REFCOUNTEDSETATOMICINTEGER, forge.Spec.StreamEventType));
}
else {
joinRefs = null;
joinRefsSerde = null;
}
}
public AdvancedIndexConfigContextPartition ValidateConfigureFilterIndex(
string indexName,
string indexTypeName,
ExprNode[] parameters,
ExprValidationContext validationContext)
{
ValidateParameters(indexTypeName, parameters);
try {
return ConfigureQuadTree(indexName, ExprNodeUtilityQuery.GetEvaluatorsNoCompile(parameters), null);
}
catch (EPException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
private AggregationForgeFactoryAccessSorted HandleCreateTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0) {
throw new ExprValidationException("Missing the sort criteria expression");
}
var message = "For tables columns, the aggregation function requires the 'sorted(*)' declaration";
if (!sortedwin && !ever) {
throw new ExprValidationException(message);
}
if (validationContext.StreamTypeService.StreamNames.Length == 0) {
throw new ExprValidationException("'Sorted' requires that the event type is provided");
}
var containedType = validationContext.StreamTypeService.EventTypes[0];
var componentType = containedType.UnderlyingType;
var criteriaExpressions = CriteriaExpressions;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
if (!sortedwin) {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
var stateDesc = new SortedAggregationStateDesc(
IsMax,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaExpressions.Second,
ever,
0,
this,
null,
containedType);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
null,
stateDesc,
null);
}
public CodegenExpression ToExpression(
string rowFactory,
string rowSerde,
CodegenExpression groupKeyEval,
CodegenMethod method,
CodegenClassScope classScope)
{
return NewInstance<AggregationLocalGroupByLevel>(
NewInstanceInner(rowFactory, Ref("this")),
NewInstanceInner(rowSerde, Ref("this")),
Constant(ExprNodeUtilityQuery.GetExprResultTypes(PartitionForges)),
groupKeyEval,
Constant(IsDefaultLevel),
PartitionMKClasses.GetExprMKSerde(method, classScope));
}
protected void ValidateGroupKeys(
TableMetaData metadata,
ExprValidationContext validationContext)
{
if (ChildNodes.Length > 0) {
groupKeyEvaluators = ExprNodeUtilityQuery.GetForges(ChildNodes);
}
else {
groupKeyEvaluators = new ExprForge[0];
}
var typesReturned = ExprNodeUtilityQuery.GetExprResultTypes(ChildNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(TableName, typesReturned, "key", ChildNodes, keyTypes, "key");
}
public static void Assign(
ExprNode[] criteriaExpressions,
MultiKeyClassRef multiKeyClassNames,
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpression criteriaEval = MultiKeyCodegen.CodegenExprEvaluatorMayMultikey(criteriaExpressions, null, multiKeyClassNames, method, classScope);
method.Block
.SetProperty(factory, "CriteriaEval", criteriaEval)
.SetProperty(factory, "CriteriaTypes", Constant(ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions)))
.SetProperty(factory, "KeySerde", multiKeyClassNames.GetExprMKSerde(method, classScope));
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
int count = 0;
ExprValidationContext validationContext =
new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
ExprNode[] inputParamNodes = new ExprNode[inputParameters.Length];
foreach (string inputParam in inputParameters) {
ExprNode raw = FindSQLExpressionNode(StreamNum, count, @base.StatementSpec.Raw.SqlParameters);
if (raw == null) {
throw new ExprValidationException(
"Internal error find expression for historical stream parameter " +
count +
" stream " +
StreamNum);
}
ExprNode evaluator = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DATABASEPOLL,
raw,
validationContext);
inputParamNodes[count++] = evaluator;
ExprNodeIdentifierCollectVisitor visitor = new ExprNodeIdentifierCollectVisitor();
visitor.Visit(evaluator);
foreach (ExprIdentNode identNode in visitor.ExprProperties) {
if (identNode.StreamId == StreamNum) {
throw new ExprValidationException(
"Invalid expression '" + inputParam + "' resolves to the historical data itself");
}
SubordinateStreams.Add(identNode.StreamId);
}
}
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(inputParamNodes);
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
return multiKeyPlan.MultiKeyForgeables;
}
public CodegenExpression Make(
CodegenMethodScope parentInitMethod,
CodegenClassScope classScope)
{
var method = parentInitMethod.MakeChild(typeof(ScriptDescriptorRuntime), GetType(), classScope)
.AddParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref);
method.Block
.DeclareVar<ScriptDescriptorRuntime>("sd", NewInstance(typeof(ScriptDescriptorRuntime)))
.SetProperty(Ref("sd"), "OptionalDialect", Constant(OptionalDialect))
.SetProperty(Ref("sd"), "ScriptName", Constant(ScriptName))
.SetProperty(Ref("sd"), "Expression", Constant(Expression))
.SetProperty(Ref("sd"), "ParameterNames", Constant(ParameterNames))
.SetProperty(
Ref("sd"),
"EvaluationTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(Parameters)))
.SetProperty(
Ref("sd"),
"Parameters",
ExprNodeUtilityCodegen.CodegenEvaluators(Parameters, method, GetType(), classScope))
.SetProperty(Ref("sd"), "DefaultDialect", Constant(_defaultDialect))
.SetProperty(
Ref("sd"),
"ImportService",
ExprDotName(
EPStatementInitServicesConstants.REF,
EPStatementInitServicesConstants.IMPORTSERVICERUNTIME))
.SetProperty(
Ref("sd"),
"ScriptCompiler",
ExprDotName(
EPStatementInitServicesConstants.REF,
EPStatementInitServicesConstants.SCRIPTCOMPILER))
.SetProperty(
Ref("sd"),
"Coercer",
ReturnType.IsNumeric()
? StaticMethod(
typeof(SimpleNumberCoercerFactory),
"GetCoercer",
Constant(typeof(object)),
Constant(ReturnType.GetBoxedType()))
: ConstantNull())
.MethodReturn(Ref("sd"));
return LocalMethod(method, EPStatementInitServicesConstants.REF);
}
public CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(TypeOfPlanFactory(), GetType(), classScope);
IList<CodegenExpression> @params = new List<CodegenExpression>(6);
@params.Add(Constant(lookupStream));
@params.Add(Constant(indexedStream));
@params.Add(
CodegenMakeableUtil.MakeArray(
"reqIdxKeys",
typeof(TableLookupIndexReqKey),
IndexNum,
GetType(),
method,
symbols,
classScope));
@params.AddAll(AdditionalParams(method, symbols, classScope));
method.Block
.DeclareVar(TypeOfPlanFactory(), "plan", NewInstance(TypeOfPlanFactory(), @params.ToArray()));
// inject additional information for virtual data windows
if (indexedStreamIsVDW) {
var keyDesc = KeyDescriptor;
var hashes = keyDesc.HashExpressions;
var ranges = keyDesc.Ranges.ToArray();
var rangeResults = QueryGraphValueEntryRangeForge.GetRangeResultTypes(ranges);
method.Block
.SetProperty(
Ref("plan"),
"VirtualDWHashEvals",
ExprNodeUtilityCodegen.CodegenEvaluators(hashes, method, GetType(), classScope))
.SetProperty(
Ref("plan"),
"VirtualDWHashTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(hashes)))
.SetProperty(
Ref("plan"),
"VirtualDWRangeEvals",
QueryGraphValueEntryRangeForge.MakeArray(ranges, method, symbols, classScope))
.SetProperty(Ref("plan"), "VirtualDWRangeTypes", Constant(rangeResults));
}
method.Block.MethodReturn(Ref("plan"));
return LocalMethod(method);
}
public void ProviderCodegen(
CodegenMethod method,
CodegenClassScope classScope,
AggregationClassNames classNames)
{
var groupByTypes = ExprNodeUtilityQuery.GetExprResultTypes(aggGroupByDesc.GroupByNodes);
if (aggGroupByDesc.IsReclaimAged) {
reclaimAge = aggGroupByDesc.ReclaimEvaluationFunctionMaxAge.Make(classScope);
reclaimFreq = aggGroupByDesc.ReclaimEvaluationFunctionFrequency.Make(classScope);
}
else {
reclaimAge = ConstantNull();
reclaimFreq = ConstantNull();
}
var stmtFields = ResultSetProcessorCodegenNames.REF_STATEMENT_FIELDS;
var timeAbacus = classScope.AddOrGetDefaultFieldSharable(TimeAbacusField.INSTANCE);
method.Block
.DeclareVar<AggregationRowFactory>(
"rowFactory",
NewInstanceInner(classNames.RowFactoryTop, Ref("this")))
.DeclareVar<DataInputOutputSerde<AggregationRow>>(
"rowSerde",
NewInstanceInner(classNames.RowSerdeTop, Ref("this")))
.DeclareVar<AggregationServiceFactory>(
"svcFactory",
NewInstanceInner(classNames.ServiceFactory, Ref("this")))
.DeclareVar<DataInputOutputSerde>(
"serde", aggGroupByDesc.GroupByMultiKey.GetExprMKSerde(method, classScope))
.MethodReturn(
ExprDotMethodChain(EPStatementInitServicesConstants.REF)
.Get(EPStatementInitServicesConstants.AGGREGATIONSERVICEFACTORYSERVICE)
.Add(
"GroupBy",
Ref("svcFactory"),
Ref("rowFactory"),
aggGroupByDesc.RowStateForgeDescs.UseFlags.ToExpression(),
Ref("rowSerde"),
Constant(groupByTypes),
reclaimAge,
reclaimFreq,
timeAbacus,
Ref("serde")));
}
public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
if (scheduleCallbackId == -1) {
throw new IllegalStateException("Unassigned schedule callback id");
}
var method = parent.MakeChild(
typeof(TimerAtObserverFactory),
typeof(TimerIntervalObserverForge),
classScope);
CodegenExpression parametersExpr;
CodegenExpression optionalConvertorExpr;
CodegenExpression specExpr;
if (spec != null) { // handle all-constant specification
parametersExpr = ConstantNull();
optionalConvertorExpr = ConstantNull();
specExpr = spec.Make(method, classScope);
}
else {
specExpr = ConstantNull();
optionalConvertorExpr = convertor.MakeAnonymous(method, classScope);
parametersExpr = ExprNodeUtilityCodegen.CodegenEvaluators(
ExprNodeUtilityQuery.ToArray(parameters),
method,
GetType(),
classScope);
}
method.Block
.DeclareVar<TimerAtObserverFactory>(
"factory",
ExprDotMethodChain(symbols.GetAddInitSvc(method))
.Get(EPStatementInitServicesConstants.PATTERNFACTORYSERVICE)
.Add("ObserverTimerAt"))
.SetProperty(Ref("factory"), "ScheduleCallbackId", Constant(scheduleCallbackId))
.SetProperty(Ref("factory"), "Parameters", parametersExpr)
.SetProperty(Ref("factory"), "OptionalConvertor", optionalConvertorExpr)
.SetProperty(Ref("factory"), "Spec", specExpr)
.MethodReturn(Ref("factory"));
return LocalMethod(method);
}
private static CodegenFieldSharable GetComparator(
OrderByElementForge[] orderBy,
bool isSortUsingCollator)
{
var nodes = new ExprNode[orderBy.Length];
var descending = new bool[orderBy.Length];
for (var i = 0; i < orderBy.Length; i++) {
nodes[i] = orderBy[i].ExprNode;
descending[i] = orderBy[i].IsDescending();
}
var types = ExprNodeUtilityQuery.GetExprResultTypes(nodes);
return new CodegenFieldSharableComparator(
COMPARATORHASHABLEMULTIKEYS,
types,
isSortUsingCollator,
descending);
}
public static InstanceManufacturerFactory GetManufacturer(
Type targetClass,
ImportServiceCompileTime importService,
ExprNode[] childNodes)
{
var forgesUnmodified = ExprNodeUtilityQuery.GetForges(childNodes);
var returnTypes = new object[forgesUnmodified.Length];
for (var i = 0; i < forgesUnmodified.Length; i++) {
returnTypes[i] = forgesUnmodified[i].EvaluationType;
}
var ctor = InstanceManufacturerUtil.GetManufacturer(
targetClass,
importService,
forgesUnmodified,
returnTypes);
return new InstanceManufacturerFactoryFastCtor(targetClass, ctor.First, ctor.Second);
}
public override void Attach(
EventType parentEventType,
int streamNumber,
ViewForgeEnv viewForgeEnv)
{
eventType = parentEventType;
var message =
NAME + " window requires a numeric size parameter and a list of expressions providing sort keys";
if (viewParameters.Count < 2) {
throw new ViewParameterException(message);
}
var validated = ViewForgeSupport.Validate(
NAME + " window",
parentEventType,
viewParameters,
true,
viewForgeEnv,
streamNumber);
for (var i = 1; i < validated.Length; i++) {
ViewForgeSupport.AssertReturnsNonConstant(NAME + " window", validated[i], i);
}
ViewForgeSupport.ValidateNoProperties(ViewName, validated[0], 0);
sizeForge = ViewForgeSupport.ValidateSizeParam(ViewName, validated[0], 0);
sortCriteriaExpressions = new ExprNode[validated.Length - 1];
isDescendingValues = new bool[sortCriteriaExpressions.Length];
for (var i = 1; i < validated.Length; i++) {
if (validated[i] is ExprOrderedExpr) {
isDescendingValues[i - 1] = ((ExprOrderedExpr) validated[i]).IsDescending;
sortCriteriaExpressions[i - 1] = validated[i].ChildNodes[0];
}
else {
sortCriteriaExpressions[i - 1] = validated[i];
}
}
sortSerdes = viewForgeEnv.SerdeResolver.SerdeForDataWindowSortCriteria(
ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions),
viewForgeEnv.StatementRawInfo);
}
public static ISet<string> GetUniqueCandidateProperties(
IList<ViewFactoryForge> forges,
Attribute[] annotations)
{
var disableUniqueImplicit = HintEnum.DISABLE_UNIQUE_IMPLICIT_IDX.GetHint(annotations) != null;
if (forges == null || forges.IsEmpty()) {
return null;
}
if (forges[0] is GroupByViewFactoryForge) {
var grouped = (GroupByViewFactoryForge) forges[0];
var criteria = grouped.CriteriaExpressions;
var groupedCriteria = ExprNodeUtilityQuery.GetPropertyNamesIfAllProps(criteria);
if (groupedCriteria == null) {
return null;
}
var inner = grouped.Groupeds[0];
if (inner is DataWindowViewForgeUniqueCandidate && !disableUniqueImplicit) {
var uniqueFactory = (DataWindowViewForgeUniqueCandidate) inner;
var uniqueCandidates = uniqueFactory.UniquenessCandidatePropertyNames;
if (uniqueCandidates != null) {
uniqueCandidates.AddAll(groupedCriteria);
}
return uniqueCandidates;
}
return null;
}
if (forges[0] is DataWindowViewForgeUniqueCandidate && !disableUniqueImplicit) {
var uniqueFactory = (DataWindowViewForgeUniqueCandidate) forges[0];
return uniqueFactory.UniquenessCandidatePropertyNames;
}
if (forges[0] is VirtualDWViewFactoryForge) {
var vdw = (VirtualDWViewFactoryForge) forges[0];
return vdw.UniqueKeys;
}
return null;
}
public static CodegenExpression CodegenExprEvaluatorMayMultikey(
ExprNode[] expressionNodes,
Type[] optionalCoercionTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
if (expressionNodes == null || expressionNodes.Length == 0)
{
return(ConstantNull());
}
return(CodegenExprEvaluatorMayMultikey(
ExprNodeUtilityQuery.GetForges(expressionNodes),
optionalCoercionTypes,
multiKeyClassRef,
method,
classScope));
}
public override EventBean[] GetEventsPerStreamRewritten(
EventBean[] eps,
bool isNewData,
ExprEvaluatorContext context)
{
if (_evaluators == null) {
_evaluators = ExprNodeUtilityQuery.GetEvaluatorsNoCompile(_valueExpressions);
}
var props = new object[_valueEventType.PropertyNames.Length];
for (var i = 0; i < _evaluators.Length; i++) {
props[i] = _evaluators[i].Evaluate(eps, isNewData, context);
}
var events = new EventBean[_eventEnumerationForges.Length];
for (var i = 0; i < _eventEnumerationForges.Length; i++) {
events[i] = _eventEnumerationForges[i].ExprEvaluatorEnumeration.EvaluateGetEventBean(eps, isNewData, context);
}
return events;
}
internal override void Assign(
CodegenMethod method,
CodegenExpressionRef factory,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
method.Block
.SetProperty(factory, "SizeEvaluator", CodegenEvaluator(sizeForge, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaEvaluators",
CodegenEvaluators(sortCriteriaExpressions, method, GetType(), classScope))
.SetProperty(
factory,
"SortCriteriaTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(sortCriteriaExpressions)))
.SetProperty(factory, "IsDescendingValues", Constant(isDescendingValues))
.SetProperty(factory, "IsUseCollatorSort", Constant(useCollatorSort))
.SetProperty(factory, "SortSerdes", DataInputOutputSerdeForgeExtensions.CodegenArray(sortSerdes, method, classScope, null));
}
private void ValidateIndexNamedParameter(ExprValidationContext validationContext)
{
if (indexNamedParameter.Length != 1 || !(indexNamedParameter[0] is ExprDeclaredNode)) {
throw GetIndexNameMessage("requires an expression name");
}
var node = (ExprDeclaredNode) indexNamedParameter[0];
if (!(node.Body is ExprDotNode)) {
throw GetIndexNameMessage("requires an index expression");
}
var dotNode = (ExprDotNode) node.Body;
if (dotNode.ChainSpec.Count > 1) {
throw GetIndexNameMessage("invalid chained index expression");
}
IList<ExprNode> @params = dotNode.ChainSpec[0].GetParametersOrEmpty();
string indexTypeName = dotNode.ChainSpec[0].GetRootNameOrEmptyString();
optionalIndexName = node.Prototype.Name;
AdvancedIndexFactoryProvider provider = null;
try {
provider = validationContext.ImportService.ResolveAdvancedIndexProvider(indexTypeName);
}
catch (ImportException e) {
throw new ExprValidationException(e.Message, e);
}
if (!indexTypeName.ToLowerInvariant().Equals(IndexTypeName)) {
throw new ExprValidationException(
"Invalid index type '" + indexTypeName + "', expected '" + IndexTypeName + "'");
}
optionalIndexConfig = provider.ValidateConfigureFilterIndex(
optionalIndexName,
indexTypeName,
ExprNodeUtilityQuery.ToArray(@params),
validationContext);
}
public ResultSetProcessorRowPerGroupRollupForge(
EventType resultEventType,
GroupByRollupPerLevelForge perLevelForges,
ExprNode[] groupKeyNodeExpressions,
bool isSelectRStream,
bool isUnidirectional,
OutputLimitSpec outputLimitSpec,
bool isSorting,
bool noDataWindowSingleStream,
AggregationGroupByRollupDescForge groupByRollupDesc,
bool isJoin,
bool isHistoricalOnly,
bool iterateUnbounded,
ResultSetProcessorOutputConditionType? outputConditionType,
OutputConditionPolledFactoryForge optionalOutputFirstConditionFactory,
EventType[] eventTypes,
MultiKeyClassRef multiKeyClassRef)
{
ResultEventType = resultEventType;
GroupKeyNodeExpressions = groupKeyNodeExpressions;
PerLevelForges = perLevelForges;
IsSorting = isSorting;
IsSelectRStream = isSelectRStream;
IsUnidirectional = isUnidirectional;
OutputLimitSpec = outputLimitSpec;
var noDataWindowSingleSnapshot = iterateUnbounded ||
outputLimitSpec != null &&
outputLimitSpec.DisplayLimit == OutputLimitLimitType.SNAPSHOT &&
noDataWindowSingleStream;
unbounded = noDataWindowSingleSnapshot && !isHistoricalOnly;
GroupByRollupDesc = groupByRollupDesc;
IsJoin = isJoin;
IsHistoricalOnly = isHistoricalOnly;
OutputConditionType = outputConditionType;
OptionalOutputFirstConditionFactory = optionalOutputFirstConditionFactory;
EventTypes = eventTypes;
GroupKeyTypes = ExprNodeUtilityQuery.GetExprResultTypes(groupKeyNodeExpressions);
MultiKeyClassRef = multiKeyClassRef;
}
public override void Accept(ExprNodeVisitorWithParent visitor)
{
base.Accept(visitor);
ExprNodeUtilityQuery.AcceptParams(visitor, Parameters);
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate and visit
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
var validatedInputParameters = new List<ExprNode>();
foreach (var exprNode in methodStreamSpec.Expressions) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.METHODINVJOIN,
exprNode,
validationContext);
validatedInputParameters.Add(validated);
validated.Accept(visitor);
}
// determine required streams
foreach (ExprNodePropOrStreamDesc @ref in visitor.Refs) {
SubordinateStreams.Add(@ref.StreamNum);
}
// class-based evaluation
MethodInfo targetMethod = null;
if (metadata.MethodProviderClass != null) {
// resolve actual method to use
ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler {
ProcHandle = e => {
if (methodStreamSpec.Expressions.Count == 0) {
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting no parameters in method: " +
e.Message);
}
var resultTypes = ExprNodeUtilityQuery.GetExprResultTypes(validatedInputParameters);
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting a method where parameters are typed '" +
TypeHelper.GetParameterAsString(resultTypes) +
"': " +
e.Message);
}
};
var desc = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream(
metadata.MethodProviderClass.FullName,
metadata.IsStaticMethod ? null : metadata.MethodProviderClass,
methodStreamSpec.MethodName,
validatedInputParameters,
false,
null,
handler,
methodStreamSpec.MethodName,
@base.StatementRawInfo,
services);
InputParamEvaluators = desc.ChildForges;
targetMethod = desc.ReflectionMethod;
}
else {
// script-based evaluation
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(ExprNodeUtilityQuery.ToArray(validatedInputParameters));
}
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
Pair<MethodTargetStrategyForge, MethodConversionStrategyForge> strategies =
PollExecStrategyPlanner.Plan(metadata, targetMethod, EventType);
target = strategies.First;
conversion = strategies.Second;
return multiKeyPlan.MultiKeyForgeables;
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (Script.ParameterNames.Length != Parameters.Count) {
throw new ExprValidationException(
string.Format(
"Invalid number of parameters for script '{0}', expected {1} parameters but received {2} parameters",
Script.Name,
Script.ParameterNames.Length,
Parameters.Count));
}
if (!validationContext.StatementCompileTimeService.Configuration.Compiler.Scripts.IsEnabled) {
throw new ExprValidationException("Script compilation has been disabled by configuration");
}
// validate all expression parameters
var validatedParameters = Parameters
.Select(
expr => ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.SCRIPTPARAMS,
expr,
validationContext))
.ToList();
// set up map of input parameter names and evaluators
var forges = new ExprForge[Script.ParameterNames.Length];
for (var i = 0; i < Script.ParameterNames.Length; i++) {
forges[i] = validatedParameters[i].Forge;
}
Parameters = validatedParameters;
// Compile script
var parameterTypes = ExprNodeUtilityQuery.GetExprResultTypes(forges);
var dialect = Script.OptionalDialect ?? _defaultDialect;
var compiled = CompileScript(
dialect,
Script.Name,
Script.Expression,
Script.ParameterNames,
parameterTypes,
Script.CompiledBuf,
validationContext.ImportService,
validationContext.ScriptCompiler);
// Determine declared return type
var declaredReturnType = GetDeclaredReturnType(Script.OptionalReturnTypeName, validationContext);
if (Script.IsOptionalReturnTypeIsArray && declaredReturnType != null) {
declaredReturnType = TypeHelper.GetArrayType(declaredReturnType);
}
Type returnType;
if (compiled.KnownReturnType == null && Script.OptionalReturnTypeName == null) {
returnType = typeof(object);
}
else if (compiled.KnownReturnType != null) {
if (declaredReturnType == null) {
returnType = compiled.KnownReturnType;
}
else {
var knownReturnType = compiled.KnownReturnType;
if (declaredReturnType.IsArray && knownReturnType.IsArray) {
// we are fine
}
else if (!knownReturnType.IsAssignmentCompatible(declaredReturnType)) {
throw new ExprValidationException(
"Return type and declared type not compatible for script '" +
Script.Name +
"', known return type is " +
knownReturnType.Name +
" versus declared return type " +
declaredReturnType.Name);
}
returnType = declaredReturnType;
}
}
else {
returnType = declaredReturnType;
}
if (returnType == null) {
returnType = typeof(object);
}
_eventTypeCollection = null;
if (Script.OptionalEventTypeName != null) {
if (returnType.IsArray && returnType.GetElementType() == typeof(EventBean)) {
_eventTypeCollection = EventTypeUtility.RequireEventType(
"Script",
Script.Name,
Script.OptionalEventTypeName,
validationContext.StatementCompileTimeService.EventTypeCompileTimeResolver);
}
else {
throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage());
}
}
_scriptDescriptor = new ScriptDescriptorCompileTime(
Script.OptionalDialect,
Script.Name,
Script.Expression,
Script.ParameterNames,
Parameters.ToArray(),
returnType,
_defaultDialect);
return null;
}
// Obtain those method and state factories for each level
private static AggregationLocalGroupByLevelForge GetLevel(
int levelNumber,
AggregationGroupByLocalGroupLevel level,
ExprForge[][] methodForgesAll,
AggregationForgeFactory[] methodFactoriesAll,
AggregationStateFactoryForge[] accessForges,
AggregationLocalGroupByColumnForge[] columns,
bool defaultLevel,
AggregationAccessorSlotPairForge[] accessors,
ImportService importService,
bool isFireAndForget,
string statementName)
{
var partitionExpr = level.PartitionExpr;
ExprForge[] partitionForges = ExprNodeUtilityQuery.GetForges(partitionExpr);
IList<ExprForge[]> methodForges = new List<ExprForge[]>();
IList<AggregationForgeFactory> methodFactories = new List<AggregationForgeFactory>();
IList<AggregationStateFactoryForge> stateFactories = new List<AggregationStateFactoryForge>();
foreach (var expr in level.Expressions) {
int column = expr.AggregationNode.Column;
var methodOffset = -1;
var methodAgg = true;
AggregationAccessorSlotPairForge pair = null;
if (column < methodForgesAll.Length) {
methodForges.Add(methodForgesAll[column]);
methodFactories.Add(methodFactoriesAll[column]);
methodOffset = methodFactories.Count - 1;
}
else {
// slot gives us the number of the state factory
int absoluteSlot = accessors[column - methodForgesAll.Length].Slot;
AggregationAccessorForge accessor = accessors[column - methodForgesAll.Length].AccessorForge;
var factory = accessForges[absoluteSlot];
var relativeSlot = stateFactories.IndexOf(factory);
if (relativeSlot == -1) {
stateFactories.Add(factory);
relativeSlot = stateFactories.Count - 1;
}
methodAgg = false;
pair = new AggregationAccessorSlotPairForge(relativeSlot, accessor);
}
columns[column] = new AggregationLocalGroupByColumnForge(
defaultLevel,
partitionForges,
methodOffset,
methodAgg,
pair,
levelNumber);
}
return new AggregationLocalGroupByLevelForge(
methodForges.ToArray(),
methodFactories.ToArray(),
stateFactories.ToArray(),
partitionForges,
defaultLevel);
}
public InstanceManufacturer MakeEvaluator()
{
return new InstanceManufacturerFastCtor(this, ExprNodeUtilityQuery.GetEvaluatorsNoCompile(forges));
}
public override void Accept(ExprNodeVisitorWithParent visitor)
{
base.Accept(visitor);
ExprNodeUtilityQuery.AcceptChain(visitor, ChainSpec, this);
}
private AggregationForgeFactoryAccessSorted HandleNonTable(ExprValidationContext validationContext)
{
if (positionalParams.Length == 0) {
throw new ExprValidationException("Missing the sort criteria expression");
}
// validate that the streams referenced in the criteria are a single stream's
var streams = ExprNodeUtilityQuery.GetIdentStreamNumbers(positionalParams[0]);
if (streams.Count > 1 || streams.IsEmpty()) {
throw new ExprValidationException(
ErrorPrefix + " requires that any parameter expressions evaluate properties of the same stream");
}
var streamNum = streams.First();
// validate that there is a remove stream, use "ever" if not
if (!ever &&
ExprAggMultiFunctionLinearAccessNode.GetIstreamOnly(
validationContext.StreamTypeService,
streamNum)) {
if (sortedwin) {
throw new ExprValidationException(
ErrorPrefix + " requires that a data window is declared for the stream");
}
}
// determine typing and evaluation
containedType = validationContext.StreamTypeService.EventTypes[streamNum];
var componentType = containedType.UnderlyingType;
var accessorResultType = componentType;
AggregationAccessorForge accessor;
var tableMetadata = validationContext.TableCompileTimeResolver.ResolveTableFromEventType(containedType);
if (!sortedwin) {
if (tableMetadata != null) {
accessor = new AggregationAccessorMinMaxByTable(IsMax, tableMetadata);
}
else {
accessor = new AggregationAccessorMinMaxByNonTable(IsMax);
}
}
else {
if (tableMetadata != null) {
accessor = new AggregationAccessorSortedTable(IsMax, componentType, tableMetadata);
}
else {
accessor = new AggregationAccessorSortedNonTable(IsMax, componentType);
}
accessorResultType = TypeHelper.GetArrayType(accessorResultType);
}
var criteriaExpressions = CriteriaExpressions;
AggregationStateTypeWStream type;
if (ever) {
type = IsMax ? AggregationStateTypeWStream.MAXEVER : AggregationStateTypeWStream.MINEVER;
}
else {
type = AggregationStateTypeWStream.SORTED;
}
var stateKey = new AggregationStateKeyWStream(
streamNum,
containedType,
type,
criteriaExpressions.First,
optionalFilter);
var optionalFilterForge = optionalFilter == null ? null : optionalFilter.Forge;
var streamEventType = validationContext.StreamTypeService.EventTypes[streamNum];
var criteriaTypes = ExprNodeUtilityQuery.GetExprResultTypes(criteriaExpressions.First);
var sortedDesc = new
SortedAggregationStateDesc(
IsMax,
validationContext.ImportService,
criteriaExpressions.First,
criteriaTypes,
criteriaExpressions.Second,
ever,
streamNum,
this,
optionalFilterForge,
streamEventType);
return new AggregationForgeFactoryAccessSorted(
this,
accessor,
accessorResultType,
containedType,
stateKey,
sortedDesc,
AggregationAgentDefault.INSTANCE);
}
public static SubordPropPlan GetJoinProps(
ExprNode filterExpr,
int outsideStreamCount,
EventType[] allStreamTypesZeroIndexed,
ExcludePlanHint excludePlanHint)
{
// No filter expression means full table scan
if (filterExpr == null) {
return new SubordPropPlan();
}
// analyze query graph
var queryGraph = new QueryGraphForge(outsideStreamCount + 1, excludePlanHint, true);
FilterExprAnalyzer.Analyze(filterExpr, queryGraph, false);
// Build a list of streams and indexes
var joinProps = new LinkedHashMap<string, SubordPropHashKeyForge>();
var rangeProps = new LinkedHashMap<string, SubordPropRangeKeyForge>();
IDictionary<QueryGraphValueEntryCustomKeyForge, QueryGraphValueEntryCustomOperationForge> customIndexOps =
EmptyDictionary<QueryGraphValueEntryCustomKeyForge, QueryGraphValueEntryCustomOperationForge>.Instance;
for (var stream = 0; stream < outsideStreamCount; stream++) {
var lookupStream = stream + 1;
var queryGraphValue = queryGraph.GetGraphValue(lookupStream, 0);
var hashKeysAndIndexes = queryGraphValue.HashKeyProps;
// determine application functions
foreach (var item in queryGraphValue.Items) {
if (item.Entry is QueryGraphValueEntryCustomForge) {
if (customIndexOps.IsEmpty()) {
customIndexOps =
new Dictionary<QueryGraphValueEntryCustomKeyForge,
QueryGraphValueEntryCustomOperationForge>();
}
var custom = (QueryGraphValueEntryCustomForge) item.Entry;
custom.MergeInto(customIndexOps);
}
}
// handle key-lookups
var keyPropertiesJoin = hashKeysAndIndexes.Keys;
var indexPropertiesJoin = hashKeysAndIndexes.Indexed;
if (!keyPropertiesJoin.IsEmpty()) {
if (keyPropertiesJoin.Count != indexPropertiesJoin.Length) {
throw new IllegalStateException(
"Invalid query key and index property collection for stream " + stream);
}
for (var i = 0; i < keyPropertiesJoin.Count; i++) {
QueryGraphValueEntryHashKeyedForge keyDesc = keyPropertiesJoin[i];
var compareNode = keyDesc.KeyExpr;
var keyPropType = compareNode.Forge.EvaluationType.GetBoxedType();
var indexedPropType = allStreamTypesZeroIndexed[0]
.GetPropertyType(indexPropertiesJoin[i])
.GetBoxedType();
var coercionType = indexedPropType;
if (keyPropType != indexedPropType) {
coercionType = keyPropType.GetCompareToCoercionType(indexedPropType);
}
SubordPropHashKeyForge desc;
if (keyPropertiesJoin[i] is QueryGraphValueEntryHashKeyedForgeExpr) {
var keyExpr = (QueryGraphValueEntryHashKeyedForgeExpr) keyPropertiesJoin[i];
var keyStreamNum = keyExpr.IsRequiresKey ? (int?) stream : null;
desc = new SubordPropHashKeyForge(keyDesc, keyStreamNum, coercionType);
}
else {
var prop = (QueryGraphValueEntryHashKeyedForgeProp) keyDesc;
desc = new SubordPropHashKeyForge(prop, stream, coercionType);
}
joinProps.Put(indexPropertiesJoin[i], desc);
}
}
// handle range lookups
var rangeKeysAndIndexes = queryGraphValue.RangeProps;
var rangeIndexes = rangeKeysAndIndexes.Indexed;
var rangeDescs = rangeKeysAndIndexes.Keys;
if (rangeDescs.IsEmpty()) {
continue;
}
// get all ranges lookups
var count = -1;
foreach (var rangeDesc in rangeDescs) {
count++;
var rangeIndexProp = rangeIndexes[count];
var subqRangeDesc = rangeProps.Get(rangeIndexProp);
// other streams may specify the start or end endpoint of a range, therefore this operation can be additive
if (subqRangeDesc != null) {
if (subqRangeDesc.RangeInfo.Type.IsRange()) {
continue;
}
// see if we can make this additive by using a range
var relOpOther = (QueryGraphValueEntryRangeRelOpForge) subqRangeDesc.RangeInfo;
var relOpThis = (QueryGraphValueEntryRangeRelOpForge) rangeDesc;
var opsDesc = QueryGraphRangeUtil.GetCanConsolidate(relOpThis.Type, relOpOther.Type);
if (opsDesc != null) {
ExprNode start;
ExprNode end;
if (!opsDesc.IsReverse) {
start = relOpOther.Expression;
end = relOpThis.Expression;
}
else {
start = relOpThis.Expression;
end = relOpOther.Expression;
}
var allowRangeReversal = relOpOther.IsBetweenPart && relOpThis.IsBetweenPart;
var rangeIn = new QueryGraphValueEntryRangeInForge(
opsDesc.Type,
start,
end,
allowRangeReversal);
var indexedPropType = allStreamTypesZeroIndexed[0]
.GetPropertyType(rangeIndexProp)
.GetBoxedType();
var coercionType = indexedPropType;
var proposedType = CoercionUtil.GetCoercionTypeRangeIn(
indexedPropType,
rangeIn.ExprStart,
rangeIn.ExprEnd);
if (proposedType != null && proposedType != indexedPropType) {
coercionType = proposedType;
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeIn, coercionType);
rangeProps.Put(rangeIndexProp, subqRangeDesc);
}
// ignore
continue;
}
// an existing entry has not been found
if (rangeDesc.Type.IsRange()) {
var rangeIn = (QueryGraphValueEntryRangeInForge) rangeDesc;
var indexedPropType =
allStreamTypesZeroIndexed[0].GetPropertyType(rangeIndexProp).GetBoxedType();
var coercionType = indexedPropType;
var proposedType = CoercionUtil.GetCoercionTypeRangeIn(
indexedPropType,
rangeIn.ExprStart,
rangeIn.ExprEnd);
if (proposedType != null && proposedType != indexedPropType) {
coercionType = proposedType;
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeDesc, coercionType);
}
else {
var relOp = (QueryGraphValueEntryRangeRelOpForge) rangeDesc;
var keyPropType = relOp.Expression.Forge.EvaluationType;
var indexedPropType =
allStreamTypesZeroIndexed[0].GetPropertyType(rangeIndexProp).GetBoxedType();
var coercionType = indexedPropType;
if (keyPropType != indexedPropType) {
coercionType = keyPropType.GetCompareToCoercionType(indexedPropType);
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeDesc, coercionType);
}
rangeProps.Put(rangeIndexProp, subqRangeDesc);
}
}
SubordPropInKeywordSingleIndex inKeywordSingleIdxProp = null;
SubordPropInKeywordMultiIndex inKeywordMultiIdxProp = null;
if (joinProps.IsEmpty() && rangeProps.IsEmpty()) {
for (var stream = 0; stream < outsideStreamCount; stream++) {
var lookupStream = stream + 1;
var queryGraphValue = queryGraph.GetGraphValue(lookupStream, 0);
var inkwSingles = queryGraphValue.InKeywordSingles;
if (inkwSingles.Indexed.Length != 0) {
ExprNode[] keys = inkwSingles.Key[0].KeyExprs;
var key = inkwSingles.Indexed[0];
if (inKeywordSingleIdxProp != null) {
continue;
}
var coercionType = keys[0].Forge.EvaluationType; // for in-comparison the same type is required
inKeywordSingleIdxProp = new SubordPropInKeywordSingleIndex(key, coercionType, keys);
}
var inkwMultis = queryGraphValue.InKeywordMulti;
if (!inkwMultis.IsEmpty()) {
QueryGraphValuePairInKWMultiIdx multi = inkwMultis[0];
inKeywordMultiIdxProp = new SubordPropInKeywordMultiIndex(
ExprNodeUtilityQuery.GetIdentResolvedPropertyNames(multi.Indexed),
multi.Indexed[0].Forge.EvaluationType,
multi.Key.KeyExpr);
}
if (inKeywordSingleIdxProp != null && inKeywordMultiIdxProp != null) {
inKeywordMultiIdxProp = null;
}
}
}
return new SubordPropPlan(
joinProps,
rangeProps,
inKeywordSingleIdxProp,
inKeywordMultiIdxProp,
customIndexOps);
}
