public bool IsDeepEqualsConsiderOrder(ObjectArrayEventType other)
{
var factoryOther = (EventTypeNestableGetterFactoryObjectArray)other.GetterFactory;
var factoryMe = (EventTypeNestableGetterFactoryObjectArray)GetterFactory;
if (factoryOther.PropertiesIndex.Count != factoryMe.PropertiesIndex.Count)
{
return(false);
}
foreach (var propMeEntry in factoryMe.PropertiesIndex)
{
int otherIndex;
if (!factoryOther.PropertiesIndex.TryGetValue(propMeEntry.Key, out otherIndex) ||
(otherIndex != propMeEntry.Value))
{
return(false);
}
var propName = propMeEntry.Key;
var setOneType = NestableTypes.Get(propName);
var setTwoType = other.NestableTypes.Get(propName);
var setTwoTypeFound = other.NestableTypes.ContainsKey(propName);
var comparedMessage = BaseNestableEventUtil.ComparePropType(
propName, setOneType, setTwoType, setTwoTypeFound, other.Name);
if (comparedMessage != null)
{
return(false);
}
}
return(true);
}
public bool IsDeepEqualsConsiderOrder(JsonEventType other)
{
if (other.NestableTypes.Count != NestableTypes.Count)
{
return(false);
}
foreach (var propMeEntry in NestableTypes)
{
var fieldMe = _detail.FieldDescriptors.Get(propMeEntry.Key);
var fieldOther = other._detail.FieldDescriptors.Get(propMeEntry.Key);
if (fieldOther == null || fieldMe.FieldName != fieldOther.FieldName)
{
return(false);
}
var propName = propMeEntry.Key;
var setOneType = this.NestableTypes.Get(propName);
var setTwoType = other.NestableTypes.Get(propName);
var setTwoTypeFound = other.NestableTypes.ContainsKey(propName);
var comparedMessage = BaseNestableEventUtil.ComparePropType(
propName,
setOneType,
setTwoType,
setTwoTypeFound,
other.Name);
if (comparedMessage != null)
{
return(false);
}
}
return(true);
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
EventType targetType,
ExprNode[] exprNodes,
ImportServiceCompileTime importService,
string statementName)
{
var oaResultType = (ObjectArrayEventType) targetType;
var oaStreamType = (ObjectArrayEventType) eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (oaResultType.IsDeepEqualsConsiderOrder(oaStreamType) && selectExprForgeContext.ExprForges.Length == 0) {
return new OAInsertProcessorSimpleRepackage(selectExprForgeContext, streamNumber, targetType);
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(oaResultType, true, false);
IList<Item> items = new List<Item>();
IList<WriteablePropertyDescriptor> written = new List<WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
foreach (var writeable in writables) {
var propertyName = writeable.PropertyName;
var hasIndexSource = oaStreamType.PropertiesIndexes.TryGetValue(propertyName, out var indexSource);
var hasIndexTarget = oaResultType.PropertiesIndexes.TryGetValue(propertyName, out var indexTarget);
if (hasIndexSource) {
var setOneType = oaStreamType.Types.Get(propertyName);
var setTwoType = oaResultType.Types.Get(propertyName);
var setTwoTypeFound = oaResultType.Types.ContainsKey(propertyName);
var message = BaseNestableEventUtil.ComparePropType(
propertyName,
setOneType,
setTwoType,
setTwoTypeFound,
oaResultType.Name);
if (message != null) {
throw new ExprValidationException(message.Message, message);
}
items.Add(new Item(indexTarget, indexSource, null, null));
written.Add(writeable);
}
}
// find the properties coming from the expressions of the select clause
var count = written.Count;
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++) {
var columnName = selectExprForgeContext.ColumnNames[i];
var forge = selectExprForgeContext.ExprForges[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null) {
throw new ExprValidationException(
"Failed to find column '" + columnName + "' in target type '" + oaResultType.Name + "'");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
null,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(count, -1, forge, widener));
written.Add(writable);
count++;
}
// make manufacturer
var itemsArr = items.ToArray();
EventBeanManufacturerForge manufacturer;
try {
manufacturer = EventTypeUtility.GetManufacturer(
oaResultType,
written.ToArray(),
importService,
true,
selectExprForgeContext.EventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException("Failed to write to type: " + e.Message, e);
}
return new OAInsertProcessorAllocate(streamNumber, itemsArr, manufacturer, targetType);
}
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));
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
EventType targetType,
ExprNode[] exprNodes,
ImportServiceCompileTime classpathImportService,
string statementName)
{
var jsonResultType = (JsonEventType)targetType;
var jsonStreamType = (JsonEventType)eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (jsonResultType.IsDeepEqualsConsiderOrder(jsonStreamType) && selectExprForgeContext.ExprForges.Length == 0)
{
return(new JsonInsertProcessorStraightFieldAssign(streamNumber, jsonStreamType, jsonResultType));
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(jsonResultType, true, false);
var items = new List <Item>();
var written = new List <WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
foreach (var writeable in writables)
{
var propertyName = writeable.PropertyName;
var fieldSource = jsonStreamType.Detail.FieldDescriptors.Get(propertyName);
var fieldTarget = jsonResultType.Detail.FieldDescriptors.Get(propertyName);
if (fieldSource != null)
{
var setOneType = jsonStreamType.Types.Get(propertyName);
var setTwoType = jsonResultType.Types.Get(propertyName);
var setTwoTypeFound = jsonResultType.Types.ContainsKey(propertyName);
var message = BaseNestableEventUtil.ComparePropType(propertyName, setOneType, setTwoType, setTwoTypeFound, jsonResultType.Name);
if (message != null)
{
throw new ExprValidationException(message.Message, message);
}
items.Add(new Item(fieldTarget, fieldSource, null, null));
written.Add(writeable);
}
}
// find the properties coming from the expressions of the select clause
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++)
{
var columnName = selectExprForgeContext.ColumnNames[i];
var forge = selectExprForgeContext.ExprForges[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null)
{
throw new ExprValidationException("Failed to find column '" + columnName + "' in target type '" + jsonResultType.Name + "'");
}
var fieldTarget = jsonResultType.Detail.FieldDescriptors.Get(writable.PropertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
null,
statementName);
} catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(fieldTarget, null, forge, widener));
written.Add(writable);
}
// make manufacturer
var itemsArr = items.ToArray();
return(new JsonInsertProcessorExpressions(streamNumber, itemsArr, jsonStreamType, jsonResultType));
}