protected void FillMethodsAnnotatedWith(Type type, IList <MethodInfo> methods, params Type[] annotations)
{
if (type == null || typeof(Object).Equals(type))
{
return;
}
FillMethodsAnnotatedWith(type.BaseType, methods, annotations);
MethodInfo[] allMethodsOfThisType = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic);
for (int a = 0, size = allMethodsOfThisType.Length; a < size; a++)
{
MethodInfo currentMethod = allMethodsOfThisType[a];
for (int b = annotations.Length; b-- > 0;)
{
if (AnnotationUtil.GetAnnotation(annotations[b], currentMethod, false) == null)
{
continue;
}
if (currentMethod.GetParameters().Length != 0)
{
throw new Exception("It is not allowed to annotated methods without " + annotations[b].FullName + " having 0 arguments: "
+ currentMethod.ToString());
}
methods.Add(currentMethod);
}
}
}
protected Object Intercept(IInvocation invocation, String methodName, Attribute annotation, Boolean?isAsyncBegin)
{
if (AnnotationUtil.GetAnnotation <ProcessAttribute>(invocation.Method, false) != null)
{
return(InterceptApplication(invocation, annotation, isAsyncBegin));
}
if (AnnotationUtil.GetAnnotation <MergeAttribute>(invocation.Method, false) != null ||
methodName.StartsWith("update") ||
methodName.StartsWith("save") ||
methodName.StartsWith("merge") ||
methodName.StartsWith("insert"))
{
return(InterceptMerge(invocation, annotation, isAsyncBegin));
}
if (AnnotationUtil.GetAnnotation <RemoveAttribute>(invocation.Method, false) != null ||
methodName.StartsWith("delete") ||
methodName.StartsWith("remove"))
{
return(InterceptDelete(invocation, annotation, isAsyncBegin));
}
if (AnnotationUtil.GetAnnotation <FindAttribute>(invocation.Method, false) != null ||
methodName.StartsWith("retrieve") ||
methodName.StartsWith("read") ||
methodName.StartsWith("find") ||
methodName.StartsWith("get"))
{
return(InterceptLoad(invocation, annotation, isAsyncBegin));
}
if (methodName.Equals("close") || methodName.Equals("abort"))
{
// Intended blank
}
return(InterceptApplication(invocation, annotation, isAsyncBegin));
}
protected void FindAnnotations <V>(Type type, IList <IAnnotationInfo <V> > targetList, bool isFirst) where V : Attribute
{
if (type == null || typeof(Object).Equals(type))
{
return;
}
if (!type.IsInterface)
{
FindAnnotations <V>(type.BaseType, targetList, false);
}
IList <V> annotations = AnnotationUtil.GetAnnotations <V>(type, false);
for (int a = 0, size = annotations.Count; a < size; a++)
{
targetList.Add(new AnnotationInfo <V>(annotations[a], type));
}
//if (isFirst)
//{
// Type[] interfaces = type.GetInterfaces();
// foreach (Type currInterface in interfaces)
// {
// IList<V> annotationsOfInterface = AnnotationUtil.GetAnnotations<V>(currInterface, true);
// for (int a = 0, size = annotationsOfInterface.Count; a < size; a++)
// {
// targetList.Add(new AnnotationInfo<V>(annotationsOfInterface[a], type));
// }
// }
//}
}
private static EventType ValidateExpressionGetEventType(string msgprefix, IList <AnnotationDesc> annotations, EventAdapterService eventAdapterService)
{
IDictionary <String, IList <AnnotationDesc> > annos = AnnotationUtil.MapByNameLowerCase(annotations);
// check annotations used
IList <AnnotationDesc> typeAnnos = annos.Pluck("type");
if (!annos.IsEmpty())
{
throw new ExprValidationException(msgprefix + " unrecognized annotation '" + annos.Keys.First() + "'");
}
// type determination
EventType optionalType = null;
if (typeAnnos != null)
{
string typeName = AnnotationUtil.GetExpectSingleStringValue(msgprefix, typeAnnos);
optionalType = eventAdapterService.GetEventTypeByName(typeName);
if (optionalType == null)
{
throw new ExprValidationException(msgprefix + " failed to find event type '" + typeName + "'");
}
}
return(optionalType);
}
protected ForkStateEntry[] GetForkStateEntries()
{
ForkStateEntry[] cachedForkStateEntries = this.cachedForkStateEntries;
if (cachedForkStateEntries != null)
{
return(cachedForkStateEntries);
}
Lock writeLock = listeners.GetWriteLock();
writeLock.Lock();
try
{
// check again: concurrent thread might have been faster
cachedForkStateEntries = this.cachedForkStateEntries;
if (cachedForkStateEntries != null)
{
return(cachedForkStateEntries);
}
IThreadLocalCleanupBean[] extensions = listeners.GetExtensions();
List <ForkStateEntry> forkStateEntries = new List <ForkStateEntry>(extensions.Length);
for (int a = 0, size = extensions.Length; a < size; a++)
{
IThreadLocalCleanupBean extension = extensions[a];
FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(extension.GetType());
foreach (FieldInfo field in fields)
{
Forkable forkable = AnnotationUtil.GetAnnotation <Forkable>(field, false);
if (forkable == null)
{
continue;
}
Object valueTL = field.GetValue(extension);
if (valueTL == null)
{
continue;
}
Type forkProcessorType = forkable.Processor;
IForkProcessor forkProcessor = null;
if (forkProcessorType != null && !typeof(IForkProcessor).Equals(forkProcessorType))
{
WeakReference beanContextOfExtensionR = extensionToContextMap.Get(extension);
IServiceContext beanContextOfExtension = beanContextOfExtensionR != null ? (IServiceContext)beanContextOfExtensionR.Target : null;
if (beanContextOfExtension == null)
{
beanContextOfExtension = BeanContext;
}
forkProcessor = beanContextOfExtension.RegisterBean <IForkProcessor>(forkProcessorType).Finish();
}
forkStateEntries.Add(new ForkStateEntry(extension, field.Name, valueTL, forkable.Value, forkProcessor));
}
}
cachedForkStateEntries = forkStateEntries.ToArray();
this.cachedForkStateEntries = cachedForkStateEntries;
return(cachedForkStateEntries);
}
finally
{
writeLock.Unlock();
}
}
private static EventType ValidateExpressionGetEventType(
string msgprefix,
IList<AnnotationDesc> annotations,
StatementCompileTimeServices services)
{
var annos = AnnotationUtil.MapByNameLowerCase(annotations);
// check annotations used
var typeAnnos = annos.Delete("type");
if (!annos.IsEmpty()) {
throw new ExprValidationException(msgprefix + " unrecognized annotation '" + annos.Keys.First() + "'");
}
// type determination
EventType optionalType = null;
if (typeAnnos != null) {
var typeName = AnnotationUtil.GetExpectSingleStringValue(msgprefix, typeAnnos);
optionalType = services.EventTypeCompileTimeResolver.GetTypeByName(typeName);
if (optionalType == null) {
throw new ExprValidationException(msgprefix + " failed to find event type '" + typeName + "'");
}
}
return optionalType;
}
public String GetPropertyNameFor(MethodInfo method)
{
PropertyAccessor propertyAccessor = AnnotationUtil.GetAnnotation <PropertyAccessor>(method, true);
if (propertyAccessor != null)
{
return(propertyAccessor.PropertyName);
}
Match matcher = getSetIsPattern.Match(method.Name);
if (!matcher.Success)
{
return("");
}
int paramLength = method.GetParameters().Length;
String getSetIs = matcher.Groups[1].Value;
if (("get_".Equals(getSetIs) || "Get".Equals(getSetIs) || "get".Equals(getSetIs)) && (0 != paramLength || typeof(void).Equals(method.ReturnType)))
{
return("");
}
else if (("set_".Equals(getSetIs) || "Set".Equals(getSetIs) || "set".Equals(getSetIs)) && 1 != paramLength)
{
return("");
}
else if (("Is".Equals(getSetIs) || "is".Equals(getSetIs)) && (0 != paramLength || typeof(void).Equals(method.ReturnType)))
{
return("");
}
String name = matcher.Groups[2].Value;
return(StringConversionHelper.UpperCaseFirst(name));
}
protected override Attribute LookForAnnotation(MemberInfo method)
{
Attribute annotation = base.LookForAnnotation(method);
if (annotation != null)
{
return(annotation);
}
NoProxyAttribute noProxy = AnnotationUtil.GetAnnotation <NoProxyAttribute>(method, false);
if (noProxy != null)
{
return(noProxy);
}
ProcessAttribute process = AnnotationUtil.GetAnnotation <ProcessAttribute>(method, false);
if (process != null)
{
return(process);
}
FindAttribute find = AnnotationUtil.GetAnnotation <FindAttribute>(method, false);
if (find != null)
{
return(find);
}
MergeAttribute merge = AnnotationUtil.GetAnnotation <MergeAttribute>(method, false);
if (merge != null)
{
return(merge);
}
return(AnnotationUtil.GetAnnotation <RemoveAttribute>(method, false));
}
protected override Attribute LookForAnnotation(MemberInfo method)
{
Attribute annotation = base.LookForAnnotation(method);
if (annotation != null)
{
return(annotation);
}
return(AnnotationUtil.GetAnnotation <CachedAttribute>(method, false));
}
public void MakeMethod(
CodegenMethod method,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var select = Ref("select");
method.Block
.DeclareVar<FAFQueryMethodSelect>(select.Ref, NewInstance(typeof(FAFQueryMethodSelect)))
.SetProperty(
select,
"Annotations",
LocalMethod(
AnnotationUtil.MakeAnnotations(typeof(Attribute[]), _desc.Annotations, method, classScope)))
.SetProperty(
select,
"Processors",
FireAndForgetProcessorForgeExtensions.MakeArray(_desc.Processors, method, symbols, classScope))
.DeclareVar(
_classNameResultSetProcessor,
"rsp",
NewInstance(_classNameResultSetProcessor, symbols.GetAddInitSvc(method), Ref("statementFields")))
.SetProperty(select, "ResultSetProcessorFactoryProvider", Ref("rsp"))
.SetProperty(select, "QueryGraph", _desc.QueryGraph.Make(method, symbols, classScope))
.SetProperty(
select,
"WhereClause",
_desc.WhereClause == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluator(
_desc.WhereClause.Forge,
method,
GetType(),
classScope))
.SetProperty(
select,
"JoinSetComposerPrototype",
_desc.Joins == null ? ConstantNull() : _desc.Joins.Make(method, symbols, classScope))
.SetProperty(
select,
"ConsumerFilters",
ExprNodeUtilityCodegen.CodegenEvaluators(_desc.ConsumerFilters, method, GetType(), classScope))
.SetProperty(select, "ContextName", Constant(_desc.ContextName))
.SetProperty(
select,
"TableAccesses",
ExprTableEvalStrategyUtil.CodegenInitMap(
_desc.TableAccessForges,
GetType(),
method,
symbols,
classScope))
.SetProperty(select, "HasTableAccess", Constant(_desc.HasTableAccess))
.SetProperty(select, "IsDistinct", Constant(_desc.IsDistinct))
.MethodReturn(select);
}
public static void HandleTypesFromCurrentDomainWithAnnotation <T>(TypeHandleDelegate typeHandleDelegate) where T : Attribute
{
foreach (Type type in typesFromCurrentDomain)
{
if (!AnnotationUtil.IsAnnotationPresent <T>(type, true))
{
continue;
}
typeHandleDelegate(type);
}
}
public virtual bool IsEntityType(Type type)
{
if (type == null || type.IsPrimitive || type.IsEnum || primitiveTypes.Contains(type) || noEntityTypeExtendables.GetExtension(type))
{
return(false);
}
if (AnnotationUtil.IsAnnotationPresent <Embeddable>(type, false) || typeof(IImmutableType).IsAssignableFrom(type))
{
return(false);
}
return(true);
}
protected bool IsAnnotationPresentIntern <V>(Type type) where V : Attribute
{
if (type == null)
{
return(false);
}
if (AnnotationUtil.IsAnnotationPresent <V>(type, false))
{
return(true);
}
return(IsAnnotationPresentIntern <V>(type.BaseType));
}
public static EventUnderlyingType GetRepresentation(
Attribute[] annotations,
Configuration configs,
AssignedType assignedType)
{
switch (assignedType) {
// assigned type has priority
case AssignedType.OBJECTARRAY:
return EventUnderlyingType.OBJECTARRAY;
case AssignedType.MAP:
return EventUnderlyingType.MAP;
case AssignedType.AVRO:
return EventUnderlyingType.AVRO;
case AssignedType.JSON:
return EventUnderlyingType.JSON;
}
if (assignedType == AssignedType.VARIANT ||
assignedType != AssignedType.NONE) {
throw new IllegalStateException("Not handled by event representation: " + assignedType);
}
// annotation has second priority
var annotation = AnnotationUtil.FindAnnotation(annotations, typeof(EventRepresentationAttribute));
if (annotation != null) {
var eventRepresentation = (EventRepresentationAttribute) annotation;
return eventRepresentation.Value switch {
EventUnderlyingType.AVRO => EventUnderlyingType.AVRO,
EventUnderlyingType.JSON => EventUnderlyingType.JSON,
EventUnderlyingType.OBJECTARRAY => EventUnderlyingType.OBJECTARRAY,
EventUnderlyingType.MAP => EventUnderlyingType.MAP,
_ => throw new IllegalStateException("Unrecognized enum " + eventRepresentation.Value)
};
}
// use runtime-wide default
var configured = configs.Common.EventMeta.DefaultEventRepresentation;
return configured switch {
EventUnderlyingType.OBJECTARRAY => EventUnderlyingType.OBJECTARRAY,
EventUnderlyingType.MAP => EventUnderlyingType.MAP,
EventUnderlyingType.AVRO => EventUnderlyingType.AVRO,
EventUnderlyingType.JSON => EventUnderlyingType.JSON,
_ => EventUnderlyingType.MAP
};
}
}
} // end of namespace
public IReaderWriterLock GetStatementLock(String statementName, Attribute[] annotations, bool stateless)
{
bool foundNoLock = AnnotationUtil.FindAttribute(annotations, typeof(NoLockAttribute)) != null;
if (_disableLocking || foundNoLock || stateless)
{
return(ReaderWriterLockManager.VoidLock());
}
if (_fairlocks)
{
return(ReaderWriterLockManager.FairLock());
}
return(ReaderWriterLockManager.CreateDefaultLock());
}
protected IList <IAnnotationInfo <V> > FindAnnotations <V>(Type type, MethodInfo method) where V : Attribute
{
IList <IAnnotationInfo <V> > targetList = new List <IAnnotationInfo <V> >();
FindAnnotations <V>(type, targetList, true);
if (method != null)
{
IList <V> annotations = AnnotationUtil.GetAnnotations <V>(method, true);
for (int a = 0, size = annotations.Count; a < size; a++)
{
targetList.Add(new AnnotationInfo <V>(annotations[a], method));
}
}
return(targetList);
}
public EventTypeBusModifier GetBusModifierEventType(
StatementRawInfo raw,
string eventTypeName)
{
if (options.BusModifierEventType != null) {
var result = options.BusModifierEventType.Invoke(new BusModifierEventTypeContext(raw, eventTypeName));
if (result != null) {
return result.Value;
}
}
var busEventType = AnnotationUtil.HasAnnotation(raw.Annotations, typeof(BusEventTypeAttribute));
if (busEventType) {
return EventTypeBusModifier.BUS;
}
return config.BusModifierEventType;
}
private NameAccessModifier GetModifier(
Attribute[] annotations,
Func<CompilerOptions, NameAccessModifier?> optionsGet,
Func<ConfigurationCompilerByteCode, NameAccessModifier> configGet)
{
if (options != null) {
var result = optionsGet.Invoke(options);
if (result != null) {
return result.Value;
}
}
var isPrivate = AnnotationUtil.HasAnnotation(annotations, typeof(PrivateAttribute));
var isProtected = AnnotationUtil.HasAnnotation(annotations, typeof(ProtectedAttribute));
var isPublic = AnnotationUtil.HasAnnotation(annotations, typeof(PublicAttribute));
if (isPrivate) {
if (isProtected) {
throw new EPException("Encountered both the @private and the @protected annotation");
}
if (isPublic) {
throw new EPException("Encountered both the @private and the @public annotation");
}
}
else if (isProtected && isPublic) {
throw new EPException("Encountered both the @protected and the @public annotation");
}
if (isPrivate) {
return NameAccessModifier.PRIVATE;
}
if (isProtected) {
return NameAccessModifier.INTERNAL;
}
if (isPublic) {
return NameAccessModifier.PUBLIC;
}
return configGet.Invoke(config);
}
public void SearchAnnoationTest_NoResult()
{
string keywords = "ABCDEFGHIJKLMNOOPQRSTUVWXYZ";
Stopwatch time = new Stopwatch();
time.Start();
var result0 = AnnotationUtil.SearchAnnotation(keywords);
Assert.AreEqual(0, result0.Count);
var result1 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.Highlight);
Assert.AreEqual(0, result1.Count);
var result2 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.StickyNote);
Assert.AreEqual(0, result2.Count);
var result3 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.Orphan);
Assert.AreEqual(0, result3.Count);
var tempText = keywords;
}
public void SearchAnnoationTest_Regular()
{
string keywords = "A1";
Stopwatch time = new Stopwatch();
time.Start();
var result0 = AnnotationUtil.SearchAnnotation(keywords);
Assert.LessOrEqual(0, result0.Count);
var result1 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.Highlight);
Assert.LessOrEqual(0, result1.Count);
var result2 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.StickyNote);
Assert.LessOrEqual(0, result2.Count);
var result3 = AnnotationUtil.SearchAnnotation(keywords, AnnotationType.Orphan);
Assert.LessOrEqual(0, result3.Count);
var tempText = keywords;
}
protected override Object InterceptApplication(IInvocation invocation, Attribute annotation, Boolean?isAsyncBegin)
{
bool oldProcessServiceActive = processServiceActiveTL.Value;
if (oldProcessServiceActive || ProcessService == null || !AnnotationUtil.IsAnnotationPresent <ServiceClientAttribute>(invocation.Method.DeclaringType, false))
{
return(base.InterceptApplication(invocation, annotation, isAsyncBegin));
}
ISecurityScope[] securityScopes = SecurityScopeProvider.SecurityScopes;
IServiceDescription serviceDescription = SyncToAsyncUtil.CreateServiceDescription(ServiceName, invocation.Method, invocation.Arguments, securityScopes);
processServiceActiveTL.Value = true;
try
{
return(ProcessService.InvokeService(serviceDescription));
}
finally
{
processServiceActiveTL.Value = oldProcessServiceActive;
}
}
public IReaderWriterLock GetStatementLock(
string statementName,
Attribute[] annotations,
bool stateless,
StatementType statementType)
{
if (statementType.IsOnTriggerInfra()) {
throw new UnsupportedOperationException("Operation not available for statement type " + statementType);
}
bool foundNoLock = AnnotationUtil.FindAnnotation(annotations, typeof(NoLockAttribute)) != null;
if (disableLocking || foundNoLock || stateless) {
return new VoidReaderWriterLock();
//return new StatementAgentInstanceLockNoLockImpl(statementName);
} else if (fairlocks) {
return new FairReaderWriterLock();
}
else {
return new SlimReaderWriterLock();
}
}
protected override Statement MethodBlock(MethodInfo method)
{
Statement statement = base.MethodBlock(method);
return(new Statement(delegate()
{
if (!hasContextBeenRebuildForThisTest)
{
if (method == null || !AnnotationUtil.IsAnnotationPresent <IgnoreAttribute>(method, false))
{
IList <IAnnotationInfo <TestRebuildContext> > rebuildContextList = FindAnnotations <TestRebuildContext>(testClass);
if (rebuildContextList.Count > 0)
{
bool rebuildContext = ((TestRebuildContext)rebuildContextList[rebuildContextList.Count - 1].Annotation).Value;
if (rebuildContext)
{
RebuildContext(method);
hasContextBeenRebuildForThisTest = true;
isRebuildContextForThisTestRecommended = false;
}
}
if (method != null)
{
if (AnnotationUtil.IsAnnotationPresent <TestModule>(method, false) || AnnotationUtil.IsAnnotationPresent <TestFrameworkModule>(method, false) ||
AnnotationUtil.IsAnnotationPresent <TestProperties>(method, false))
{
RebuildContext(method);
hasContextBeenRebuildForThisTest = true;
isRebuildContextForThisTestRecommended = false;
}
}
}
}
if (beanContext == null || isRebuildContextForThisTestRecommended)
{
RebuildContext(method);
}
statement();
}));
}
protected Type[] GetModules(bool scanForFrameworkModule)
{
if (log.InfoEnabled)
{
log.Info("Looking for " + (scanForFrameworkModule ? "Ambeth" : "Application") + " bootstrap modules in classpath...");
}
IList <Type> bootstrapOrFrameworkModules = ClasspathScanner.ScanClassesAnnotatedWith(scanForFrameworkModule ? typeof(FrameworkModuleAttribute)
: typeof(BootstrapModuleAttribute));
List <Type> bootstrapModules = new List <Type>(bootstrapOrFrameworkModules.Count);
foreach (Type bootstrapOrFrameworkModule in bootstrapOrFrameworkModules)
{
if (scanForFrameworkModule && AnnotationUtil.IsAnnotationPresent <FrameworkModuleAttribute>(bootstrapOrFrameworkModule, false))
{
bootstrapModules.Add(bootstrapOrFrameworkModule);
}
else if (AnnotationUtil.IsAnnotationPresent <BootstrapModuleAttribute>(bootstrapOrFrameworkModule, false) &&
!AnnotationUtil.IsAnnotationPresent <FrameworkModuleAttribute>(bootstrapOrFrameworkModule, false))
{
bootstrapModules.Add(bootstrapOrFrameworkModule);
}
}
if (log.InfoEnabled)
{
log.Info("Found " + bootstrapModules.Count + (scanForFrameworkModule ? " Ambeth" : " Application")
+ " modules in classpath to include in bootstrap...");
bootstrapModules.Sort(delegate(Type o1, Type o2)
{
return(o1.FullName.CompareTo(o2.FullName));
});
for (int a = 0, size = bootstrapModules.Count; a < size; a++)
{
Type boostrapModule = bootstrapModules[a];
log.Info("Including " + boostrapModule.FullName);
}
}
return(bootstrapModules.ToArray());
}
public void PutAnnotations(ICustomAttributeProvider obj)
{
if (obj is MethodInfo)
{
MethodInfo m = (MethodInfo)obj;
Type[] parameters = new Type[m.GetParameters().Length];
for (int a = m.GetParameters().Length; a-- > 0;)
{
parameters[a] = m.GetParameters()[a].ParameterType;
}
Type baseType = m.DeclaringType.BaseType;
MethodInfo overriddenMethod = baseType != null?ReflectUtil.GetDeclaredMethod(true, baseType, m.ReturnType, m.Name, parameters) : null;
if (overriddenMethod != null)
{
PutAnnotations(overriddenMethod);
}
}
Object[] annotations = obj.GetCustomAttributes(true);
foreach (Object anno in annotations)
{
Attribute annotation = (Attribute)anno;
AttributeUsageAttribute attributeUsage = AnnotationUtil.GetAnnotation <AttributeUsageAttribute>(annotation.GetType(), true);
Type type = annotation.GetType();
if (this.annotations == null)
{
this.annotations = new LinkedHashMap <Type, Attribute[]>();
}
Attribute[] existingAttributes = this.annotations.Get(type);
if (existingAttributes == null)
{
existingAttributes = new Attribute[0];
}
Attribute[] newAttributes = new Attribute[existingAttributes.Length + 1];
Array.Copy(existingAttributes, newAttributes, existingAttributes.Length);
newAttributes[existingAttributes.Length] = annotation;
this.annotations.Put(type, newAttributes);
}
}
private void RunAssertionBuiltin(EPServiceProvider epService)
{
var stmtText = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"value\") select * from Bean";
var stmt = epService.EPAdministrator.CreateEPL(stmtText);
Assert.IsTrue(((EPStatementSPI)stmt).IsNameProvided);
TryAssertion(stmt);
stmt.Dispose();
var name = (NameAttribute)AnnotationUtil.FindAnnotation(stmt.Annotations, typeof(NameAttribute));
Assert.AreEqual("MyTestStmt", name.Value);
// try lowercase
var stmtTextLower = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"value\") select * from Bean";
stmt = epService.EPAdministrator.CreateEPL(stmtTextLower);
TryAssertion(stmt);
stmt.Dispose();
// try pattern
stmtText = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name='UserId', Value='value') every Bean";
stmt = epService.EPAdministrator.CreatePattern(stmtText);
TryAssertion(stmt);
stmt.Dispose();
stmtText = "@" + typeof(NameAttribute).FullName + "('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"value\") every Bean";
stmt = epService.EPAdministrator.CreatePattern(stmtText);
TryAssertion(stmt);
epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY') select * from Bean");
epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,DISABLE_RECLAIM_GROUP') select * from Bean");
epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY') select * from Bean");
epService.EPAdministrator.CreateEPL("@Hint(' iterate_only ') select * from Bean");
// test statement name override
stmtText = "@Name('MyAnnotatedName') select * from Bean";
stmt = epService.EPAdministrator.CreateEPL(stmtText, "MyABCStmt");
Assert.AreEqual("MyABCStmt", stmt.Name);
// hint tests
Assert.IsNull(HintEnum.DISABLE_RECLAIM_GROUP.GetHint(null));
Assert.IsNull(HintEnum.DISABLE_RECLAIM_GROUP.GetHint(new Attribute[0]));
var annos = epService.EPAdministrator.CreateEPL("@Hint('DISABLE_RECLAIM_GROUP') select * from Bean").Annotations;
Assert.AreEqual("DISABLE_RECLAIM_GROUP", HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annos).Value);
annos = epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY') select * from Bean").Annotations;
Assert.AreEqual("ITERATE_ONLY,ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY", HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annos).Value);
annos = epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,reclaim_group_aged=10') select * from Bean").Annotations;
var hint = HintEnum.RECLAIM_GROUP_AGED.GetHint(annos);
Assert.AreEqual("10", HintEnum.RECLAIM_GROUP_AGED.GetHintAssignedValue(hint));
annos = epService.EPAdministrator.CreateEPL("@Hint('reclaim_group_aged=11') select * from Bean").Annotations;
hint = HintEnum.RECLAIM_GROUP_AGED.GetHint(annos);
Assert.AreEqual("11", HintEnum.RECLAIM_GROUP_AGED.GetHintAssignedValue(hint));
annos = epService.EPAdministrator.CreateEPL("@Hint('Index(one, two)') select * from Bean").Annotations;
Assert.AreEqual("one, two", HintEnum.INDEX.GetHintAssignedValues(annos)[0]);
stmt.Dispose();
// NoLock
stmt = epService.EPAdministrator.CreateEPL("@NoLock select * from Bean");
Assert.IsNotNull(AnnotationUtil.FindAnnotation(stmt.Annotations, typeof(NoLockAttribute)));
Assert.AreEqual(1, AnnotationUtil.FindAnnotations(stmt.Annotations, typeof(NoLockAttribute)).Count);
stmt.Dispose();
}
public void TestBuiltin()
{
var configuration = SupportConfigFactory.GetConfiguration();
configuration.AddEventType("Bean", typeof(SupportBean).FullName);
configuration.AddImport(typeof(MyAnnotationNestableValuesAttribute).Namespace);
_epService = EPServiceProviderManager.GetDefaultProvider(configuration);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
var stmtText = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"Value\") select * from Bean";
var stmt = _epService.EPAdministrator.CreateEPL(stmtText);
Assert.IsTrue((((EPStatementSPI)stmt).IsNameProvided));
RunAssertion(stmt);
stmt.Dispose();
var name = (NameAttribute)AnnotationUtil.FindAnnotation(stmt.Annotations, typeof(NameAttribute));
Assert.AreEqual("MyTestStmt", name.Value);
// try lowercase
var stmtTextLower = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"Value\") select * from Bean";
stmt = _epService.EPAdministrator.CreateEPL(stmtTextLower);
RunAssertion(stmt);
stmt.Dispose();
// try pattern
stmtText = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name='UserId', Value='Value') every Bean";
stmt = _epService.EPAdministrator.CreatePattern(stmtText);
RunAssertion(stmt);
stmt.Dispose();
stmtText = "@Name('MyTestStmt') @Description('MyTestStmt description') @Tag(Name=\"UserId\", Value=\"Value\") every Bean";
stmt = _epService.EPAdministrator.CreatePattern(stmtText);
RunAssertion(stmt);
_epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY') select * from Bean");
_epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,DISABLE_RECLAIM_GROUP') select * from Bean");
_epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY') select * from Bean");
_epService.EPAdministrator.CreateEPL("@Hint(' iterate_only ') select * from Bean");
// test statement name override
stmtText = "@Name('MyAnnotatedName') select * from Bean";
stmt = _epService.EPAdministrator.CreateEPL(stmtText, "MyABCStmt");
Assert.AreEqual("MyABCStmt", stmt.Name);
// hint tests
Assert.IsNull(HintEnum.DISABLE_RECLAIM_GROUP.GetHint(null));
Assert.IsNull(HintEnum.DISABLE_RECLAIM_GROUP.GetHint(new Attribute[0]));
var annos =
_epService.EPAdministrator.CreateEPL("@Hint('DISABLE_RECLAIM_GROUP') select * from Bean").Annotations.ToArray();
Assert.AreEqual("DISABLE_RECLAIM_GROUP", HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annos).Value);
annos = _epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY') select * from Bean").Annotations.ToArray();
Assert.AreEqual("ITERATE_ONLY,ITERATE_ONLY,DISABLE_RECLAIM_GROUP,ITERATE_ONLY", HintEnum.DISABLE_RECLAIM_GROUP.GetHint(annos).Value);
annos = _epService.EPAdministrator.CreateEPL("@Hint('ITERATE_ONLY,reclaim_group_aged=10') select * from Bean").Annotations.ToArray();
var hint = HintEnum.RECLAIM_GROUP_AGED.GetHint(annos);
Assert.AreEqual("10", HintEnum.RECLAIM_GROUP_AGED.GetHintAssignedValue(hint));
annos = _epService.EPAdministrator.CreateEPL("@Hint('reclaim_group_aged=11') select * from Bean").Annotations.ToArray();
hint = HintEnum.RECLAIM_GROUP_AGED.GetHint(annos);
Assert.AreEqual("11", HintEnum.RECLAIM_GROUP_AGED.GetHintAssignedValue(hint));
annos = _epService.EPAdministrator.CreateEPL("@Hint('index(one, two)') select * from Bean").Annotations.ToArray();
Assert.AreEqual("one, two", HintEnum.INDEX.GetHintAssignedValues(annos)[0]);
// NoLock
stmt = _epService.EPAdministrator.CreateEPL("@NoLock select * from Bean");
Assert.NotNull(AnnotationUtil.FindAnnotation(stmt.Annotations.ToArray(), typeof(NoLockAttribute)));
Assert.AreEqual(1, AnnotationUtil.FindAttributes(stmt.Annotations.ToArray(), typeof(NoLockAttribute)).Count);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public static EventUnderlyingType GetRepresentation(
Attribute[] annotations,
ConfigurationInformation configs,
AssignedType assignedType)
{
// assigned type has priority
if (assignedType == AssignedType.OBJECTARRAY)
{
return(EventUnderlyingType.OBJECTARRAY);
}
else if (assignedType == AssignedType.MAP)
{
return(EventUnderlyingType.MAP);
}
else if (assignedType == AssignedType.AVRO)
{
return(EventUnderlyingType.AVRO);
}
if (assignedType == AssignedType.VARIANT ||
assignedType != AssignedType.NONE)
{
throw new IllegalStateException("Not handled by event representation: " + assignedType);
}
// annotation has second priority
var annotation = AnnotationUtil.FindAnnotation(annotations, typeof(EventRepresentationAttribute));
if (annotation != null)
{
EventRepresentationAttribute eventRepresentation = (EventRepresentationAttribute)annotation;
if (eventRepresentation.Value == EventUnderlyingType.AVRO)
{
return(EventUnderlyingType.AVRO);
}
else if (eventRepresentation.Value == EventUnderlyingType.OBJECTARRAY)
{
return(EventUnderlyingType.OBJECTARRAY);
}
else if (eventRepresentation.Value == EventUnderlyingType.MAP)
{
return(EventUnderlyingType.MAP);
}
else
{
throw new IllegalStateException("Unrecognized enum " + eventRepresentation.Value);
}
}
// use engine-wide default
EventUnderlyingType configured = configs.EngineDefaults.EventMeta.DefaultEventRepresentation;
if (configured == EventUnderlyingType.OBJECTARRAY)
{
return(EventUnderlyingType.OBJECTARRAY);
}
else if (configured == EventUnderlyingType.MAP)
{
return(EventUnderlyingType.MAP);
}
else if (configured == EventUnderlyingType.AVRO)
{
return(EventUnderlyingType.AVRO);
}
return(EventUnderlyingType.MAP);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
if (context.InputPorts.IsEmpty())
{
throw new ArgumentException("Select operator requires at least one input stream");
}
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException("Select operator requires one output stream but produces " + context.OutputPorts.Count + " streams");
}
DataFlowOpOutputPort portZero = context.OutputPorts[0];
if (portZero.OptionalDeclaredType != null && !portZero.OptionalDeclaredType.IsUnderlying)
{
_submitEventBean = true;
}
// determine adapter factories for each type
int numStreams = context.InputPorts.Count;
_adapterFactories = new EventBeanAdapterFactory[numStreams];
for (int i = 0; i < numStreams; i++)
{
EventType eventType = context.InputPorts.Get(i).TypeDesc.EventType;
_adapterFactories[i] = context.StatementContext.EventAdapterService.GetAdapterFactoryForType(eventType);
}
// Compile and prepare execution
//
StatementContext statementContext = context.StatementContext;
EPServicesContext servicesContext = context.ServicesContext;
AgentInstanceContext agentInstanceContext = context.AgentInstanceContext;
// validate
if (select.InsertIntoDesc != null)
{
throw new ExprValidationException("Insert-into clause is not supported");
}
if (select.SelectStreamSelectorEnum != SelectClauseStreamSelectorEnum.ISTREAM_ONLY)
{
throw new ExprValidationException("Selecting remove-stream is not supported");
}
ExprNodeSubselectDeclaredDotVisitor visitor = StatementSpecRawAnalyzer.WalkSubselectAndDeclaredDotExpr(select);
GroupByClauseExpressions groupByExpressions = GroupByExpressionHelper.GetGroupByRollupExpressions(
servicesContext.Container,
select.GroupByExpressions,
select.SelectClauseSpec,
select.HavingExprRootNode,
select.OrderByList,
visitor);
if (!visitor.Subselects.IsEmpty())
{
throw new ExprValidationException("Subselects are not supported");
}
IDictionary <int, FilterStreamSpecRaw> streams = new Dictionary <int, FilterStreamSpecRaw>();
for (int streamNum = 0; streamNum < select.StreamSpecs.Count; streamNum++)
{
var rawStreamSpec = select.StreamSpecs[streamNum];
if (!(rawStreamSpec is FilterStreamSpecRaw))
{
throw new ExprValidationException("From-clause must contain only streams and cannot contain patterns or other constructs");
}
streams.Put(streamNum, (FilterStreamSpecRaw)rawStreamSpec);
}
// compile offered streams
IList <StreamSpecCompiled> streamSpecCompileds = new List <StreamSpecCompiled>();
for (int streamNum = 0; streamNum < select.StreamSpecs.Count; streamNum++)
{
var filter = streams.Get(streamNum);
var inputPort = FindInputPort(filter.RawFilterSpec.EventTypeName, context.InputPorts);
if (inputPort == null)
{
throw new ExprValidationException(
string.Format("Failed to find stream '{0}' among input ports, input ports are {1}", filter.RawFilterSpec.EventTypeName, GetInputPortNames(context.InputPorts).Render(", ", "[]")));
}
var eventType = inputPort.Value.Value.TypeDesc.EventType;
var streamAlias = filter.OptionalStreamName;
var filterSpecCompiled = new FilterSpecCompiled(eventType, streamAlias, new IList <FilterSpecParam>[] { Collections.GetEmptyList <FilterSpecParam>() }, null);
var filterStreamSpecCompiled = new FilterStreamSpecCompiled(filterSpecCompiled, select.StreamSpecs[0].ViewSpecs, streamAlias, StreamSpecOptions.DEFAULT);
streamSpecCompileds.Add(filterStreamSpecCompiled);
}
// create compiled statement spec
SelectClauseSpecCompiled selectClauseCompiled = StatementLifecycleSvcUtil.CompileSelectClause(select.SelectClauseSpec);
// determine if snapshot output is needed
OutputLimitSpec outputLimitSpec = select.OutputLimitSpec;
_isOutputLimited = outputLimitSpec != null;
if (iterate)
{
if (outputLimitSpec != null)
{
throw new ExprValidationException("Output rate limiting is not supported with 'iterate'");
}
outputLimitSpec = new OutputLimitSpec(OutputLimitLimitType.SNAPSHOT, OutputLimitRateType.TERM);
}
var mergedAnnotations = AnnotationUtil.MergeAnnotations(statementContext.Annotations, context.OperatorAnnotations);
var orderByArray = OrderByItem.ToArray(select.OrderByList);
var outerJoinArray = OuterJoinDesc.ToArray(select.OuterJoinDescList);
var streamSpecArray = streamSpecCompileds.ToArray();
var compiled = new StatementSpecCompiled(null, null, null, null, null, null, null, SelectClauseStreamSelectorEnum.ISTREAM_ONLY,
selectClauseCompiled, streamSpecArray, outerJoinArray, select.FilterExprRootNode, select.HavingExprRootNode, outputLimitSpec,
orderByArray, ExprSubselectNode.EMPTY_SUBSELECT_ARRAY, ExprNodeUtility.EMPTY_DECLARED_ARR, ExprNodeUtility.EMPTY_SCRIPTS, select.ReferencedVariables,
select.RowLimitSpec, CollectionUtil.EMPTY_STRING_ARRAY, mergedAnnotations, null, null, null, null, null, null, null, null, null, groupByExpressions, null, null);
// create viewable per port
var viewables = new EPLSelectViewable[context.InputPorts.Count];
_viewablesPerPort = viewables;
foreach (var entry in context.InputPorts)
{
EPLSelectViewable viewable = new EPLSelectViewable(entry.Value.TypeDesc.EventType);
viewables[entry.Key] = viewable;
}
var activatorFactory = new ProxyViewableActivatorFactory
{
ProcCreateActivatorSimple = filterStreamSpec =>
{
EPLSelectViewable found = null;
foreach (EPLSelectViewable sviewable in viewables)
{
if (sviewable.EventType == filterStreamSpec.FilterSpec.FilterForEventType)
{
found = sviewable;
}
}
if (found == null)
{
throw new IllegalStateException("Failed to find viewable for filter");
}
EPLSelectViewable viewable = found;
return(new ProxyViewableActivator(
(agentInstanceContext2, isSubselect, isRecoveringResilient) =>
new ViewableActivationResult(
viewable,
new ProxyStopCallback(() => { }),
null,
null,
null,
false,
false,
null)));
}
};
// for per-row deliver, register select expression result callback
OutputProcessViewCallback optionalOutputProcessViewCallback = null;
if (!iterate && !_isOutputLimited)
{
_deliveryCallback = new EPLSelectDeliveryCallback();
optionalOutputProcessViewCallback = this;
}
// prepare
EPStatementStartMethodSelectDesc selectDesc = EPStatementStartMethodSelectUtil.Prepare(compiled, servicesContext, statementContext, false, agentInstanceContext, false, activatorFactory, optionalOutputProcessViewCallback, _deliveryCallback);
// start
_selectResult = (StatementAgentInstanceFactorySelectResult)selectDesc.StatementAgentInstanceFactorySelect.NewContext(agentInstanceContext, false);
// for output-rate-limited, register a dispatch view
if (_isOutputLimited)
{
_selectResult.FinalView.AddView(new EPLSelectUpdateDispatchView(this));
}
// assign strategies to expression nodes
EPStatementStartMethodHelperAssignExpr.AssignExpressionStrategies(
selectDesc,
_selectResult.OptionalAggegationService,
_selectResult.SubselectStrategies,
_selectResult.PriorNodeStrategies,
_selectResult.PreviousNodeStrategies,
null,
null,
_selectResult.TableAccessEvalStrategies);
EventType outputEventType = selectDesc.ResultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType;
_agentInstanceContext = agentInstanceContext;
return(new DataFlowOpInitializeResult(new GraphTypeDesc[] { new GraphTypeDesc(false, true, outputEventType) }));
}
public PropertyEntry(Type type, String propertyName)
{
this.propertyName = propertyName;
LinkedHashSet <String> propertyNames = new LinkedHashSet <String>();
propertyNames.Add(propertyName);
PropertyInfo prop = type.GetProperty(propertyName);
doesModifyToBeUpdated = !AnnotationUtil.IsAnnotationPresent <IgnoreToBeUpdated>(prop, false);
isParentChildSetter = AnnotationUtil.IsAnnotationPresent <ParentChild>(prop, false);
isAddedRemovedCheckNecessary = !prop.PropertyType.IsPrimitive && ImmutableTypeSet.GetUnwrappedType(prop.PropertyType) == null &&
!typeof(String).Equals(prop.PropertyType) && !prop.PropertyType.IsValueType;
EvaluateDependentProperties(type, prop, propertyNames);
while (true)
{
int startCount = propertyNames.Count;
foreach (String currPropertyName in new List <String>(propertyNames))
{
PropertyInfo currProp = type.GetProperty(currPropertyName);
if (currProp.CanWrite)
{
continue;
}
// Is is just an evaluating property which has to be re-evaluated because of the change on the current property
EvaluateDependentProperties(type, currProp, propertyNames);
}
if (startCount == propertyNames.Count)
{
break;
}
}
this.propertyNames = propertyNames.ToArray();
bool firesToBeCreatedPCE = false;
unknownValues = CreateArrayOfValues(UNKNOWN_VALUE, this.propertyNames.Length);
pceArgs = new PropertyChangedEventArgs[propertyNames.Count];
int index = 0;
foreach (String invokedPropertyName in propertyNames)
{
pceArgs[index] = new PropertyChangedEventArgs(invokedPropertyName);
index++;
firesToBeCreatedPCE |= "ToBeCreated".Equals(invokedPropertyName);
}
this.firesToBeCreatedPCE = firesToBeCreatedPCE;
if (prop.CanRead)
{
getDelegate = TypeUtility.GetMemberGetDelegate(type, ValueHolderIEC.GetGetterNameOfRelationPropertyWithNoInit(prop.Name), true);
if (getDelegate == null)
{
getDelegate = TypeUtility.GetMemberGetDelegate(type, prop.Name);
}
}
if (prop.CanWrite)
{
setDelegate = TypeUtility.GetMemberSetDelegate(type, ValueHolderIEC.GetSetterNameOfRelationPropertyWithNoInit(prop.Name), true);
if (setDelegate == null)
{
setDelegate = TypeUtility.GetMemberSetDelegate(type, prop.Name);
}
}
}
