private static DeliveryConvertor DetermineWideningDeliveryConvertor(
bool firstParameterIsEPStatement,
EPStatement statement,
Type[] selectClauseTypes,
Type[] parameterTypes,
MethodInfo method,
string runtimeURI)
{
var needWidener = false;
for (var i = 0; i < selectClauseTypes.Length; i++) {
var optionalWidener = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method, statement.Name);
if (optionalWidener != null) {
needWidener = true;
break;
}
}
if (!needWidener) {
return firstParameterIsEPStatement
? new DeliveryConvertorNullWStatement(statement)
: (DeliveryConvertor) DeliveryConvertorNull.INSTANCE;
}
var wideners = new TypeWidenerSPI[selectClauseTypes.Length];
for (var i = 0; i < selectClauseTypes.Length; i++) {
wideners[i] = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method, statement.Name);
}
return firstParameterIsEPStatement
? new DeliveryConvertorWidenerWStatement(wideners, statement)
: (DeliveryConvertor) new DeliveryConvertorWidener(wideners);
}
public ExprEvalWithTypeWidener(
TypeWidenerSPI widener,
ExprNode validated,
Type targetType)
{
this.widener = widener;
this.validated = validated;
this.targetType = targetType;
}
public SelectExprProcessorEvalAvroArrayCoercer(
ExprForge forge,
TypeWidenerSPI widener,
Type resultType)
{
_forge = forge;
_widener = widener;
EvaluationType = resultType;
}
public VariableTriggerWriteArrayElementForge(
string variableName,
ExprForge indexExpression,
TypeWidenerSPI widener)
{
this.variableName = variableName;
this.indexExpression = indexExpression;
this.widener = widener;
}
internal Item(
int toIndex,
int optionalFromIndex,
ExprForge forge,
TypeWidenerSPI optionalWidener)
{
ToIndex = toIndex;
OptionalFromIndex = optionalFromIndex;
Forge = forge;
OptionalWidener = optionalWidener;
}
internal Item(
int toIndex,
string optionalPropertyName,
ExprForge forge,
TypeWidenerSPI optionalWidener)
{
ToIndex = toIndex;
OptionalPropertyName = optionalPropertyName;
Forge = forge;
OptionalWidener = optionalWidener;
}
public InternalEventRouterWriterArrayElementForge(
ExprNode indexExpression,
ExprNode rhsExpression,
TypeWidenerSPI widener,
string propertyName)
{
_indexExpression = indexExpression;
_rhsExpression = rhsExpression;
_widener = widener;
_propertyName = propertyName;
}
internal Item(
JsonUnderlyingField toField,
JsonUnderlyingField optionalFromField,
ExprForge forge,
TypeWidenerSPI optionalWidener)
{
if (toField == null)
{
throw new ArgumentException("Null to-field");
}
this.toField = toField;
this.optionalFromField = optionalFromField;
this.forge = forge;
this.optionalWidener = optionalWidener;
}
public static CodegenExpression CodegenWidener(
TypeWidenerSPI widener,
CodegenMethod method,
Type originator,
CodegenClassScope classScope)
{
var widen = new CodegenExpressionLambda(method.Block).WithParam<object>("input");
var anonymousClass = NewInstance<ProxyTypeWidener>(widen);
//var anonymousClass = NewAnonymousClass(method.Block, typeof(TypeWidener));
//var widen = CodegenMethod.MakeParentNode(typeof(object), originator, classScope)
// .AddParam(typeof(object), "input");
//anonymousClass.AddMethod("widen", widen);
var widenResult = widener.WidenCodegen(Ref("input"), method, classScope);
widen.Block.BlockReturn(widenResult);
return anonymousClass;
}
public EventBeanUpdateItemForge(
ExprForge expression,
string optionalPropertyName,
EventPropertyWriterSPI optionalWriter,
bool notNullableField,
TypeWidenerSPI optionalWidener,
bool useUntypedAssignment,
bool useTriggeringEvent,
EventBeanUpdateItemArray optionalArray)
{
Expression = expression;
OptionalPropertyName = optionalPropertyName;
OptionalWriter = optionalWriter;
IsNotNullableField = notNullableField;
OptionalWidener = optionalWidener;
IsUseUntypedAssignment = useUntypedAssignment;
IsUseTriggeringEvent = useTriggeringEvent;
OptionalArray = optionalArray;
}
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);
}
public static InternalEventRouterDescForge GetValidatePreprocessing(
EventType eventType,
UpdateDesc desc,
Attribute[] annotations)
{
if (!(eventType is EventTypeSPI)) {
throw new ExprValidationException(
"Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface");
}
var eventTypeSPI = (EventTypeSPI) eventType;
var size = desc.Assignments.Count;
var wideners = new TypeWidenerSPI[size];
var properties = new string[size];
var expressions = new ExprNode[size];
for (var i = 0; i < size; i++) {
var onSet = desc.Assignments[i];
var assignmentPair = ExprNodeUtilityValidate.CheckGetAssignmentToProp(onSet.Expression);
if (assignmentPair == null) {
throw new ExprValidationException(
"Missing property assignment expression in assignment number " + i);
}
properties[i] = assignmentPair.First;
expressions[i] = assignmentPair.Second;
var writableProperty = eventTypeSPI.GetWritableProperty(assignmentPair.First);
if (writableProperty == null) {
throw new ExprValidationException(
"Property '" + assignmentPair.First + "' is not available for write access");
}
try {
wideners[i] = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentPair.Second),
assignmentPair.Second.Forge.EvaluationType,
writableProperty.PropertyType,
assignmentPair.First,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethodForge(properties);
if (copyMethod == null) {
throw new ExprValidationException(
"The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return new InternalEventRouterDescForge(
copyMethod,
wideners,
eventType,
annotations,
desc.OptionalWhereClause,
properties,
expressions);
}