public StmtClassForgeableBaseNestableEventTypeSerde(string className, CodegenNamespaceScope namespaceScope, BaseNestableEventType eventType, DataInputOutputSerdeForge[] forges)
{
this.className = className;
this.namespaceScope = namespaceScope;
this.eventType = eventType;
this.forges = forges;
}
private static SerdeAndForgeables PlanBaseNestable(
BaseNestableEventType eventType,
StatementRawInfo raw,
SerdeCompileTimeResolver resolver)
{
string className;
if (eventType is JsonEventType)
{
var classNameFull = ((JsonEventType)eventType).Detail.SerdeClassName;
var lastDotIndex = classNameFull.LastIndexOf('.');
className = lastDotIndex == -1 ? classNameFull : classNameFull.Substring(lastDotIndex + 1);
}
else
{
var uuid = GenerateClassNameUUID();
className = GenerateClassNameWithUUID(typeof(DataInputOutputSerde), eventType.Metadata.Name, uuid);
}
var optionalApplicationSerde = resolver.SerdeForEventTypeExternalProvider(eventType, raw);
if (optionalApplicationSerde != null)
{
return(new SerdeAndForgeables(optionalApplicationSerde, EmptyList <StmtClassForgeableFactory> .Instance));
}
var forges = new DataInputOutputSerdeForge[eventType.Types.Count];
var count = 0;
foreach (var property in eventType.Types)
{
var desc = ForgeForEventProperty(eventType, property.Key, property.Value, raw, resolver);
forges[count] = desc.Forge;
count++;
}
StmtClassForgeableFactory forgeable = new ProxyStmtClassForgeableFactory()
{
ProcMake = (
namespaceScope,
classPostfix) => {
return(new StmtClassForgeableBaseNestableEventTypeSerde(className, namespaceScope, eventType, forges));
},
};
var forge = new DataInputOutputSerdeForgeForClassName(className);
return(new SerdeAndForgeables(forge, Collections.SingletonList(forgeable)));
}
public DataInputOutputSerdeForge SerdeForEventTypeExternalProvider(
BaseNestableEventType eventType,
StatementRawInfo raw)
{
if (serdeProviders.IsEmpty())
{
return(null);
}
SerdeProviderEventTypeContext context = new SerdeProviderEventTypeContext(raw, eventType);
foreach (SerdeProvider provider in serdeProviders)
{
try {
SerdeProvision serde = provider.ResolveSerdeForEventType(context);
if (serde != null)
{
return(serde.ToForge());
}
}
catch (DataInputOutputSerdeException) {
throw;
}
catch (EPException) {
throw;
}
catch (Exception ex) {
throw new DataInputOutputSerdeException(
"Unexpected exception invoking serde provider '" +
provider.GetType().Name +
"' passing for event type '" +
eventType.Name +
"': " +
ex.Message,
ex);
}
}
return(null);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
var analysis = AnalyzeCase();
foreach (var pair in analysis.WhenThenNodeList) {
if (!IsCase2) {
var returnType = pair.First.Forge.EvaluationType;
if (returnType != typeof(bool) && returnType != typeof(bool?)) {
throw new ExprValidationException("Case node 'when' expressions must return a boolean value");
}
}
}
var mustCoerce = false;
Coercer coercer = null;
if (IsCase2) {
// validate we can compare result types
var comparedTypes = new List<Type>();
comparedTypes.Add(analysis.OptionalCompareExprNode.Forge.EvaluationType);
foreach (var pair in analysis.WhenThenNodeList) {
comparedTypes.Add(pair.First.Forge.EvaluationType);
}
// Determine common denominator type
try {
var coercionType = TypeHelper.GetCommonCoercionType(comparedTypes.ToArray());
// Determine if we need to coerce numbers when one type doesn't match any other type
if (coercionType.IsNumeric()) {
mustCoerce = false;
foreach (var comparedType in comparedTypes) {
if (comparedType != coercionType) {
mustCoerce = true;
}
}
if (mustCoerce) {
coercer = SimpleNumberCoercerFactory.GetCoercer(null, coercionType);
}
}
}
catch (CoercionException ex) {
throw new ExprValidationException("Implicit conversion not allowed: " + ex.Message);
}
}
// Determine type of each result (then-node and else node) child node expression
IList<Type> childTypes = new List<Type>();
IList<IDictionary<string, object>> childMapTypes = new List<IDictionary<string, object>>();
foreach (var pair in analysis.WhenThenNodeList) {
if (pair.Second.Forge is ExprTypableReturnForge) {
var typableReturn = (ExprTypableReturnForge) pair.Second.Forge;
var rowProps = typableReturn.RowProperties;
if (rowProps != null) {
childMapTypes.Add(rowProps);
continue;
}
}
childTypes.Add(pair.Second.Forge.EvaluationType);
}
if (analysis.OptionalElseExprNode != null) {
if (analysis.OptionalElseExprNode.Forge is ExprTypableReturnForge) {
var typableReturn = (ExprTypableReturnForge) analysis.OptionalElseExprNode.Forge;
var rowProps = typableReturn.RowProperties;
if (rowProps != null) {
childMapTypes.Add(rowProps);
}
else {
childTypes.Add(analysis.OptionalElseExprNode.Forge.EvaluationType);
}
}
else {
childTypes.Add(analysis.OptionalElseExprNode.Forge.EvaluationType);
}
}
if (!childMapTypes.IsEmpty() && !childTypes.IsEmpty()) {
var message =
"Case node 'when' expressions require that all results either return a single value or a Map-type (new-operator) value";
string check;
var count = -1;
foreach (var pair in analysis.WhenThenNodeList) {
count++;
if (pair.Second.Forge.EvaluationType != null &&
pair.Second.Forge.EvaluationType.IsNotGenericDictionary()) {
check = ", check when-condition number " + count;
throw new ExprValidationException(message + check);
}
}
if (analysis.OptionalElseExprNode != null) {
if (analysis.OptionalElseExprNode.Forge.EvaluationType != null &&
analysis.OptionalElseExprNode.Forge.EvaluationType.IsNotGenericDictionary()) {
check = ", check the else-condition";
throw new ExprValidationException(message + check);
}
}
throw new ExprValidationException(message);
}
IDictionary<string, object> mapResultType = null;
Type resultType = null;
var isNumericResult = false;
if (childMapTypes.IsEmpty()) {
// Determine common denominator type
try {
resultType = TypeHelper
.GetCommonCoercionType(childTypes.ToArray())
.GetBoxedType();
if (resultType.IsNumeric()) {
isNumericResult = true;
}
}
catch (CoercionException ex) {
throw new ExprValidationException("Implicit conversion not allowed: " + ex.Message);
}
}
else {
resultType = typeof(IDictionary<string, object>);
mapResultType = childMapTypes[0];
for (var i = 1; i < childMapTypes.Count; i++) {
var other = childMapTypes[i];
var messageEquals = BaseNestableEventType.IsDeepEqualsProperties(
"Case-when number " + i,
mapResultType,
other);
if (messageEquals != null) {
throw new ExprValidationException(
"Incompatible case-when return types by new-operator in case-when number " +
i +
": " +
messageEquals.Message,
messageEquals);
}
}
}
forge = new ExprCaseNodeForge(
this,
resultType,
mapResultType,
isNumericResult,
mustCoerce,
coercer,
analysis.WhenThenNodeList,
analysis.OptionalCompareExprNode,
analysis.OptionalElseExprNode);
return null;
}
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 DataInputOutputSerdeForge SerdeForEventTypeExternalProvider(
BaseNestableEventType eventType,
StatementRawInfo raw)
{
return(Noop());
}
