public void SetUp()
{
_container = SupportContainer.Reset();
var selectList = SupportSelectExprFactory.MakeNoAggregateSelectList();
var eventAdapterService = _container.Resolve <EventAdapterService>();
var vaeService = new SupportValueAddEventService();
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(
"abc", new StatementEventTypeRefImpl(_container.RWLockManager()));
var engineImportService = SupportEngineImportServiceFactory.Make(_container);
_methodOne = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), selectList, Collections.GetEmptyList <SelectExprStreamDesc>(),
null, null, false, new SupportStreamTypeSvc1Stream(), eventAdapterService, vaeService,
selectExprEventTypeRegistry, engineImportService, 1, "stmtname", null,
new Configuration(_container), null,
new TableServiceImpl(_container), null);
var insertIntoDesc = new InsertIntoDesc(SelectClauseStreamSelectorEnum.ISTREAM_ONLY, "Hello");
insertIntoDesc.Add("a");
insertIntoDesc.Add("b");
_methodTwo = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), selectList, Collections.GetEmptyList <SelectExprStreamDesc>(),
insertIntoDesc, null, false, new SupportStreamTypeSvc1Stream(), eventAdapterService, vaeService,
selectExprEventTypeRegistry, engineImportService, 1, "stmtname", null,
new Configuration(_container), null,
new TableServiceImpl(_container), null);
}
public void SetUp()
{
_container = SupportContainer.Reset();
_agentInstanceContext = SupportStatementContextFactory.MakeAgentInstanceContext(_container);
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(
"abc", new StatementEventTypeRefImpl(_container.RWLockManager()));
var factory = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(),
SupportSelectExprFactory.MakeSelectListFromIdent("TheString", "s0"),
Collections.GetEmptyList <SelectExprStreamDesc>(),
null, null, false,
new SupportStreamTypeSvc1Stream(),
_container.Resolve <EventAdapterService>(), null,
selectExprEventTypeRegistry,
_agentInstanceContext.StatementContext.EngineImportService,
1, "stmtname", null,
new Configuration(_container), null,
new TableServiceImpl(_container),
null);
var selectProcessor = factory.GetEvaluator();
_supportAggregationService = new SupportAggregationService();
var groupKeyNodes = new ExprEvaluator[2];
groupKeyNodes[0] = SupportExprNodeFactory.MakeIdentNode("IntPrimitive", "s0").ExprEvaluator;
groupKeyNodes[1] = SupportExprNodeFactory.MakeIdentNode("IntBoxed", "s0").ExprEvaluator;
var prototype = new ResultSetProcessorRowPerGroupFactory(selectProcessor, null, groupKeyNodes, null, true, false, null, false, false, false, false, null, false, 1, null);
_processor = (ResultSetProcessorRowPerGroup)prototype.Instantiate(null, _supportAggregationService, _agentInstanceContext);
}
private static SelectExprProcessor GetProcessorInternal(ICollection <int> assignedTypeNumberStack, SelectClauseElementCompiled[] selectionList, bool isUsingWildcard, InsertIntoDesc insertIntoDesc, EventType optionalInsertIntoEventType, StreamTypeService typeService, EventAdapterService eventAdapterService, ValueAddEventService valueAddEventService, SelectExprEventTypeRegistry selectExprEventTypeRegistry, EngineImportService engineImportService, int statementId, Attribute[] annotations, ConfigurationInformation configuration, NamedWindowMgmtService namedWindowMgmtService, TableService tableService, GroupByRollupInfo groupByRollupInfo)
{
// Wildcard not allowed when insert into specifies column order
if (isUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty())
{
throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order");
}
// Determine wildcard processor (select *)
if (IsWildcardsOnly(selectionList))
{
// For joins
if (typeService.StreamNames.Length > 1)
{
Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor");
return(SelectExprJoinWildcardProcessorFactory.Create(
assignedTypeNumberStack, statementId, typeService.StreamNames, typeService.EventTypes,
eventAdapterService, insertIntoDesc, selectExprEventTypeRegistry, engineImportService,
annotations, configuration, tableService));
}
// Single-table selects with no insert-into
// don't need extra processing
else if (insertIntoDesc == null)
{
Log.Debug(".getProcessor Using wildcard processor");
if (typeService.HasTableTypes)
{
var tableName = TableServiceUtil.GetTableNameFromEventType(typeService.EventTypes[0]);
return(new SelectExprWildcardTableProcessor(tableName, tableService));
}
return(new SelectExprWildcardProcessor(typeService.EventTypes[0]));
}
}
// Verify the assigned or name used is unique
if (insertIntoDesc == null)
{
VerifyNameUniqueness(selectionList);
}
// Construct processor
var buckets = GetSelectExpressionBuckets(selectionList);
var factory = new SelectExprProcessorHelper(
assignedTypeNumberStack, buckets.Expressions, buckets.SelectedStreams, insertIntoDesc,
optionalInsertIntoEventType, isUsingWildcard, typeService, eventAdapterService, valueAddEventService,
selectExprEventTypeRegistry, engineImportService, statementId, annotations, configuration,
namedWindowMgmtService, tableService, groupByRollupInfo);
SelectExprProcessor processor = factory.Evaluator;
// add reference to the type obtained
var type = (EventTypeSPI)processor.ResultEventType;
if (!typeService.IsOnDemandStreams && type.Metadata.TypeClass != TypeClass.ANONYMOUS)
{
selectExprEventTypeRegistry.Add(processor.ResultEventType);
}
return(processor);
}
private static SelectExprProcessorWInsertTarget GetProcessorInternal(
SelectProcessorArgs args,
InsertIntoDesc insertIntoDesc)
{
// Wildcard not allowed when insert into specifies column order
if (args.IsUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty()) {
throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order");
}
var insertIntoTarget = insertIntoDesc == null
? null
: args.EventTypeCompileTimeResolver.GetTypeByName(insertIntoDesc.EventTypeName);
// Determine wildcard processor (select *)
if (IsWildcardsOnly(args.SelectionList)) {
// For joins
if (args.TypeService.StreamNames.Length > 1 && !(insertIntoTarget is VariantEventType)) {
Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor");
SelectExprProcessorForgeWForgables pair = SelectExprJoinWildcardProcessorFactory.Create(args, insertIntoDesc, eventTypeName => eventTypeName);
SelectExprProcessorForge forgeX = pair.Forge;
return new SelectExprProcessorWInsertTarget(forgeX, null, pair.AdditionalForgeables);
}
if (insertIntoDesc == null) {
// Single-table selects with no insert-into
// don't need extra processing
Log.Debug(".getProcessor Using wildcard processor");
if (args.TypeService.HasTableTypes) {
var table = args.TableCompileTimeResolver.ResolveTableFromEventType(
args.TypeService.EventTypes[0]);
if (table != null) {
SelectExprProcessorForge forgeX = new SelectEvalWildcardTable(table);
return new SelectExprProcessorWInsertTarget(forgeX, null, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
SelectExprProcessorForge forgeOuter = new SelectEvalWildcardNonJoin(args.TypeService.EventTypes[0]);
return new SelectExprProcessorWInsertTarget(forgeOuter, null, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
// Verify the assigned or name used is unique
if (insertIntoDesc == null) {
VerifyNameUniqueness(args.SelectionList);
}
// Construct processor
var buckets = GetSelectExpressionBuckets(args.SelectionList);
var factory = new SelectExprProcessorHelper(
buckets.Expressions,
buckets.SelectedStreams,
args,
insertIntoDesc);
return factory.Forge;
}
public void SetUp()
{
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry("abc", new StatementEventTypeRefImpl());
var statementContext = SupportStatementContextFactory.MakeContext();
var factory = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), SupportSelectExprFactory.MakeNoAggregateSelectList(),
Collections.GetEmptyList <SelectExprStreamDesc>(), null, null, false,
new SupportStreamTypeSvc1Stream(), SupportEventAdapterService.Service, null,
selectExprEventTypeRegistry, statementContext.EngineImportService, 1, "stmtname", null,
new Configuration(), null, new TableServiceImpl(), null);
_selectExprProcessor = factory.Evaluator;
_orderByProcessor = null;
var prototype = new ResultSetProcessorSimpleFactory(_selectExprProcessor, null, true, null, false, null, 1);
_outputProcessorAll = (ResultSetProcessorSimple)prototype.Instantiate(null, null, null);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (singleRowOnly) {
var singleMethodNode = codegenMethodScope.MakeChild(
typeof(EventBean),
typeof(SelectExprProcessorTypableSingleForge),
codegenClassScope);
var singleMethodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(singleMethodNode.Block, codegenMethodScope, codegenClassScope));
var singleMethodBlock = singleMethodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(singleMethodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
singleMethodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
singleMethodNode,
codegenClassScope));
}
singleMethodBlock.MethodReturn(ExprDotMethod(singleMethodManufacturer, "Make", Ref("row")));
return LocalMethod(singleMethodNode);
}
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean[]),
typeof(SelectExprProcessorTypableSingleForge),
codegenClassScope);
var methodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var methodBlock = methodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
methodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
methodNode,
codegenClassScope));
}
methodBlock.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), Constant(1)))
.AssignArrayElement("events", Constant(0), ExprDotMethod(methodManufacturer, "Make", Ref("row")))
.MethodReturn(Ref("events"));
return LocalMethod(methodNode);
}
public CodegenExpression EvaluateCodegen(
Type requiredType,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
if (firstRowOnly) {
var firstMethodNode = codegenMethodScope
.MakeChild(typeof(EventBean), typeof(SelectExprProcessorTypableMultiForge), codegenClassScope);
var firstMethodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(firstMethodNode.Block, codegenMethodScope, codegenClassScope));
var firstBlock = firstMethodNode.Block
.DeclareVar<object[]>(
"row",
typable.EvaluateTypableSingleCodegen(firstMethodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("row");
if (hasWideners) {
firstBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegen(
Ref("row"),
wideners,
firstMethodNode,
codegenClassScope));
}
firstBlock.MethodReturn(ExprDotMethod(firstMethodManufacturer, "Make", Ref("row")));
return LocalMethod(firstMethodNode);
}
else {
var methodNode = codegenMethodScope.MakeChild(
typeof(EventBean[]),
typeof(SelectExprProcessorTypableMultiForge),
codegenClassScope);
var methodManufacturer = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(EventBeanManufacturer),
factory.Make(methodNode.Block, codegenMethodScope, codegenClassScope));
var methodBlock = methodNode.Block
.DeclareVar<object[][]>(
"rows",
typable.EvaluateTypableMultiCodegen(methodNode, exprSymbol, codegenClassScope))
.IfRefNullReturnNull("rows")
.IfCondition(EqualsIdentity(ArrayLength(Ref("rows")), Constant(0)))
.BlockReturn(NewArrayByLength(typeof(EventBean), Constant(0)));
if (hasWideners) {
methodBlock.Expression(
SelectExprProcessorHelper.ApplyWidenersCodegenMultirow(
Ref("rows"),
wideners,
methodNode,
codegenClassScope));
}
methodBlock.DeclareVar<EventBean[]>("events", NewArrayByLength(typeof(EventBean), ArrayLength(Ref("rows"))))
.ForLoopIntSimple("i", ArrayLength(Ref("events")))
.AssignArrayElement(
"events",
Ref("i"),
ExprDotMethod(methodManufacturer, "Make", ArrayAtIndex(Ref("rows"), Ref("i"))))
.BlockEnd()
.MethodReturn(Ref("events"));
return LocalMethod(methodNode);
}
}
