/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="streamNum">stream num</param>
/// <param name="eventsPerStream">events</param>
/// <returns>value</returns>
public static AggregationRow TableColumnRow(
int streamNum,
EventBean[] eventsPerStream)
{
var oa = (ObjectArrayBackedEventBean) eventsPerStream[streamNum];
return ExprTableEvalStrategyUtil.GetRow(oa);
}
public CodegenMethod InitializeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(TypeOfSubclass(), GetType(), classScope);
method.Block
.DeclareVar(TypeOfSubclass(), "saiff", NewInstance(TypeOfSubclass()))
.SetProperty(Ref("saiff"), "Activator", activator.MakeCodegen(method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"ResultEventType",
EventTypeUtility.ResolveTypeCodegen(resultEventType, symbols.GetAddInitSvc(method)))
.SetProperty(
Ref("saiff"),
"Subselects",
SubSelectFactoryForge.CodegenInitMap(subselects, GetType(), method, symbols, classScope))
.SetProperty(
Ref("saiff"),
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(tableAccesses, GetType(), method, symbols, classScope));
InlineInitializeOnTriggerBase(Ref("saiff"), method, symbols, classScope);
method.Block.MethodReturn(Ref("saiff"));
return method;
}
public void ApplyLeave(EventBean[] eventsPerStream, object optionalGroupKeyPerRow, ExprEvaluatorContext exprEvaluatorContext)
{
// acquire table-level write lock
ExprTableEvalLockUtil.ObtainLockUnless(_tableStateInstance.TableLevelRWLock.WriteLock, exprEvaluatorContext);
var @event = _tableStateInstance.GetCreateRowIntoTable(null, exprEvaluatorContext);
var row = ExprTableEvalStrategyUtil.GetRow(@event);
var evaluateParams = new EvaluateParams(eventsPerStream, false, exprEvaluatorContext);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QAggregationUngroupedApplyEnterLeave(false, row.Methods.Length, row.States.Length); }
for (var i = 0; i < _methodPairs.Length; i++)
{
var methodPair = _methodPairs[i];
var method = row.Methods[methodPair.TargetIndex];
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QAggNoAccessEnterLeave(false, i, method, methodPair.AggregationNode); }
var columnResult = methodPair.Evaluator.Evaluate(evaluateParams);
method.Leave(columnResult);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AAggNoAccessEnterLeave(false, i, method); }
}
for (var i = 0; i < _targetStates.Length; i++)
{
var state = row.States[_targetStates[i]];
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QAggAccessEnterLeave(false, i, state, _accessStateExpr[i]); }
_agents[i].ApplyLeave(eventsPerStream, exprEvaluatorContext, state);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AAggAccessEnterLeave(false, i, state); }
}
_tableStateInstance.HandleRowUpdated(@event);
if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().AAggregationUngroupedApplyEnterLeave(false); }
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="streamNum">stream num</param>
/// <param name="eventsPerStream">events</param>
public static void TableAggReset(
int streamNum,
EventBean[] eventsPerStream)
{
var oa = (ObjectArrayBackedEventBean) eventsPerStream[streamNum];
var row = ExprTableEvalStrategyUtil.GetRow(oa);
row.Clear();
}
public void MakeMethod(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var select = Ref("select");
method.Block
.DeclareVar<FAFQueryMethodSelect>(select.Ref, NewInstance(typeof(FAFQueryMethodSelect)))
.SetProperty(
select,
"Annotations",
LocalMethod(
AnnotationUtil.MakeAnnotations(typeof(Attribute[]), _desc.Annotations, method, classScope)))
.SetProperty(
select,
"Processors",
FireAndForgetProcessorForgeExtensions.MakeArray(_desc.Processors, method, symbols, classScope))
.DeclareVar(
_classNameResultSetProcessor,
"rsp",
NewInstance(_classNameResultSetProcessor, symbols.GetAddInitSvc(method), Ref("statementFields")))
.SetProperty(select, "ResultSetProcessorFactoryProvider", Ref("rsp"))
.SetProperty(select, "QueryGraph", _desc.QueryGraph.Make(method, symbols, classScope))
.SetProperty(
select,
"WhereClause",
_desc.WhereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
_desc.WhereClause.Forge,
method,
GetType(),
classScope))
.SetProperty(
select,
"JoinSetComposerPrototype",
_desc.Joins == null ? ConstantNull() : _desc.Joins.Make(method, symbols, classScope))
.SetProperty(
select,
"ConsumerFilters",
ExprNodeUtilityCodegen.CodegenEvaluators(_desc.ConsumerFilters, method, GetType(), classScope))
.SetProperty(select, "ContextName", Constant(_desc.ContextName))
.SetProperty(
select,
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(
_desc.TableAccessForges,
GetType(),
method,
symbols,
classScope))
.SetProperty(select, "HasTableAccess", Constant(_desc.HasTableAccess))
.SetProperty(select, "IsDistinct", Constant(_desc.IsDistinct))
.MethodReturn(select);
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="streamNum">stream num</param>
/// <param name="column">col</param>
/// <param name="eventsPerStream">events</param>
/// <param name="isNewData">new-data flow</param>
/// <param name="ctx">context</param>
/// <returns>value</returns>
public static object TableColumnAggValue(
int streamNum,
int column,
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext ctx)
{
var oa = (ObjectArrayBackedEventBean) eventsPerStream[streamNum];
var row = ExprTableEvalStrategyUtil.GetRow(oa);
return row.GetValue(column, eventsPerStream, isNewData, ctx);
}
private AggregationState GetState(EventBean[] eventsPerStream)
{
EventBean @event = eventsPerStream[_streamNum];
if (@event == null)
{
return(null);
}
AggregationRowPair row = ExprTableEvalStrategyUtil.GetRow((ObjectArrayBackedEventBean)@event);
return(row.States[_tableAccessColumn.AccessAccessorSlotPair.Slot]);
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="streamNum">stream number</param>
/// <param name="reader">reader</param>
/// <param name="aggColNum">agg col</param>
/// <param name="eventsPerStream">events</param>
/// <param name="isNewData">new-data flag</param>
/// <param name="exprEvaluatorContext">expr ctx</param>
/// <returns>value</returns>
public static ICollection<object> EvaluateTableWithReaderCollectionScalar(
int streamNum,
AggregationMultiFunctionTableReader reader,
int aggColNum,
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext exprEvaluatorContext)
{
var @event = eventsPerStream[streamNum];
if (@event == null) {
return null;
}
var row = ExprTableEvalStrategyUtil.GetRow((ObjectArrayBackedEventBean) @event);
return reader.GetValueCollectionScalar(aggColNum, row, eventsPerStream, isNewData, exprEvaluatorContext);
}
public EventBean GetEventBean(
int column,
EventBean[] eventsPerStream,
bool isNewData,
ExprEvaluatorContext context)
{
// acquire table-level write lock
TableEvalLockUtil.ObtainLockUnless(tableInstance.TableLevelRWLock.WriteLock, context);
var @event = tableInstance.EventUngrouped;
if (@event == null) {
return null;
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
return row.GetEventBean(column, eventsPerStream, isNewData, context);
}
public void MakeMethod(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenExpressionRef queryMethod = Ref("qm");
method.Block
.DeclareVar(TypeOfMethod(), queryMethod.Ref, NewInstance(TypeOfMethod()))
.SetProperty(
queryMethod,
"Annotations",
annotations == null
? ConstantNull()
: LocalMethod(MakeAnnotations(typeof(Attribute[]), annotations, method, classScope)))
.SetProperty(
queryMethod, "Processor", processor.Make(method, symbols, classScope))
.SetProperty(
queryMethod,
"QueryGraph",
queryGraph == null ? ConstantNull() : queryGraph.Make(method, symbols, classScope))
.SetProperty(
queryMethod,
"InternalEventRouteDest",
ExprDotName(
symbols.GetAddInitSvc(method), EPStatementInitServicesConstants.INTERNALEVENTROUTEDEST))
.SetProperty(
queryMethod,
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(
tableAccessForges,
this.GetType(),
method,
symbols,
classScope))
.SetProperty(
queryMethod, "HasTableAccess", Constant(hasTableAccess))
.SetProperty(
queryMethod, "Subselects", SubSelectFactoryForge.CodegenInitMap(
_subselectForges, GetType(), method, symbols, classScope));
MakeInlineSpecificSetter(queryMethod, method, symbols, classScope);
method.Block.MethodReturn(queryMethod);
}
public object GetValue(int column, int agentInstanceId, EvaluateParams evaluateParams)
{
// acquire table-level write lock
ExprTableEvalLockUtil.ObtainLockUnless(_tableStateInstance.TableLevelRWLock.WriteLock, evaluateParams.ExprEvaluatorContext);
var @event = _tableStateInstance.EventUngrouped;
if (@event == null)
{
return null;
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
var aggregators = row.Methods;
if (column < aggregators.Length)
{
return aggregators[column].Value;
}
else
{
var pair = _accessors[column - aggregators.Length];
return pair.Accessor.GetValue(row.States[pair.Slot], evaluateParams);
}
}
public void ClearResults(ExprEvaluatorContext exprEvaluatorContext)
{
// acquire table-level write lock
ExprTableEvalLockUtil.ObtainLockUnless(_tableStateInstance.TableLevelRWLock.WriteLock, exprEvaluatorContext);
var @event = _tableStateInstance.EventUngrouped;
if (@event == null)
{
return;
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
var aggregators = row.Methods;
foreach (var state in row.States)
{
state.Clear();
}
foreach (var aggregator in aggregators)
{
aggregator.Clear();
}
}
public void ApplyLeave(
EventBean[] eventsPerStream,
object optionalGroupKeyPerRow,
ExprEvaluatorContext exprEvaluatorContext)
{
// acquire table-level write lock
TableEvalLockUtil.ObtainLockUnless(tableInstance.TableLevelRWLock.WriteLock, exprEvaluatorContext);
var @event = tableInstance.GetCreateRowIntoTable(exprEvaluatorContext);
var row = ExprTableEvalStrategyUtil.GetRow(@event);
for (var i = 0; i < methodPairs.Length; i++) {
var methodPair = methodPairs[i];
var columnResult = methodPair.Evaluator.Evaluate(eventsPerStream, false, exprEvaluatorContext);
row.LeaveAgg(methodPair.Column, columnResult);
}
for (var i = 0; i < accessAgents.Length; i++) {
accessAgents[i].ApplyLeave(eventsPerStream, exprEvaluatorContext, row, accessColumnsZeroOffset[i]);
}
tableInstance.HandleRowUpdated(@event);
}
public object[] ConvertToUnd(EventBean @event, EvaluateParams evalParams)
{
var bean = (ObjectArrayBackedEventBean)@event;
var row = ExprTableEvalStrategyUtil.GetRow(bean);
var data = new object[_numColumns];
foreach (var plain in _plains)
{
data[plain.Dest] = bean.Properties[plain.Source];
}
var count = 0;
foreach (var access in _accessors)
{
data[access.Dest] = access.Accessor.GetValue(row.States[count++], evalParams);
}
count = 0;
foreach (var method in _methods)
{
data[method.Dest] = row.Methods[count++].Value;
}
return(data);
}
public EventBean GetEventBean(int column, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext context)
{
// acquire table-level write lock
ExprTableEvalLockUtil.ObtainLockUnless(_tableStateInstance.TableLevelRWLock.WriteLock, context);
var @event = _tableStateInstance.EventReference.Get();
if (@event == null)
{
return(null);
}
var row = ExprTableEvalStrategyUtil.GetRow(@event);
var aggregators = row.Methods;
if (column < aggregators.Length)
{
return(null);
}
else
{
var pair = _accessors[column - aggregators.Length];
return(pair.Accessor.GetEnumerableEvent(row.States[pair.Slot], eventsPerStream, isNewData, context));
}
}
public CodegenMethod InitializeCodegen(
CodegenClassScope classScope,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols)
{
var method = parent.MakeChild(typeof(StatementAgentInstanceFactorySelect), GetType(), classScope);
method.Block
.DeclareVar<StatementAgentInstanceFactorySelect>(
"saiff",
NewInstance(typeof(StatementAgentInstanceFactorySelect)));
// stream names
method.Block.SetProperty(Ref("saiff"), "StreamNames", Constant(_streamNames));
// activators
method.Block.DeclareVar<ViewableActivator[]>(
"activators",
NewArrayByLength(typeof(ViewableActivator), Constant(_viewableActivatorForges.Length)));
for (var i = 0; i < _viewableActivatorForges.Length; i++) {
method.Block.AssignArrayElement(
"activators",
Constant(i),
_viewableActivatorForges[i].MakeCodegen(method, symbols, classScope));
}
method.Block.SetProperty(Ref("saiff"), "ViewableActivators", Ref("activators"));
// views
method.Block.DeclareVar<ViewFactory[][]>(
"viewFactories",
NewArrayByLength(typeof(ViewFactory[]), Constant(_views.Length)));
for (var i = 0; i < _views.Length; i++) {
if (_views[i] != null) {
var array = ViewFactoryForgeUtil.CodegenForgesWInit(
_views[i],
i,
null,
method,
symbols,
classScope);
method.Block.AssignArrayElement("viewFactories", Constant(i), array);
}
}
method.Block.SetProperty(Ref("saiff"), "ViewFactories", Ref("viewFactories"));
// view delegate information ('prior' and 'prev')
method.Block.DeclareVar<ViewResourceDelegateDesc[]>(
"viewResourceDelegates",
NewArrayByLength(typeof(ViewResourceDelegateDesc), Constant(_viewResourceDelegates.Length)));
for (var i = 0; i < _viewResourceDelegates.Length; i++) {
method.Block.AssignArrayElement(
"viewResourceDelegates",
Constant(i),
_viewResourceDelegates[i].ToExpression());
}
method.Block.SetProperty(Ref("saiff"), "ViewResourceDelegates", Ref("viewResourceDelegates"));
// result set processor
method.Block.DeclareVar(
_resultSetProcessorProviderClassName,
RSPFACTORYPROVIDER,
NewInstanceInner(_resultSetProcessorProviderClassName,
symbols.GetAddInitSvc(method),
Ref(StmtClassForgeableAIFactoryProviderBase.MEMBERNAME_STATEMENT_FIELDS)))
.SetProperty(Ref("saiff"), "ResultSetProcessorFactoryProvider", Ref(RSPFACTORYPROVIDER));
// where-clause evaluator
if (_whereClauseForge != null) {
var whereEval = CodegenEvaluator(_whereClauseForge, method, GetType(), classScope);
method.Block.SetProperty(Ref("saiff"), "WhereClauseEvaluator", whereEval);
if (classScope.IsInstrumented) {
method.Block.SetProperty(
Ref("saiff"),
"WhereClauseEvaluatorTextForAudit",
Constant(ExprNodeUtilityPrint.ToExpressionStringMinPrecedence(_whereClauseForge)));
}
}
// joins
if (_joinSetComposerPrototypeForge != null) {
method.Block.SetProperty(
Ref("saiff"),
"JoinSetComposerPrototype",
_joinSetComposerPrototypeForge.Make(method, symbols, classScope));
}
// output process view
method.Block.DeclareVar(
_outputProcessViewProviderClassName,
OPVFACTORYPROVIDER,
NewInstanceInner(_outputProcessViewProviderClassName, symbols.GetAddInitSvc(method), Ref("statementFields")))
.SetProperty(Ref("saiff"), "OutputProcessViewFactoryProvider", Ref(OPVFACTORYPROVIDER));
// subselects
if (!_subselects.IsEmpty()) {
method.Block.SetProperty(
Ref("saiff"),
"Subselects",
SubSelectFactoryForge.CodegenInitMap(_subselects, GetType(), method, symbols, classScope));
}
// table-access
if (!_tableAccesses.IsEmpty()) {
method.Block.SetProperty(
Ref("saiff"),
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(_tableAccesses, GetType(), method, symbols, classScope));
}
// order-by with no output-limit
method.Block.SetProperty(
Ref("saiff"),
"OrderByWithoutOutputRateLimit",
Constant(_orderByWithoutOutputRateLimit));
// unidirectional join
method.Block.SetProperty(Ref("saiff"), "IsUnidirectionalJoin", Constant(_unidirectionalJoin));
method.Block.MethodReturn(Ref("saiff"));
return method;
}
