/**
* Check if the named node type is in use in any workspace in the repository
*
* @param nodeTypeName the name of the node type to check
* @return true if at least one node is using that type; false otherwise
* @throws InvalidQueryException if there is an error searching for uses of the named node type
*/
boolean isNodeTypeInUse(Name nodeTypeName) throws InvalidQueryException {
String nodeTypeString = nodeTypeName.getString(context.getNamespaceRegistry());
String expression = "SELECT * from [" + nodeTypeString + "] LIMIT 1";
TypeSystem typeSystem = context.getValueFactories().getTypeSystem();
// Parsing must be done now ...
QueryCommand command = queryParser.parseQuery(expression, typeSystem);
assert command != null : "Could not parse " + expression;
Schemata schemata = getRepositorySchemata();
// Now query the entire repository for any nodes that use this node type ...
RepositoryCache repoCache = repository.repositoryCache();
RepositoryQueryManager queryManager = repository.queryManager();
Set<String> workspaceNames = repoCache.getWorkspaceNames();
Map<String, NodeCache> overridden = null;
NodeTypes nodeTypes = repository.nodeTypeManager().getNodeTypes();
RepositoryIndexes indexDefns = repository.queryManager().getIndexes();
CancellableQuery query =
queryManager.query(
context,
repoCache,
workspaceNames,
overridden,
command,
schemata,
indexDefns,
nodeTypes,
null,
null);
try {
QueryResults result = query.execute();
if (result.isEmpty()) return false;
if (result.getRowCount() < 0) {
// Try to get the first row ...
NodeSequence seq = result.getRows();
Batch batch = seq.nextBatch();
while (batch != null) {
if (batch.hasNext()) return true;
// It's not common for the first batch may be empty, but it's possible. So try the next
// batch ...
batch = seq.nextBatch();
}
return false;
}
return result.getRowCount() > 0;
} catch (RepositoryException e) {
logger.error(e, JcrI18n.errorCheckingNodeTypeUsage, nodeTypeName, e.getLocalizedMessage());
return true;
}
}
RepositoryNodeTypeManager with(
JcrRepository.RunningState repository,
boolean includeColumnsForInheritedProperties,
boolean includePseudoColumnsInSelectStar) {
assert this.systemWorkspaceName.equals(repository.repositoryCache().getSystemWorkspaceName());
PathFactory pathFactory = repository.context().getValueFactories().getPathFactory();
Path nodeTypesPath = pathFactory.createAbsolutePath(JcrLexicon.SYSTEM, JcrLexicon.NODE_TYPES);
assert this.nodeTypesPath.equals(nodeTypesPath);
RepositoryNodeTypeManager result =
new RepositoryNodeTypeManager(
repository, includeColumnsForInheritedProperties, includePseudoColumnsInSelectStar);
// Now copy the node types from this cache into the new manager's cache ...
// (If we didn't do this, we'd have to refresh from the system storage)
result.nodeTypesCache = result.nodeTypesCache.with(this.nodeTypesCache.getAllNodeTypes());
return result;
}
private JcrPropertyDefinition propertyDefinitionFrom(PropertyDefinition propDefn)
throws RepositoryException {
Name propertyName = nameFactory.create(propDefn.getName());
int onParentVersionBehavior = propDefn.getOnParentVersion();
int requiredType = propDefn.getRequiredType();
boolean mandatory = propDefn.isMandatory();
boolean multiple = propDefn.isMultiple();
boolean autoCreated = propDefn.isAutoCreated();
boolean isProtected = propDefn.isProtected();
boolean fullTextSearchable = propDefn.isFullTextSearchable();
boolean queryOrderable = propDefn.isQueryOrderable();
Value[] defaultValues = propDefn.getDefaultValues();
JcrValue[] jcrDefaultValues = null;
if (defaultValues != null) {
jcrDefaultValues = new JcrValue[defaultValues.length];
for (int i = 0; i != defaultValues.length; ++i) {
Value value = defaultValues[i];
jcrDefaultValues[i] = new JcrValue(this.context.getValueFactories(), value);
}
}
String[] valueConstraints = propDefn.getValueConstraints();
String[] queryOperators = propDefn.getAvailableQueryOperators();
if (valueConstraints == null) valueConstraints = new String[0];
NodeKey prototypeKey = repository.repositoryCache().getSystemKey();
return new JcrPropertyDefinition(
this.context,
null,
prototypeKey,
propertyName,
onParentVersionBehavior,
autoCreated,
mandatory,
isProtected,
jcrDefaultValues,
requiredType,
valueConstraints,
multiple,
fullTextSearchable,
queryOrderable,
queryOperators);
}
private JcrNodeType nodeTypeFrom(NodeTypeDefinition nodeType, List<JcrNodeType> supertypes)
throws RepositoryException {
PropertyDefinition[] propDefns = nodeType.getDeclaredPropertyDefinitions();
NodeDefinition[] childDefns = nodeType.getDeclaredChildNodeDefinitions();
List<JcrPropertyDefinition> properties = new ArrayList<JcrPropertyDefinition>();
List<JcrNodeDefinition> childNodes = new ArrayList<JcrNodeDefinition>();
if (propDefns != null) {
for (PropertyDefinition propDefn : propDefns) {
properties.add(propertyDefinitionFrom(propDefn));
}
}
if (childDefns != null) {
for (NodeDefinition childNodeDefn : childDefns) {
childNodes.add(childNodeDefinitionFrom(childNodeDefn));
}
}
Name name = nameFactory.create(nodeType.getName());
Name primaryItemName = nameFactory.create(nodeType.getPrimaryItemName());
boolean mixin = nodeType.isMixin();
boolean isAbstract = nodeType.isAbstract();
boolean queryable = nodeType.isQueryable();
boolean orderableChildNodes = nodeType.hasOrderableChildNodes();
NodeKey prototypeKey = repository.repositoryCache().getSystemKey();
return new JcrNodeType(
prototypeKey,
this.context,
null,
this,
name,
supertypes,
primaryItemName,
childNodes,
properties,
mixin,
isAbstract,
queryable,
orderableChildNodes);
}
private JcrNodeDefinition childNodeDefinitionFrom(NodeDefinition childNodeDefn) {
Name childNodeName = nameFactory.create(childNodeDefn.getName());
Name defaultPrimaryTypeName = nameFactory.create(childNodeDefn.getDefaultPrimaryTypeName());
int onParentVersion = childNodeDefn.getOnParentVersion();
boolean mandatory = childNodeDefn.isMandatory();
boolean allowsSns = childNodeDefn.allowsSameNameSiblings();
boolean autoCreated = childNodeDefn.isAutoCreated();
boolean isProtected = childNodeDefn.isProtected();
Name[] requiredTypes;
String[] requiredTypeNames = childNodeDefn.getRequiredPrimaryTypeNames();
if (requiredTypeNames != null) {
List<Name> names = new ArrayList<Name>(requiredTypeNames.length);
for (String typeName : requiredTypeNames) {
names.add(nameFactory.create(typeName));
}
requiredTypes = names.toArray(new Name[names.size()]);
} else {
requiredTypes = new Name[0];
}
NodeKey prototypeKey = repository.repositoryCache().getSystemKey();
return new JcrNodeDefinition(
this.context,
null,
prototypeKey,
childNodeName,
onParentVersion,
autoCreated,
mandatory,
isProtected,
allowsSns,
defaultPrimaryTypeName,
requiredTypes);
}
protected ScanningTasks notify(ChangeSet changeSet) {
if (changeSet.getWorkspaceName() == null) {
// This is a change to the workspaces or repository metadata ...
// Refresh the index definitions ...
RepositoryIndexes indexes = readIndexDefinitions();
ScanningTasks feedback = new ScanningTasks();
if (!indexes.getIndexDefinitions().isEmpty()) {
// Build up the names of the added and removed workspace names ...
Set<String> addedWorkspaces = new HashSet<>();
Set<String> removedWorkspaces = new HashSet<>();
for (Change change : changeSet) {
if (change instanceof WorkspaceAdded) {
WorkspaceAdded added = (WorkspaceAdded) change;
addedWorkspaces.add(added.getWorkspaceName());
} else if (change instanceof WorkspaceRemoved) {
WorkspaceRemoved removed = (WorkspaceRemoved) change;
removedWorkspaces.add(removed.getWorkspaceName());
}
}
if (!addedWorkspaces.isEmpty() || !removedWorkspaces.isEmpty()) {
// Figure out which providers need to be called, and which definitions go with those
// providers ...
Map<String, List<IndexDefinition>> defnsByProvider = new HashMap<>();
for (IndexDefinition defn : indexes.getIndexDefinitions().values()) {
String providerName = defn.getProviderName();
List<IndexDefinition> defns = defnsByProvider.get(providerName);
if (defns == null) {
defns = new ArrayList<>();
defnsByProvider.put(providerName, defns);
}
defns.add(defn);
}
// Then for each provider ...
for (Map.Entry<String, List<IndexDefinition>> entry : defnsByProvider.entrySet()) {
String providerName = entry.getKey();
WorkspaceIndexChanges changes =
new WorkspaceIndexChanges(entry.getValue(), addedWorkspaces, removedWorkspaces);
IndexProvider provider = providers.get(providerName);
if (provider == null) continue;
provider.notify(
changes,
repository.changeBus(),
repository.nodeTypeManager(),
repository.repositoryCache().getWorkspaceNames(),
feedback.forProvider(providerName));
}
}
}
return feedback;
}
if (!systemWorkspaceName.equals(changeSet.getWorkspaceName())) {
// The change does not affect the 'system' workspace, so skip it ...
return null;
}
// It is simple to listen to all local and remote changes. Therefore, any changes made locally
// to the index definitions
// will be propagated through the cached representation via this listener.
AtomicReference<Map<Name, IndexChangeInfo>> changesByProviderName = new AtomicReference<>();
for (Change change : changeSet) {
if (change instanceof NodeAdded) {
NodeAdded added = (NodeAdded) change;
Path addedPath = added.getPath();
if (indexesPath.isAncestorOf(addedPath)) {
// Get the name of the affected provider ...
Name providerName = addedPath.getSegment(2).getName();
if (addedPath.size() > 3) {
// Adding an index (or column definition), but all we care about is the name of the
// index
Name indexName = addedPath.getSegment(3).getName();
changeInfoForProvider(changesByProviderName, providerName).changed(indexName);
}
}
} else if (change instanceof NodeRemoved) {
NodeRemoved removed = (NodeRemoved) change;
Path removedPath = removed.getPath();
if (indexesPath.isAncestorOf(removedPath)) {
// Get the name of the affected provider ...
Name providerName = removedPath.getSegment(2).getName();
if (removedPath.size() > 4) {
// It's a column definition being removed, so the index is changed ...
Name indexName = removedPath.getSegment(3).getName();
changeInfoForProvider(changesByProviderName, providerName).removed(indexName);
} else if (removedPath.size() > 3) {
// Removing an index (or column definition), but all we care about is the name of the
// index
Name indexName = removedPath.getSegment(3).getName();
changeInfoForProvider(changesByProviderName, providerName).removed(indexName);
} else if (removedPath.size() == 3) {
// The whole provider was removed ...
changeInfoForProvider(changesByProviderName, providerName).removedAll();
}
}
} else if (change instanceof PropertyChanged) {
PropertyChanged propChanged = (PropertyChanged) change;
Path changedPath = propChanged.getPathToNode();
if (indexesPath.isAncestorOf(changedPath)) {
if (changedPath.size() > 3) {
// Adding an index (or column definition), but all we care about is the name of the
// index
Name providerName = changedPath.getSegment(2).getName();
Name indexName = changedPath.getSegment(3).getName();
changeInfoForProvider(changesByProviderName, providerName).changed(indexName);
}
}
} // we don't care about node moves (don't happen) or property added/removed (handled by node
// add/remove)
}
if (changesByProviderName.get() == null || changesByProviderName.get().isEmpty()) {
// No changes to the indexes ...
return null;
}
// Refresh the index definitions ...
RepositoryIndexes indexes = readIndexDefinitions();
// And notify the affected providers ...
StringFactory strings = context.getValueFactories().getStringFactory();
ScanningTasks feedback = new ScanningTasks();
for (Map.Entry<Name, IndexChangeInfo> entry : changesByProviderName.get().entrySet()) {
String providerName = strings.create(entry.getKey());
IndexProvider provider = providers.get(providerName);
if (provider == null) continue;
IndexChanges changes = new IndexChanges();
IndexChangeInfo info = entry.getValue();
if (info.removedAll) {
// Get all of the definitions for this provider ...
for (IndexDefinition defn : indexes.getIndexDefinitions().values()) {
if (defn.getProviderName().equals(providerName)) changes.remove(defn.getName());
}
}
// Others might have been added or changed after the existing ones were removed ...
for (Name name : info.removedIndexes) {
changes.remove(strings.create(name));
}
for (Name name : info.changedIndexes) {
IndexDefinition defn = indexes.getIndexDefinitions().get(strings.create(name));
if (defn != null) changes.change(defn);
}
// Notify the provider ...
try {
provider.notify(
changes,
repository.changeBus(),
repository.nodeTypeManager(),
repository.repositoryCache().getWorkspaceNames(),
feedback.forProvider(providerName));
} catch (RuntimeException e) {
logger.error(
e,
JcrI18n.errorNotifyingProviderOfIndexChanges,
providerName,
repository.name(),
e.getMessage());
}
}
// Finally swap the snapshot of indexes ...
this.indexes = indexes;
return feedback;
}
/**
* Initialize this manager by calling {@link IndexProvider#initialize()} on each of the
* currently-registered providers.
*
* @return the information about the portions of the repository that need to be scanned to
* (re)build indexes; null if no scanning is required
*/
protected synchronized ScanningTasks initialize() {
if (initialized.get()) {
// nothing to do ...
return null;
}
// Initialize each of the providers, removing any that are not properly initialized ...
for (Iterator<Map.Entry<String, IndexProvider>> providerIter = providers.entrySet().iterator();
providerIter.hasNext(); ) {
IndexProvider provider = providerIter.next().getValue();
try {
doInitialize(provider);
} catch (Throwable t) {
if (t.getCause() != null) {
t = t.getCause();
}
repository.error(
t,
JcrI18n.unableToInitializeIndexProvider,
provider.getName(),
repository.name(),
t.getMessage());
providerIter.remove();
}
}
// Re-read the index definitions in case there were disabled index definitions that used the
// now-available provider ...
RepositoryIndexes indexes = readIndexDefinitions();
// Notify the providers of all the index definitions (which we'll treat as "new" since we're
// just starting up) ...
ScanningTasks feedback = new ScanningTasks();
for (Iterator<Map.Entry<String, IndexProvider>> providerIter = providers.entrySet().iterator();
providerIter.hasNext(); ) {
IndexProvider provider = providerIter.next().getValue();
if (provider == null) continue;
final String providerName = provider.getName();
IndexChanges changes = new IndexChanges();
for (IndexDefinition indexDefn : indexes.getIndexDefinitions().values()) {
if (!providerName.equals(indexDefn.getProviderName())) continue;
changes.change(indexDefn);
}
// Even if there are no definitions, we still want to notify each of the providers ...
try {
provider.notify(
changes,
repository.changeBus(),
repository.nodeTypeManager(),
repository.repositoryCache().getWorkspaceNames(),
feedback.forProvider(providerName));
} catch (RuntimeException e) {
logger.error(
e,
JcrI18n.errorNotifyingProviderOfIndexChanges,
providerName,
repository.name(),
e.getMessage());
}
}
// Refresh the index writer ...
refreshIndexWriter();
initialized.set(true);
return feedback;
}
