public void ValidateExistingType(
EventType existingType,
AvroSchemaEventType proposedType)
{
if (!(existingType is AvroSchemaEventType)) {
throw new EventAdapterException(
"Type by name '" +
proposedType.Name +
"' is not a compatible type " +
"(target type underlying is '" +
existingType.UnderlyingType.Name +
"', " +
"source type underlying is '" +
proposedType.UnderlyingType.Name +
"')");
}
var proposed = (Schema) proposedType.Schema;
var existing = (Schema) ((AvroSchemaEventType) existingType).Schema;
if (!proposed.Equals(existing)) {
throw new EventAdapterException(
"Event type named '" +
existingType.Name +
"' has already been declared with differing column name or type information\n" +
"schemaExisting: " +
AvroSchemaUtil.ToSchemaStringSafe(existing) +
"\n" +
"schemaProposed: " +
AvroSchemaUtil.ToSchemaStringSafe(proposed));
}
}
public EventBeanManufacturer GetEventBeanManufacturer(
AvroSchemaEventType avroSchemaEventType,
EventAdapterService eventAdapterService,
IList <WriteablePropertyDescriptor> properties)
{
return(new EventBeanManufacturerAvro(avroSchemaEventType, eventAdapterService, properties));
}
public object ConvertEvent(
EventBean theEvent,
AvroSchemaEventType targetType)
{
var original = ((AvroGenericDataBackedEventBean) theEvent).Properties;
var targetSchema = (Schema) targetType.Schema;
var target = new GenericRecord(targetSchema.AsRecordSchema());
foreach (var field in original.Schema.Fields) {
var targetField = targetSchema.GetField(field.Name);
if (targetField == null) {
continue;
}
if (field.Schema.Tag == Schema.Type.Array) {
var originalColl = (ICollection<object>) original.Get(field);
if (originalColl != null) {
target.Put(targetField, new List<object>(originalColl));
}
}
else if (field.Schema.Tag == Schema.Type.Map) {
var originalMap = (IDictionary<string, object>) original.Get(field);
if (originalMap != null) {
target.Put(targetField, new Dictionary<string, object>(originalMap));
}
}
else {
target.Put(targetField, original.Get(field));
}
}
return target;
}
public EventBeanManufacturer GetEventBeanManufacturer(
AvroSchemaEventType avroSchemaEventType,
EventAdapterService eventAdapterService,
IList <WriteablePropertyDescriptor> properties)
{
throw GetUnsupported();
}
public EventBeanManufacturerAvro(
AvroSchemaEventType eventType,
EventBeanTypedEventFactory eventAdapterService,
Field[] indexPerWritable)
{
_eventAdapterService = eventAdapterService;
_eventType = (AvroEventType) eventType;
_schema = _eventType.SchemaAvro;
_indexPerWritable = indexPerWritable;
}
public void Add(
string recordSchemaName,
AvroSchemaEventType fragmentType)
{
if (_cacheByRecordSchemaName == null) {
_cacheByRecordSchemaName = new Dictionary<string, AvroSchemaEventType>();
}
_cacheByRecordSchemaName.Put(recordSchemaName, fragmentType);
}
public SelectExprProcessor MakeRecast(
EventType[] eventTypes,
SelectExprContext selectExprContext,
int streamNumber,
AvroSchemaEventType insertIntoTargetType,
ExprNode[] exprNodes,
string statementName,
string engineURI)
{
return AvroRecastFactory.Make(
eventTypes, selectExprContext, streamNumber, insertIntoTargetType, exprNodes, statementName, engineURI);
}
public EventBeanManufacturerAvroForge(
AvroSchemaEventType eventType,
WriteablePropertyDescriptor[] properties)
{
_eventType = (AvroEventType) eventType;
Schema schema = _eventType.SchemaAvro;
_indexPerWritable = new Field[properties.Length];
for (var i = 0; i < properties.Length; i++) {
var propertyName = properties[i].PropertyName;
var field = schema.GetField(propertyName);
_indexPerWritable[i] = field ??
throw new IllegalStateException($"Failed to find property '{propertyName}' among the array indexes");
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="eventType">type to create</param>
/// <param name="eventAdapterService">event factory</param>
/// <param name="properties">written properties</param>
public EventBeanManufacturerAvro(
AvroSchemaEventType eventType,
EventAdapterService eventAdapterService,
IList<WriteablePropertyDescriptor> properties)
{
_eventAdapterService = eventAdapterService;
_eventType = (AvroEventType) eventType;
_schema = _eventType.SchemaAvro;
_indexPerWritable = new Field[properties.Count];
for (int i = 0; i < properties.Count; i++)
{
string propertyName = properties[i].PropertyName;
var field = _schema.GetField(propertyName);
if (field == null)
{
throw new IllegalStateException(
"Failed to find property '" + propertyName + "' among the array indexes");
}
_indexPerWritable[i] = field;
}
}
public void ValidateExistingType(
EventType existingType,
AvroSchemaEventType proposedType)
{
throw new UnsupportedOperationException();
}
public EventBeanManufacturerForge GetEventBeanManufacturer(
AvroSchemaEventType avroSchemaEventType,
WriteablePropertyDescriptor[] properties)
{
throw new UnsupportedOperationException();
}
public object ConvertEvent(
EventBean theEvent,
AvroSchemaEventType targetType)
{
throw new UnsupportedOperationException();
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
AvroSchemaEventType targetType,
ExprNode[] exprNodes,
string statementName)
{
AvroEventType resultType = (AvroEventType) targetType;
AvroEventType streamType = (AvroEventType) eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (resultType.Schema.Equals(streamType.Schema) && selectExprForgeContext.ExprForges.Length == 0) {
return new AvroInsertProcessorSimpleRepackage(selectExprForgeContext, streamNumber, targetType);
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(resultType, 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;
Field streamTypeField = streamType.SchemaAvro.GetField(propertyName);
Field resultTypeField = resultType.SchemaAvro.GetField(propertyName);
if (streamTypeField != null && resultTypeField != null) {
if (streamTypeField.Schema.Equals(resultTypeField.Schema)) {
items.Add(new Item(resultTypeField, streamTypeField, null, null));
}
else {
throw new ExprValidationException(
"Type by name '" +
resultType.Name +
"' " +
"in property '" +
propertyName +
"' expected schema '" +
resultTypeField.Schema +
"' but received schema '" +
streamTypeField.Schema +
"'");
}
}
}
// find the properties coming from the expressions of the select clause
var typeWidenerCustomizer =
selectExprForgeContext.EventTypeAvroHandler.GetTypeWidenerCustomizer(targetType);
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++) {
var columnName = selectExprForgeContext.ColumnNames[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null) {
throw new ExprValidationException(
"Failed to find column '" + columnName + "' in target type '" + resultType.Name + "'");
}
Field resultTypeField = resultType.SchemaAvro.GetField(writable.PropertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(resultTypeField, null, exprNode.Forge, widener));
written.Add(writable);
}
// make manufacturer
Item[] itemsArr = items.ToArray();
return new AvroInsertProcessorAllocate(
streamNumber,
itemsArr,
resultType,
resultType.SchemaAvro,
selectExprForgeContext.EventBeanTypedEventFactory);
}
public EventBeanManufacturerForge GetEventBeanManufacturer(
AvroSchemaEventType avroSchemaEventType,
WriteablePropertyDescriptor[] properties)
{
return new EventBeanManufacturerAvroForge(avroSchemaEventType, properties);
}
public Object ConvertEvent(EventBean theEvent, AvroSchemaEventType targetType)
{
throw GetUnsupported();
}
public void ValidateExistingType(EventType existingType, AvroSchemaEventType proposedType)
{
throw GetUnsupported();
}