private static WriteablePropertyDescriptor[] SetupProperties(string[] propertyNamesOffered, EventType outputEventType, StatementContext statementContext)
{
var writeables = statementContext.EventAdapterService.GetWriteableProperties(outputEventType, false);
var writablesList = new List <WriteablePropertyDescriptor>();
for (var i = 0; i < propertyNamesOffered.Length; i++)
{
var propertyName = propertyNamesOffered[i];
WriteablePropertyDescriptor writable = EventTypeUtility.FindWritable(propertyName, writeables);
if (writable == null)
{
throw new ExprValidationException("Failed to find writable property '" + propertyName + "' for event type '" + outputEventType.Name + "'");
}
writablesList.Add(writable);
}
return(writablesList.ToArray());
}
private void RunAssertion(
RegressionEnvironment env,
string epl,
Consumer <object> underlyingAssertion)
{
env.CompileDeploy("@public @name('schema') " + epl);
var type = (EventTypeSPI)env.Deployment.GetDeployment(env.DeploymentId("schema")).Statements[0].EventType;
var writables = EventTypeUtility.GetWriteableProperties(type, true, true);
var props = new WriteablePropertyDescriptor[2];
props[0] = FindProp(writables, "P1");
props[1] = FindProp(writables, "P2");
var spi = (EPRuntimeSPI)env.Runtime;
EventBeanManufacturer manufacturer;
var forge = EventTypeUtility.GetManufacturer(
type,
props,
spi.ServicesContext.ImportServiceRuntime,
true,
spi.ServicesContext.EventTypeAvroHandler);
manufacturer = forge.GetManufacturer(spi.ServicesContext.EventBeanTypedEventFactory);
var @event = manufacturer.Make(new object[] { "a", 1 });
underlyingAssertion.Invoke(@event.Underlying);
Assert.AreSame(@event.EventType, type);
var underlying = manufacturer.MakeUnderlying(new object[] { "a", 1 });
underlyingAssertion.Invoke(underlying);
env.UndeployAll();
}
private static SelectExprProcessor InitializeJoinWildcardInternal(
EventType eventType,
ICollection <WriteablePropertyDescriptor> writables,
string[] streamNames,
EventType[] streamTypes,
EngineImportService engineImportService,
EventAdapterService eventAdapterService,
string statementName,
string engineURI)
{
var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType);
var writablePropertiesList = new List <WriteablePropertyDescriptor>();
var evaluatorsList = new List <ExprEvaluator>();
var widenersList = new List <TypeWidener>();
// loop over all columns selected, if any
for (var i = 0; i < streamNames.Length; i++)
{
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
foreach (var desc in writables)
{
if (!desc.PropertyName.Equals(streamNames[i]))
{
continue;
}
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
streamNames[i], streamTypes[i].UnderlyingType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, engineURI);
selectedWritable = desc;
break;
}
if (selectedWritable == null)
{
var message = "Stream underlying object for stream '" + streamNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property or setter method?)";
throw new ExprValidationException(message);
}
var streamNum = i;
var returnType = streamTypes[streamNum].UnderlyingType;
var evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[streamNum];
if (theEvent != null)
{
return(theEvent.Underlying);
}
return(null);
},
ProcReturnType = () => returnType
};
// add
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprEvaluators = evaluatorsList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturer eventManufacturer;
try
{
eventManufacturer = eventAdapterService.GetManufacturer(
eventType, writableProperties, engineImportService, false);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(e.Message, e);
}
return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners));
}
private static SelectExprProcessor InitializeSetterManufactor(
EventType eventType,
ICollection <WriteablePropertyDescriptor> writables,
bool isUsingWildcard,
StreamTypeService typeService,
ExprEvaluator[] expressionNodes,
string[] columnNames,
Object[] expressionReturnTypes,
EngineImportService engineImportService,
EventAdapterService eventAdapterService,
string statementName)
{
var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType);
var writablePropertiesList = new List <WriteablePropertyDescriptor>();
var evaluatorsList = new List <ExprEvaluator>();
var widenersList = new List <TypeWidener>();
// loop over all columns selected, if any
for (var i = 0; i < columnNames.Length; i++)
{
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
var evaluator = expressionNodes[i];
foreach (var desc in writables)
{
if (!desc.PropertyName.Equals(columnNames[i]))
{
continue;
}
var columnType = expressionReturnTypes[i];
if (columnType == null)
{
TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], null, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer,
statementName, typeService.EngineURIQualifier);
}
else if (columnType is EventType)
{
var columnEventType = (EventType)columnType;
var returnType = columnEventType.UnderlyingType;
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], columnEventType.UnderlyingType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, typeService.EngineURIQualifier);
// handle evaluator returning an event
if (TypeHelper.IsSubclassOrImplementsInterface(returnType, desc.PropertyType))
{
selectedWritable = desc;
widener = input =>
{
var eventBean = input as EventBean;
if (eventBean != null)
{
return(eventBean.Underlying);
}
return(input);
};
continue;
}
// find stream
var streamNum = 0;
for (var j = 0; j < typeService.EventTypes.Length; j++)
{
if (Equals(typeService.EventTypes[j], columnEventType))
{
streamNum = j;
break;
}
}
var streamNumEval = streamNum;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[streamNumEval];
if (theEvent != null)
{
return(theEvent.Underlying);
}
return(null);
},
ProcReturnType = () => returnType
};
}
else if (columnType is EventType[])
{
// handle case where the select-clause contains an fragment array
var columnEventType = ((EventType[])columnType)[0];
var componentReturnType = columnEventType.UnderlyingType;
var arrayReturnType = Array.CreateInstance(componentReturnType, 0).GetType();
var allowObjectArrayToCollectionConversion = eventType is AvroSchemaEventType;
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], arrayReturnType, desc.PropertyType, desc.PropertyName,
allowObjectArrayToCollectionConversion, typeWidenerCustomizer, statementName,
typeService.EngineURIQualifier);
var inner = evaluator;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var result = inner.Evaluate(evaluateParams);
if (!(result is EventBean[]))
{
return(null);
}
var events = (EventBean[])result;
var values = Array.CreateInstance(componentReturnType, events.Length);
for (var ii = 0; ii < events.Length; ii++)
{
values.SetValue(events[ii].Underlying, ii);
}
return(values);
},
ProcReturnType = () => componentReturnType
};
}
else if (!(columnType is Type))
{
var message = "Invalid assignment of column '" + columnNames[i] +
"' of type '" + columnType +
"' to event property '" + desc.PropertyName +
"' typed as '" + desc.PropertyType.FullName +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
else
{
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i], (Type)columnType, desc.PropertyType, desc.PropertyName, false,
typeWidenerCustomizer, statementName, typeService.EngineURIQualifier);
}
selectedWritable = desc;
break;
}
if (selectedWritable == null)
{
var message = "Column '" + columnNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
// add
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
// handle wildcard
if (isUsingWildcard)
{
var sourceType = typeService.EventTypes[0];
foreach (var eventPropDescriptor in sourceType.PropertyDescriptors)
{
if (eventPropDescriptor.RequiresIndex || (eventPropDescriptor.RequiresMapKey))
{
continue;
}
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
ExprEvaluator evaluator = null;
foreach (var writableDesc in writables)
{
if (!writableDesc.PropertyName.Equals(eventPropDescriptor.PropertyName))
{
continue;
}
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
eventPropDescriptor.PropertyName, eventPropDescriptor.PropertyType, writableDesc.PropertyType,
writableDesc.PropertyName, false, typeWidenerCustomizer, statementName,
typeService.EngineURIQualifier);
selectedWritable = writableDesc;
var propertyName = eventPropDescriptor.PropertyName;
var propertyType = eventPropDescriptor.PropertyType;
evaluator = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
EventBean theEvent = evaluateParams.EventsPerStream[0];
if (theEvent != null)
{
return(theEvent.Get(propertyName));
}
return(null);
},
ProcReturnType = () => propertyType
};
break;
}
if (selectedWritable == null)
{
var message = "Event property '" + eventPropDescriptor.PropertyName +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
writablePropertiesList.Add(selectedWritable);
evaluatorsList.Add(evaluator);
widenersList.Add(widener);
}
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprEvaluators = evaluatorsList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturer eventManufacturer;
try
{
eventManufacturer = eventAdapterService.GetManufacturer(
eventType, writableProperties, engineImportService, false);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(e.Message, e);
}
return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners));
}
public static SelectExprProcessor Make(EventType[] eventTypes, SelectExprContext selectExprContext, int streamNumber, EventType targetType, ExprNode[] exprNodes, EngineImportService engineImportService)
{
var mapResultType = (MapEventType)targetType;
var mapStreamType = (MapEventType)eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
String typeSameMssage = BaseNestableEventType.IsDeepEqualsProperties(mapResultType.Name, mapResultType.Types, mapStreamType.Types);
if (typeSameMssage == null && selectExprContext.ExpressionNodes.Length == 0)
{
return(new MapInsertProcessorSimpleRepackage(selectExprContext, streamNumber, targetType));
}
// (B) not completely assignable: find matching properties
ICollection <WriteablePropertyDescriptor> writables = selectExprContext.EventAdapterService.GetWriteableProperties(mapResultType, true);
IList <Item> items = new List <Item>();
IList <WriteablePropertyDescriptor> written = new List <WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
int count = 0;
foreach (WriteablePropertyDescriptor writeable in writables)
{
String propertyName = writeable.PropertyName;
if (mapStreamType.Types.ContainsKey(propertyName))
{
Object setOneType = mapStreamType.Types.Get(propertyName);
Object setTwoType = mapResultType.Types.Get(propertyName);
bool setTwoTypeFound = mapResultType.Types.ContainsKey(propertyName);
String message = BaseNestableEventUtil.ComparePropType(propertyName, setOneType, setTwoType, setTwoTypeFound, mapResultType.Name);
if (message != null)
{
throw new ExprValidationException(message);
}
items.Add(new Item(count, propertyName, null, null));
written.Add(writeable);
count++;
}
}
// find the properties coming from the expressions of the select clause
for (int i = 0; i < selectExprContext.ExpressionNodes.Length; i++)
{
String columnName = selectExprContext.ColumnNames[i];
ExprEvaluator evaluator = selectExprContext.ExpressionNodes[i];
ExprNode exprNode = exprNodes[i];
WriteablePropertyDescriptor writable = FindWritable(columnName, writables);
if (writable == null)
{
throw new ExprValidationException("Failed to find column '" + columnName + "' in target type '" + mapResultType.Name + "'");
}
TypeWidener widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.ExprEvaluator.ReturnType,
writable.PropertyType, columnName);
items.Add(new Item(count, null, evaluator, widener));
written.Add(writable);
count++;
}
// make manufacturer
Item[] itemsArr = items.ToArray();
EventBeanManufacturer manufacturer;
try {
manufacturer = selectExprContext.EventAdapterService.GetManufacturer(mapResultType,
written.ToArray(), engineImportService, true);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException("Failed to write to type: " + e.Message, e);
}
return(new MapInsertProcessorAllocate(streamNumber, itemsArr, manufacturer, targetType));
}
private static SelectExprProcessorForge InitializeJoinWildcardInternal(
EventType eventType,
ISet<WriteablePropertyDescriptor> writables,
string[] streamNames,
EventType[] streamTypes,
string statementName,
ImportServiceCompileTime importService,
EventTypeAvroHandler eventTypeAvroHandler)
{
var typeWidenerCustomizer = eventTypeAvroHandler.GetTypeWidenerCustomizer(eventType);
IList<WriteablePropertyDescriptor> writablePropertiesList = new List<WriteablePropertyDescriptor>();
IList<ExprForge> forgesList = new List<ExprForge>();
IList<TypeWidenerSPI> widenersList = new List<TypeWidenerSPI>();
// loop over all columns selected, if any
for (var i = 0; i < streamNames.Length; i++) {
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
foreach (var desc in writables) {
if (!desc.PropertyName.Equals(streamNames[i])) {
continue;
}
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
streamNames[i],
streamTypes[i].UnderlyingType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
selectedWritable = desc;
break;
}
if (selectedWritable == null) {
var message = "Stream underlying object for stream '" +
streamNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property or setter method?)";
throw new ExprValidationException(message);
}
ExprForge forge = new ExprForgeStreamUnderlying(i, streamTypes[i].UnderlyingType);
// add
writablePropertiesList.Add(selectedWritable);
forgesList.Add(forge);
widenersList.Add(widener);
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprForges = forgesList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturerForge eventManufacturer;
try {
eventManufacturer = EventTypeUtility.GetManufacturer(
eventType,
writableProperties,
importService,
false,
eventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(e.Message, e);
}
return new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprForges, wideners);
}
private static SelectExprProcessorForge InitializeSetterManufactor(
EventType eventType,
ISet<WriteablePropertyDescriptor> writables,
bool isUsingWildcard,
StreamTypeService typeService,
ExprForge[] expressionForges,
string[] columnNames,
object[] expressionReturnTypes,
string statementName,
ImportServiceCompileTime importService,
EventTypeAvroHandler eventTypeAvroHandler)
{
var typeWidenerCustomizer = eventTypeAvroHandler.GetTypeWidenerCustomizer(eventType);
IList<WriteablePropertyDescriptor> writablePropertiesList = new List<WriteablePropertyDescriptor>();
IList<ExprForge> forgesList = new List<ExprForge>();
IList<TypeWidenerSPI> widenersList = new List<TypeWidenerSPI>();
// loop over all columns selected, if any
for (var i = 0; i < columnNames.Length; i++) {
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
var forge = expressionForges[i];
foreach (var desc in writables) {
if (!desc.PropertyName.Equals(columnNames[i])) {
continue;
}
var columnType = expressionReturnTypes[i];
if (columnType == null) {
try {
TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
null,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
else if (columnType is EventType) {
var columnEventType = (EventType) columnType;
var returnType = columnEventType.UnderlyingType;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
columnEventType.UnderlyingType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
// handle evaluator returning an event
if (TypeHelper.IsSubclassOrImplementsInterface(returnType, desc.PropertyType)) {
selectedWritable = desc;
widener = new ProxyTypeWidenerSPI {
ProcWidenResultType = () => desc.PropertyType,
ProcWiden = input => {
if (input is EventBean eventBean) {
return eventBean.Underlying;
}
return input;
},
ProcWidenCodegen = (
expression,
codegenMethodScope,
codegenClassScope) => {
var method = codegenMethodScope
.MakeChild(typeof(object), typeof(TypeWidenerSPI), codegenClassScope)
.AddParam(typeof(object), "input")
.Block
.IfCondition(InstanceOf(Ref("input"), typeof(EventBean)))
.BlockReturn(
ExprDotName(Cast(typeof(EventBean), Ref("input")), "Underlying"))
.MethodReturn(Ref("input"));
return LocalMethodBuild(method).Pass(expression).Call();
}
};
continue;
}
// find stream
var streamNum = 0;
for (var j = 0; j < typeService.EventTypes.Length; j++) {
if (typeService.EventTypes[j] == columnEventType) {
streamNum = j;
break;
}
}
forge = new ExprForgeStreamUnderlying(
streamNum,
typeService.EventTypes[streamNum].UnderlyingType);
}
else if (columnType is EventType[]) {
// handle case where the select-clause contains an fragment array
var columnEventType = ((EventType[]) columnType)[0];
var componentReturnType = columnEventType.UnderlyingType;
var arrayReturnType = componentReturnType.MakeArrayType();
var allowObjectArrayToCollectionConversion = eventType is AvroSchemaEventType;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
arrayReturnType,
desc.PropertyType,
desc.PropertyName,
allowObjectArrayToCollectionConversion,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var inner = forge;
forge = new ExprForgeStreamWithInner(inner, componentReturnType);
}
else if (!(columnType is Type columnAsType)) {
var message = "Invalid assignment of column '" +
columnNames[i] +
"' of type '" +
columnType +
"' to event property '" +
desc.PropertyName +
"' typed as '" +
desc.PropertyType.CleanName() +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
else {
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
(Type) columnType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
selectedWritable = desc;
break;
}
if (selectedWritable == null) {
var message = "Column '" +
columnNames[i] +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
// add
writablePropertiesList.Add(selectedWritable);
forgesList.Add(forge);
widenersList.Add(widener);
}
// handle wildcard
if (isUsingWildcard) {
var sourceType = typeService.EventTypes[0];
foreach (var eventPropDescriptor in sourceType.PropertyDescriptors) {
if (eventPropDescriptor.IsRequiresIndex || eventPropDescriptor.IsRequiresMapKey) {
continue;
}
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
ExprForge forge = null;
foreach (var writableDesc in writables) {
if (!writableDesc.PropertyName.Equals(eventPropDescriptor.PropertyName)) {
continue;
}
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
eventPropDescriptor.PropertyName,
eventPropDescriptor.PropertyType,
writableDesc.PropertyType,
writableDesc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
selectedWritable = writableDesc;
var propertyName = eventPropDescriptor.PropertyName;
var getter = ((EventTypeSPI) sourceType).GetGetterSPI(propertyName);
forge = new ExprForgeStreamWithGetter(getter);
break;
}
if (selectedWritable == null) {
var message = "Event property '" +
eventPropDescriptor.PropertyName +
"' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)";
throw new ExprValidationException(message);
}
writablePropertiesList.Add(selectedWritable);
forgesList.Add(forge);
widenersList.Add(widener);
}
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprForges = forgesList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturerForge eventManufacturer;
try {
eventManufacturer = EventTypeUtility.GetManufacturer(
eventType,
writableProperties,
importService,
false,
eventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(e.Message, e);
}
if (eventManufacturer == null) {
return null;
}
return new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprForges, wideners);
}
