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(); }