public SelectEvalBase(
SelectExprForgeContext context,
EventType resultEventType)
{
this.context = context;
this.resultEventType = resultEventType;
}
public SelectEvalNoWildcardObjectArray(
SelectExprForgeContext context,
EventType resultEventType)
{
this.context = context;
this.resultEventType = resultEventType;
}
protected SelectEvalBaseMap(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
: base(selectExprForgeContext, resultEventType)
{
}
public SelectEvalStreamWUnderlying(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard,
IList<SelectExprStreamDesc> unnamedStreams,
bool singleStreamWrapper,
bool underlyingIsFragmentEvent,
int underlyingStreamNumber,
EventPropertyGetterSPI underlyingPropertyEventGetter,
ExprForge underlyingExprForge,
TableMetaData tableMetadata,
EventType[] eventTypes)
: base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard)
{
wrapperEventType = (WrapperEventType) resultEventType;
this.unnamedStreams = unnamedStreams;
this.singleStreamWrapper = singleStreamWrapper;
this.underlyingIsFragmentEvent = underlyingIsFragmentEvent;
this.underlyingStreamNumber = underlyingStreamNumber;
this.underlyingPropertyEventGetter = underlyingPropertyEventGetter;
this.underlyingExprForge = underlyingExprForge;
this.tableMetadata = tableMetadata;
this.eventTypes = eventTypes;
}
public SelectEvalNoWildcardEmptyProps(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
{
this.selectExprForgeContext = selectExprForgeContext;
this.resultEventType = resultEventType;
}
public SelectEvalNoWildcardJson(
SelectExprForgeContext selectContext,
JsonEventType jsonEventType)
{
this._selectContext = selectContext;
this._jsonEventType = jsonEventType;
}
public SelectEvalInsertWildcardWrapper(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
: base(selectExprForgeContext, resultEventType)
{
}
public SelectEvalInsertNoWildcardSingleColCoercionMapWrap(
SelectExprForgeContext selectExprForgeContext,
WrapperEventType wrapper)
: base(selectExprForgeContext, wrapper)
{
}
public SelectEvalBaseFirstProp(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
{
this.selectExprForgeContext = selectExprForgeContext;
this.resultEventType = resultEventType;
}
public SelectEvalInsertNoWildcardSingleColCoercionBean(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
: base(selectExprForgeContext, resultEventType)
{
}
public SelectEvalInsertNoWildcardObjectArray(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType)
: base(selectExprForgeContext, resultEventType)
{
}
public SelectEvalBaseFirstPropFromWrap(
SelectExprForgeContext selectExprForgeContext,
WrapperEventType wrapper)
: base(selectExprForgeContext, wrapper)
{
this.wrapper = wrapper;
}
public SelectEvalInsertNoWildcardSingleColCoercionBeanWrapVariant(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
VariantEventType variantEventType)
: base(selectExprForgeContext, resultEventType)
{
this.variantEventType = variantEventType;
}
public SelectExprProcessorForge MakeSelectNoWildcard(
SelectExprForgeContext selectExprForgeContext,
ExprForge[] exprForges,
EventType resultEventType,
TableCompileTimeResolver tableService,
string statementName)
{
return new EvalSelectNoWildcardAvro(selectExprForgeContext, exprForges, resultEventType, statementName);
}
public SelectEvalInsertWildcardVariant(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
VariantEventType variantEventType)
: base(selectExprForgeContext, resultEventType)
{
this.variantEventType = variantEventType;
}
protected SelectEvalStreamBaseMap(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard)
: base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard)
{
}
public SelectEvalInsertNoWildcardObjectArrayRemap(
SelectExprForgeContext context,
EventType resultEventType,
int[] remapped)
{
this.context = context;
this.resultEventType = resultEventType;
this.remapped = remapped;
}
internal OAInsertProcessorSimpleRepackage(
SelectExprForgeContext selectExprForgeContext,
int underlyingStreamNumber,
EventType resultType)
{
this.selectExprForgeContext = selectExprForgeContext;
this.underlyingStreamNumber = underlyingStreamNumber;
ResultEventType = resultType;
}
public SelectEvalStreamBaseObjectArray(
SelectExprForgeContext context,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard)
: base(context, resultEventType, namedStreams, usingWildcard)
{
}
public SelectEvalWildcardJoin(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
SelectExprProcessorForge joinWildcardProcessorForge)
: base(selectExprForgeContext, resultEventType)
{
this.joinWildcardProcessorForge = joinWildcardProcessorForge;
}
public SelectEvalInsertWildcardWrapperNested(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
WrapperEventType innerWrapperType)
: base(selectExprForgeContext, resultEventType)
{
this.innerWrapperType = innerWrapperType;
}
public SelectEvalStreamBase(
SelectExprForgeContext context,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard)
{
this.context = context;
this.resultEventType = resultEventType;
this.namedStreams = namedStreams;
isUsingWildcard = usingWildcard;
}
public SelectEvalInsertWildcardJoinVariant(
SelectExprForgeContext context,
EventType resultEventType,
SelectExprProcessorForge joinWildcardProcessorForge,
VariantEventType variantEventType)
: base(context, resultEventType)
{
this.joinWildcardProcessorForge = joinWildcardProcessorForge;
this.variantEventType = variantEventType;
}
public SelectEvalInsertNoWildcardObjectArrayRemapWWiden(
SelectExprForgeContext context,
EventType resultEventType,
int[] remapped,
TypeWidenerSPI[] wideners)
{
this.context = context;
this.resultEventType = resultEventType;
this.remapped = remapped;
this.wideners = wideners;
}
public SelectEvalStreamNoUndWEventBeanToObj(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard,
ISet<string> eventBeanToObjectProps)
: base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard)
{
this.eventBeanToObjectProps = eventBeanToObjectProps.ToArray();
}
public SelectExprProcessorForge MakeRecast(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
AvroSchemaEventType insertIntoTargetType,
ExprNode[] exprNodes,
string statementName)
{
return AvroRecastFactory.Make(
eventTypes,
selectExprForgeContext,
streamNumber,
insertIntoTargetType,
exprNodes,
statementName);
}
public SelectEvalStreamNoUndWEventBeanToObjObjArray(
SelectExprForgeContext selectExprForgeContext,
EventType resultEventType,
IList<SelectClauseStreamCompiledSpec> namedStreams,
bool usingWildcard,
ISet<string> eventBeanToObjectProps)
: base(selectExprForgeContext, resultEventType, namedStreams, usingWildcard)
{
var eventBeanToObjectIndexes = new HashSet<int>();
var type = (ObjectArrayEventType) resultEventType;
foreach (var name in eventBeanToObjectProps) {
if (type.PropertiesIndexes.TryGetValue(name, out var index)) {
eventBeanToObjectIndexes.Add(index);
}
}
eventBeanToObjectIndexesArray = eventBeanToObjectIndexes.ToArray();
}
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 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 EvalSelectNoWildcardAvro(
SelectExprForgeContext selectExprForgeContext,
ExprForge[] exprForges,
EventType resultEventTypeAvro,
string statementName)
{
_selectExprForgeContext = selectExprForgeContext;
_resultEventTypeAvro = (AvroEventType) resultEventTypeAvro;
_forges = new ExprForge[selectExprForgeContext.ExprForges.Length];
var typeWidenerCustomizer =
selectExprForgeContext.EventTypeAvroHandler.GetTypeWidenerCustomizer(resultEventTypeAvro);
for (var i = 0; i < _forges.Length; i++) {
_forges[i] = selectExprForgeContext.ExprForges[i];
var forge = exprForges[i];
var forgeEvaluationType = forge.EvaluationType;
if (forge is ExprEvalByGetterFragment) {
_forges[i] = HandleFragment((ExprEvalByGetterFragment) forge);
}
else if (forge is ExprEvalStreamInsertBean) {
var und = (ExprEvalStreamInsertBean) forge;
_forges[i] =
new SelectExprInsertEventBeanFactory.ExprForgeStreamUnderlying(und.StreamNum, typeof(object));
}
else if (forge is SelectExprProcessorTypableMapForge) {
var typableMap = (SelectExprProcessorTypableMapForge) forge;
_forges[i] = new SelectExprProcessorEvalAvroMapToAvro(
typableMap.InnerForge,
((AvroEventType) resultEventTypeAvro).SchemaAvro,
selectExprForgeContext.ColumnNames[i]);
}
else if (forge is ExprEvalStreamInsertNamedWindow) {
var nw = (ExprEvalStreamInsertNamedWindow) forge;
_forges[i] =
new SelectExprInsertEventBeanFactory.ExprForgeStreamUnderlying(nw.StreamNum, typeof(object));
}
else if (forgeEvaluationType != null && forgeEvaluationType.IsArray) {
var widener = TypeWidenerFactory.GetArrayToCollectionCoercer(forgeEvaluationType.GetElementType());
var resultType = typeof(ICollection<object>);
_forges[i] = new SelectExprProcessorEvalAvroArrayCoercer(forge, widener, resultType);
}
else {
var propertyName = selectExprForgeContext.ColumnNames[i];
var propertyType = resultEventTypeAvro.GetPropertyType(propertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
propertyName,
forgeEvaluationType,
propertyType,
propertyName,
true,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
if (widener != null) {
_forges[i] = new SelectExprProcessorEvalAvroArrayCoercer(forge, widener, propertyType);
}
}
}
}
