/**
   * 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;
    }
  }
Example #2
0
 /**
  * Load all of the rows from the supplied sequence into the buffer.
  *
  * @param sequence the node sequence; may not be null
  * @param extractor the extractor for the sortable value; may not be null
  * @param rowsWithNullKey the buffer into which should be placed all rows for which the extracted
  *     key value is null; may be null if these are not to be kept
  * @return the size of the first batch, or 0 if there are no rows found
  */
 protected int loadAll(
     NodeSequence sequence,
     ExtractFromRow extractor,
     DistinctBuffer<BufferedRow> rowsWithNullKey) {
   // Put all of the batches from the sequence into the buffer
   Batch batch = sequence.nextBatch();
   int batchSize = 0;
   Object value = null;
   while (batch != null && batchSize == 0) {
     while (batch.hasNext()) {
       batch.nextRow();
       value = extractor.getValueInRow(batch);
       if (value instanceof Object[]) {
         // Put each of the values in the buffer ...
         for (Object v : (Object[]) value) {
           buffer.put(v, createRow(batch));
         }
       } else if (value != null) {
         buffer.put(value, createRow(batch));
       } else if (rowsWithNullKey != null) {
         rowsWithNullKey.addIfAbsent(createRow(batch));
       }
       ++batchSize;
     }
     batch = sequence.nextBatch();
   }
   while (batch != null) {
     while (batch.hasNext()) {
       batch.nextRow();
       value = extractor.getValueInRow(batch);
       if (value instanceof Object[]) {
         // Put each of the values in the buffer ...
         for (Object v : (Object[]) value) {
           buffer.put(v, createRow(batch));
         }
       } else if (value != null) {
         buffer.put(value, createRow(batch));
       } else if (rowsWithNullKey != null) {
         rowsWithNullKey.addIfAbsent(createRow(batch));
       }
     }
     batch = sequence.nextBatch();
   }
   return batchSize;
 }
Example #3
0
  @SuppressWarnings("unchecked")
  protected BufferingSequence(
      String workspaceName,
      NodeSequence delegate,
      ExtractFromRow extractor,
      BufferManager bufferMgr,
      CachedNodeSupplier nodeCache,
      boolean pack,
      boolean useHeap,
      boolean allowDuplicates) {
    super(delegate);
    assert extractor != null;
    this.workspaceName = workspaceName;
    this.width = delegate.width();
    this.cache = nodeCache;
    this.extractor = extractor;

    // Set up the row factory based upon the width of the delegate sequence...
    this.rowFactory = BufferedRows.serializer(nodeCache, width);

    // Set up the buffer ...
    SortingBuffer<Object, BufferedRow> buffer = null;
    TypeFactory<?> keyType = extractor.getType();
    if (allowDuplicates) {
      @SuppressWarnings("rawtypes")
      Serializer<? extends Comparable> keySerializer =
          (Serializer<? extends Comparable<?>>) bufferMgr.serializerFor(keyType);
      buffer =
          bufferMgr
              .createSortingWithDuplicatesBuffer(
                  keySerializer,
                  extractor.getType().getComparator(),
                  (BufferedRowFactory<BufferedRow>) rowFactory)
              .keepSize(true)
              .useHeap(useHeap)
              .make();
    } else {
      BTreeKeySerializer<Object> keySerializer =
          (BTreeKeySerializer<Object>) bufferMgr.bTreeKeySerializerFor(keyType, pack);
      if (keySerializer instanceof KeySerializerWithComparator) {
        keySerializer =
            ((KeySerializerWithComparator<Object>) keySerializer)
                .withComparator(extractor.getType().getComparator());
      }
      buffer =
          bufferMgr
              .createSortingBuffer(keySerializer, (BufferedRowFactory<BufferedRow>) rowFactory)
              .keepSize(true)
              .useHeap(useHeap)
              .make();
    }
    this.buffer = buffer;
  }
Example #4
0
  protected Batch batchFrom(final Iterator<BufferedRow> rows, final long maxBatchSize) {
    if (rows == null || !rows.hasNext()) return null;
    if (maxBatchSize == 0 || remainingRowCount.get() <= 0)
      return NodeSequence.emptyBatch(workspaceName, this.width);
    final long rowsInBatch = Math.min(maxBatchSize, remainingRowCount.get());
    rowsLeftInBatch.set(rowsInBatch);
    return new Batch() {
      private BufferedRow current;

      @Override
      public int width() {
        return width;
      }

      @Override
      public long rowCount() {
        return rowsInBatch;
      }

      @Override
      public String getWorkspaceName() {
        return workspaceName;
      }

      @Override
      public boolean isEmpty() {
        return rowsInBatch <= 0;
      }

      @Override
      public boolean hasNext() {
        return rowsLeftInBatch.get() > 0 && rows.hasNext();
      }

      @Override
      public void nextRow() {
        current = rows.next();
        remainingRowCount.decrementAndGet();
        rowsLeftInBatch.decrementAndGet();
      }

      @Override
      public CachedNode getNode() {
        return current.getNode();
      }

      @Override
      public CachedNode getNode(int index) {
        return current.getNode(index);
      }

      @Override
      public float getScore() {
        return current.getScore();
      }

      @Override
      public float getScore(int index) {
        return current.getScore(index);
      }

      @Override
      public String toString() {
        return "(buffered-batch size=" + rowsInBatch + " )";
      }
    };
  }