private static void ValidateIndexPrecondition(
EventTableIndexMetadata indexMetadata,
ModuleIndexMeta index,
string deploymentId)
{
var imk = indexMetadata.GetIndexByName(index.IndexName);
var entry = indexMetadata.Indexes.Get(imk);
if (entry == null)
{
return;
}
var referring = indexMetadata.Indexes.Get(imk).ReferringDeployments;
if (referring != null && referring.Length > 0)
{
string first = null;
foreach (var referringeploymentId in referring)
{
if (!referringeploymentId.Equals(deploymentId))
{
first = referringeploymentId;
}
}
if (first != null)
{
throw MakeException(PathRegistryObjectType.INDEX, index.IndexName, first);
}
}
}
public NamedWindowRootViewInstance(
NamedWindowRootView rootView,
AgentInstanceContext agentInstanceContext,
EventTableIndexMetadata eventTableIndexMetadata)
{
this.rootView = rootView;
AgentInstanceContext = agentInstanceContext;
IndexRepository = new EventTableIndexRepository(eventTableIndexMetadata);
foreach (var entry in eventTableIndexMetadata.Indexes
) {
if (entry.Value.OptionalQueryPlanIndexItem != null) {
var index = EventTableUtil.BuildIndex(
agentInstanceContext,
0,
entry.Value.OptionalQueryPlanIndexItem,
rootView.EventType,
true,
entry.Key.IsUnique,
entry.Value.OptionalIndexName,
null,
false);
IndexRepository.AddIndex(
entry.Key,
new EventTableIndexRepositoryEntry(
entry.Value.OptionalIndexName,
entry.Value.OptionalIndexModuleName,
index));
}
}
}
private TableMetaData(
string tableName,
string tableModuleName,
NameAccessModifier tableVisibility,
string optionalContextName,
NameAccessModifier? optionalContextVisibility,
string optionalContextModule,
EventType internalEventType,
EventType publicEventType,
string[] keyColumns,
Type[] keyTypes,
int[] keyColNums,
IDictionary<string, TableMetadataColumn> columns,
int numMethodAggs,
IndexMultiKey keyIndexMultiKey,
EventTableIndexMetadata indexMetadata)
{
TableName = tableName;
TableModuleName = tableModuleName;
TableVisibility = tableVisibility;
OptionalContextName = optionalContextName;
OptionalContextVisibility = optionalContextVisibility;
OptionalContextModule = optionalContextModule;
InternalEventType = internalEventType;
PublicEventType = publicEventType;
KeyColumns = keyColumns;
KeyTypes = keyTypes;
KeyColNums = keyColNums;
Columns = columns;
NumMethodAggs = numMethodAggs;
KeyIndexMultiKey = keyIndexMultiKey;
IndexMetadata = indexMetadata;
}
public void RegisterIndex(
IndexCompileTimeKey indexKey,
IndexDetail indexDetail)
{
EventTableIndexMetadata indexMetadata = null;
if (indexKey.IsNamedWindow) {
NamedWindowMetaData localNamedWindow = moduleNamedWindows.Get(indexKey.InfraName);
if (localNamedWindow != null) {
indexMetadata = localNamedWindow.IndexMetadata;
}
else {
if (indexKey.Visibility == NameAccessModifier.PUBLIC) {
NamedWindowMetaData pathNamedWindow = pathNamedWindows.GetWithModule(
indexKey.InfraName,
indexKey.InfraModuleName);
if (pathNamedWindow != null) {
indexMetadata = pathNamedWindow.IndexMetadata;
}
}
}
if (indexMetadata == null) {
throw new EPException("Failed to find named window '" + indexKey.InfraName + "'");
}
}
else {
TableMetaData localTable = moduleTables.Get(indexKey.InfraName);
if (localTable != null) {
indexMetadata = localTable.IndexMetadata;
}
else {
if (indexKey.Visibility == NameAccessModifier.PUBLIC) {
TableMetaData pathTable = pathTables.GetWithModule(
indexKey.InfraName,
indexKey.InfraModuleName);
if (pathTable != null) {
indexMetadata = pathTable.IndexMetadata;
}
}
}
if (indexMetadata == null) {
throw new EPException("Failed to find table '" + indexKey.InfraName + "'");
}
}
try {
indexMetadata.AddIndexExplicit(
false,
indexDetail.IndexMultiKey,
indexKey.IndexName,
indexKey.InfraModuleName,
indexDetail.QueryPlanIndexItem,
"");
}
catch (ExprValidationException ex) {
throw new EPException(ex.Message, ex);
}
}
private static void ValidateIndexPrecondition(
int rolloutItemNumber,
EventTableIndexMetadata indexMetadata,
ModuleIndexMeta index)
{
if (indexMetadata.GetIndexByName(index.IndexName) != null)
{
var ex = new PathExceptionAlreadyRegistered(index.IndexName, PathRegistryObjectType.INDEX, index.IndexModuleName);
throw new EPDeployPreconditionException(ex.Message, ex, rolloutItemNumber);
}
}
public NamedWindowImpl(
NamedWindowMetaData metadata,
EPStatementInitServices services)
{
rootView = new NamedWindowRootView(metadata);
eventTableIndexMetadataRepo = metadata.IndexMetadata;
tailView = services.NamedWindowFactoryService.CreateNamedWindowTailView(
metadata.EventType,
metadata.IsChildBatching,
services,
metadata.ContextName);
}
// what are the dependencies that the given deployment provides to other modules?
public static EPDeploymentDependencyProvided GetDependenciesProvided(
string selfDeploymentId,
EPServicesPath paths,
DeploymentLifecycleService deploymentLifecycleService)
{
DeploymentInternal selfDeployment = deploymentLifecycleService.GetDeploymentById(selfDeploymentId);
if (selfDeployment == null)
{
return(null);
}
IList <EPDeploymentDependencyProvided.Item> dependencies = new List <EPDeploymentDependencyProvided.Item>(4);
string moduleName = selfDeployment.ModuleProvider.ModuleName;
HandleProvided(selfDeployment.PathNamedWindows, EPObjectType.NAMEDWINDOW, paths.NamedWindowPathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathTables, EPObjectType.TABLE, paths.TablePathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathVariables, EPObjectType.VARIABLE, paths.VariablePathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathContexts, EPObjectType.CONTEXT, paths.ContextPathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathEventTypes, EPObjectType.EVENTTYPE, paths.EventTypePathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathExprDecls, EPObjectType.EXPRESSION, paths.ExprDeclaredPathRegistry, moduleName, dependencies, name => name);
HandleProvided(selfDeployment.PathScripts, EPObjectType.SCRIPT, paths.ScriptPathRegistry, moduleName, dependencies, SCRIPT_OBJECTNAME);
HandleProvided(
selfDeployment.PathClassProvideds,
EPObjectType.CLASSPROVIDED,
paths.ClassProvidedPathRegistry,
moduleName,
dependencies,
name => name);
foreach (ModuleIndexMeta objectName in selfDeployment.PathIndexes)
{
EventTableIndexMetadata indexMetadata = GetIndexMetadata(objectName, moduleName, paths);
if (indexMetadata == null)
{
continue;
}
EventTableIndexMetadataEntry meta = indexMetadata.GetIndexEntryByName(objectName.IndexName);
if (meta != null && meta.ReferringDeployments != null && meta.ReferringDeployments.Length > 0)
{
ISet <string> referred = new HashSet <string>(Arrays.AsList(meta.ReferringDeployments));
referred.Remove(selfDeploymentId);
if (!referred.IsEmpty())
{
dependencies.Add(new EPDeploymentDependencyProvided.Item(EPObjectType.INDEX, INDEX_OBJECTNAME.Invoke(objectName), referred));
}
}
}
return(new EPDeploymentDependencyProvided(dependencies));
}
public NamedWindowMetaData(
EventType eventType,
string namedWindowModuleName,
string contextName,
string[] uniqueness,
bool isChildBatching,
bool isEnableIndexShare,
EventType optionalEventTypeAs,
bool virtualDataWindow)
{
EventType = eventType;
NamedWindowModuleName = namedWindowModuleName;
ContextName = contextName;
Uniqueness = uniqueness;
IsChildBatching = isChildBatching;
IsEnableIndexShare = isEnableIndexShare;
OptionalEventTypeAs = optionalEventTypeAs;
IndexMetadata = new EventTableIndexMetadata();
IsVirtualDataWindow = virtualDataWindow;
}
public NamedWindowRootViewInstance(NamedWindowRootView rootView, AgentInstanceContext agentInstanceContext, EventTableIndexMetadata eventTableIndexMetadata)
{
_rootView = rootView;
_agentInstanceContext = agentInstanceContext;
_indexRepository = new EventTableIndexRepository();
foreach (KeyValuePair <IndexMultiKey, EventTableIndexMetadataEntry> entry in eventTableIndexMetadata.Indexes)
{
if (entry.Value.QueryPlanIndexItem != null)
{
EventTable index = EventTableUtil.BuildIndex(agentInstanceContext, 0, entry.Value.QueryPlanIndexItem, rootView.EventType, true, entry.Key.IsUnique, entry.Value.OptionalIndexName, null, false);
_indexRepository.AddIndex(entry.Key, new EventTableIndexRepositoryEntry(entry.Value.OptionalIndexName, index));
}
}
_tablePerMultiLookup = new Dictionary <SubordWMatchExprLookupStrategy, EventTable[]>();
}
// what are the dependencies that the given deployment consumes from other modules?
public static EPDeploymentDependencyConsumed GetDependenciesConsumed(
string selfDeploymentId,
EPServicesPath paths,
DeploymentLifecycleService deploymentLifecycleService)
{
var selfDeployment = deploymentLifecycleService.GetDeploymentById(selfDeploymentId);
if (selfDeployment == null)
{
return(null);
}
string[] consumedDeploymentIds = selfDeployment.DeploymentIdDependencies;
var consumed = new List <EPDeploymentDependencyConsumed.Item>(4);
foreach (string providerDeploymentId in consumedDeploymentIds)
{
var providingDeployment = deploymentLifecycleService.GetDeploymentById(providerDeploymentId);
if (providingDeployment == null)
{
continue;
}
string moduleName = providingDeployment.ModuleProvider.ModuleName;
HandleConsumed(
providerDeploymentId,
providingDeployment.PathNamedWindows,
EPObjectType.NAMEDWINDOW,
paths.NamedWindowPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathTables,
EPObjectType.TABLE,
paths.TablePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathVariables,
EPObjectType.VARIABLE,
paths.VariablePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathContexts,
EPObjectType.CONTEXT,
paths.ContextPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathEventTypes,
EPObjectType.EVENTTYPE,
paths.EventTypePathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathExprDecls,
EPObjectType.EXPRESSION,
paths.ExprDeclaredPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathScripts,
EPObjectType.SCRIPT,
paths.ScriptPathRegistry,
moduleName,
selfDeploymentId,
consumed,
SCRIPT_OBJECTNAME);
HandleConsumed(
providerDeploymentId,
providingDeployment.PathClassProvideds,
EPObjectType.CLASSPROVIDED,
paths.ClassProvidedPathRegistry,
moduleName,
selfDeploymentId,
consumed,
name => name);
foreach (ModuleIndexMeta objectName in providingDeployment.PathIndexes)
{
EventTableIndexMetadata indexMetadata = GetIndexMetadata(objectName, moduleName, paths);
if (indexMetadata == null)
{
continue;
}
EventTableIndexMetadataEntry meta = indexMetadata.GetIndexEntryByName(objectName.IndexName);
if (meta != null && meta.ReferringDeployments != null && meta.ReferringDeployments.Length > 0)
{
bool found = false;
foreach (string dep in meta.ReferringDeployments)
{
if (dep.Equals(selfDeploymentId))
{
found = true;
break;
}
}
if (found)
{
consumed.Add(
new EPDeploymentDependencyConsumed.Item(providerDeploymentId, EPObjectType.INDEX, INDEX_OBJECTNAME.Invoke(objectName)));
}
}
}
}
return(new EPDeploymentDependencyConsumed(consumed));
}
