private List<IndexInfo> loadIndexes(RepositoryInfo repo) { String repoId = repo.getId(); if (null == repoId) { return Lists.newArrayList(); } Repository geogig; try { geogig = RepositoryManager.get().getRepository(repoId); return geogig.indexDatabase().getIndexInfos(); } catch (Exception e) { LOGGER.warn("Failed to load indexes for repository", e); } return Lists.newArrayList(); }
private Optional<Index> resolveIndex(ObjectId canonicalTreeId, IndexInfo indexInfo, IndexDatabase db) { Index index = null; if (EMPTY_TREE_ID.equals(canonicalTreeId)) { index = new Index(indexInfo, EMPTY_TREE_ID, db); } else { ObjectId indexedTree = db.resolveIndexedTree(indexInfo, canonicalTreeId).orNull(); if (indexedTree != null) { index = new Index(indexInfo, indexedTree, db); } } return Optional.ofNullable(index); }
/** * Performs the operation. * * @return the newly constructed {@link IndexInfo} */ @Override protected IndexInfo _call() { IndexDatabase indexDatabase = indexDatabase(); checkArgument(treeName != null, "tree name not provided"); checkArgument(attributeName != null, "indexing attribute name not provided"); checkArgument(indexType != null, "index type not provided"); checkArgument(!indexDatabase.getIndexInfo(treeName, attributeName).isPresent(), "An index has already been created on that tree and attribute."); Map<String, Object> metadata = this.metadata; IndexInfo index = indexDatabase.createIndexInfo(treeName, attributeName, indexType, metadata); return index; } }
/** * Resolves a given tree and attribute name into one or more {@link IndexInfo} objects * * @param indexdb the index database * @param treeName the name of the feature tree * @param attributeName the name of the indexed attribute. If {@code null}, this function will * return the index infos associated with the given tree name * @return the resolved {@link IndexInfo} objects */ public static List<IndexInfo> resolveIndexInfo(IndexDatabase indexdb, String treeName, @Nullable String attributeName) { if (attributeName == null) { return indexdb.getIndexInfos(treeName); } else { Optional<IndexInfo> indexInfoOpt = indexdb.getIndexInfo(treeName, attributeName); if (indexInfoOpt.isPresent()) { return Lists.newArrayList(indexInfoOpt.get()); } } return Lists.newArrayList(); }
protected @Override void compute() { List<TreeCopyTask> treeTasks = new ArrayList<>(); Set<IndexTreeMapping> mappings = new HashSet<>(); try (AutoCloseableIterator<IndexTreeMapping> indexMappings = src .resolveIndexedTrees(index)) { mappings = Sets.newHashSet(indexMappings); } for (IndexTreeMapping mapping : mappings) { ObjectId indexTreeId = mapping.indexTree; if (!target.exists(indexTreeId)) { TreeCopyTask task = new TreeCopyTask(src.getTree(indexTreeId), src, target); treeTasks.add(task); } } super.invokeAll(treeTasks); IndexInfo targetIndex = target.createIndexInfo(index.getTreeName(), index.getAttributeName(), index.getIndexType(), index.getMetadata()); mappings.forEach(m -> target.addIndexedTree(targetIndex, m.featureTree, m.indexTree)); }
@Test public void testGetIndexesNoneTreeName() { String treeName = "tree"; List<IndexInfo> indexes = indexDb.getIndexInfos(treeName); assertTrue(indexes.isEmpty()); indexDb.createIndexInfo("otherTree", "someAttribute", IndexType.QUADTREE, null); indexes = indexDb.getIndexInfos(treeName); assertTrue(indexes.isEmpty()); }
String treeName = "tree"; String attributeName = "attribute"; IndexInfo index = indexDb.createIndexInfo(treeName, attributeName, IndexType.QUADTREE, null); IndexInfo index2 = indexDb.createIndexInfo(treeName, attributeName2, IndexType.QUADTREE, null); indexDb.addIndexedTree(index, originalTreeId1, indexedTreeId1); indexDb.addIndexedTree(index, originalTreeId2, indexedTreeId2); indexDb.addIndexedTree(index2, originalTreeId1, indexedTreeId1); indexDb.addIndexedTree(index2, originalTreeId2, indexedTreeId2); Optional<ObjectId> resolvedId = indexDb.resolveIndexedTree(index, originalTreeId1); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId1, resolvedId.get()); resolvedId = indexDb.resolveIndexedTree(index, originalTreeId2); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId2, resolvedId.get()); resolvedId = indexDb.resolveIndexedTree(index2, originalTreeId1); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId1, resolvedId.get()); resolvedId = indexDb.resolveIndexedTree(index2, originalTreeId2); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId2, resolvedId.get());
@Then("^the response should contain the index ID for tree \"([^\"]*)\"$") public void the_response_contains_indexID(String tree) throws Throwable { GeoGIG gig = localRepo.geogigCLI.getGeogig(); ObjectId canonicalTreeId = gig.command(ResolveTreeish.class).setTreeish("HEAD:" + tree).call().get(); Optional<IndexInfo> indexInfo = gig.getRepository().indexDatabase().getIndexInfo(tree,"pp"); Optional<ObjectId> indexedTree = gig.getRepository().indexDatabase().resolveIndexedTree(indexInfo.get(),canonicalTreeId); if (!indexedTree.isPresent()) { fail(); } String indexId = indexedTree.get().toString(); String actual = localRepo.stdOut.toString().replaceAll(LINE_SEPARATOR, "") .replaceAll("\\\\", "/"); assertTrue("'" + actual + "' does not contain ID '" + indexId.substring(0,8), actual.contains(indexId.toString().substring(0,8))); }
@Test public void testIndexTreeMappings() { String treeName = "tree"; String attributeName = "attribute"; IndexInfo index = indexDb.createIndexInfo(treeName, attributeName, IndexType.QUADTREE, null); ObjectId originalTreeId = RevObjectTestSupport.hashString("fake1"); ObjectId indexedTreeId = RevObjectTestSupport.hashString("fake2"); ObjectId notIndexedId = RevObjectTestSupport.hashString("fake3"); indexDb.addIndexedTree(index, originalTreeId, indexedTreeId); Optional<ObjectId> resolvedId = indexDb.resolveIndexedTree(index, originalTreeId); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId, resolvedId.get()); resolvedId = indexDb.resolveIndexedTree(index, notIndexedId); assertFalse(resolvedId.isPresent()); }
@Test public void testClearIndex() { String treeName = "tree"; String attributeName = "attribute"; IndexInfo index = indexDb.createIndexInfo(treeName, attributeName, IndexType.QUADTREE, null); ObjectId originalTreeId1 = RevObjectTestSupport.hashString("fake1"); ObjectId originalTreeId2 = RevObjectTestSupport.hashString("fake2"); ObjectId indexedTreeId1 = RevObjectTestSupport.hashString("fake3"); ObjectId indexedTreeId2 = RevObjectTestSupport.hashString("fake4"); indexDb.addIndexedTree(index, originalTreeId1, indexedTreeId1); indexDb.addIndexedTree(index, originalTreeId2, indexedTreeId2); Optional<ObjectId> resolvedId = indexDb.resolveIndexedTree(index, originalTreeId1); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId1, resolvedId.get()); resolvedId = indexDb.resolveIndexedTree(index, originalTreeId2); assertTrue(resolvedId.isPresent()); assertEquals(indexedTreeId2, resolvedId.get()); indexDb.clearIndex(index); resolvedId = indexDb.resolveIndexedTree(index, originalTreeId1); assertFalse(resolvedId.isPresent()); resolvedId = indexDb.resolveIndexedTree(index, originalTreeId2); assertFalse(resolvedId.isPresent()); }
indexInfosByFeatureTreeName = indexdb.getIndexInfos().stream() .collect(Collectors.toMap(i -> i.getTreeName(), i -> i)); if (indexInfosByFeatureTreeName.isEmpty()) { : treeDiff.newObjectId(); ObjectId oldIndexTreeId = indexdb.resolveIndexedTree(indexInfo, oldCanonical) .or(RevTree.EMPTY_TREE_ID); ObjectId newIndexTreeId = indexdb.resolveIndexedTree(indexInfo, newCanonical) .or(RevTree.EMPTY_TREE_ID);
oldIndexTree = RevTree.EMPTY; } else { final Optional<ObjectId> oldIndexTreeId = indexDatabase.resolveIndexedTree(index, oldCanonicalTree.getId()); if (oldIndexTreeId.isPresent()) { oldIndexTree = indexDatabase.getTree(oldIndexTreeId.get()); } else { oldIndexTree = RevTree.EMPTY;
final String treeName = indexDef.getIndex().getTreeName(); final String attributeName = indexDef.getIndex().getAttributeName(); final Optional<IndexInfo> existingIndex = indexdb.getIndexInfo(treeName, attributeName); sourceStore.copyIndexTo(indexDef.getIndex(), indexdb); return; Iterator<ObjectId> missingContentIds = producer.iterator(); missingContents = sourceStore.getAll(() -> missingContentIds, NOOP_LISTENER, RevTree.class); IndexInfo indexInfo = indexDef.getIndex(); CountingListener c = new BulkOpListener.CountingListener(); indexdb.putAll(missingContents, c); indexdb.addIndexedTree(indexInfo, originalTree, indexedTree); } finally { producerThread.shutdownNow();
/** * @return the {@link RevTree} that represents the indexed tree */ public RevTree indexTree() { return indexdb.getTree(indexTree); }
/** * @param oldCanonical the layer's canonical tree id * @param treeName the layer's tree path * @param attributeName the index attribute name * @param repo * @return */ private Optional<Index> resolveIndex(final ObjectId oldCanonical, final String treeName, final String attributeName, final IndexDatabase db) { IndexInfo info = db.getIndexInfo(treeName, attributeName).orNull(); Optional<Index> index = Optional.empty(); if (info != null) { index = resolveIndex(oldCanonical, info, db); } return index; }
private static Set<IndexTreeMapping> getIndexMappings(IndexInfo indexInfo, Repository repo, Optional<String> ref) { if (!ref.isPresent()) { return Sets.newHashSet(repo.indexDatabase().resolveIndexedTrees(indexInfo)); } Set<IndexTreeMapping> mappings = new HashSet<>(); List<Ref> branches = getBranches(repo, ref); for (Ref branch : branches) { List<RevCommit> commits = Lists.newArrayList(repo.command(LogOp.class) .addPath(indexInfo.getTreeName()).setUntil(branch.getObjectId()).call()); for (RevCommit c : commits) { String treeRef = String.format("%s:%s", c.getId(), indexInfo.getTreeName()); ObjectId canonicalTreeId = repo.command(RevParse.class).setRefSpec(treeRef).call() .get(); Optional<ObjectId> indexedTree = repo.indexDatabase().resolveIndexedTree(indexInfo, canonicalTreeId); String msg = String.format("Expected index at %s:%s", branch.getName(), indexInfo.getTreeName()); assertTrue(msg, indexedTree.isPresent()); mappings.add(new IndexTreeMapping(canonicalTreeId, indexedTree.get())); } } return mappings; }
protected void testCopyIndexesTo(IndexDatabase target) { IndexInfo index1 = createIndex("Layer1", this.indexDb); this.indexDb.copyIndexesTo(target); Optional<IndexInfo> indexInfo = target.getIndexInfo(index1.getTreeName(), index1.getAttributeName()); assertNotNull(indexInfo); assertTrue(indexInfo.isPresent()); assertEquals(index1, indexInfo.get()); Set<IndexTreeMapping> expectedMappings = toSet(this.indexDb.resolveIndexedTrees(index1)); Set<IndexTreeMapping> actualMappings = toSet(target.resolveIndexedTrees(index1)); assertEquals(expectedMappings.size(), actualMappings.size()); assertEquals(expectedMappings, actualMappings); Set<ObjectId> expectedIndexTrees = verifyAllReachableTrees(this.indexDb, expectedMappings); Set<ObjectId> actualIndexTrees = verifyAllReachableTrees(target, actualMappings); assertEquals(expectedIndexTrees.size(), actualIndexTrees.size()); assertEquals(expectedIndexTrees, actualIndexTrees); }
private IndexInfo createIndexForLayer(String layerName, @Nullable String... extraAttributes) { Map<String, Object> metadata = new HashMap<>(); metadata.put(IndexInfo.MD_QUAD_MAX_BOUNDS, new Envelope(-180, 180, -90, 90)); if (extraAttributes != null && extraAttributes.length > 0) { metadata.put(IndexInfo.FEATURE_ATTRIBUTES_EXTRA_DATA, extraAttributes); } IndexInfo indexInfo; indexInfo = indexdb.createIndexInfo(layerName, "geom", IndexType.QUADTREE, metadata); return indexInfo; }
@Test public void testUpdateIndexAddMetadata() { String treeName = "tree"; String attributeName = "attribute"; IndexInfo index = indexDb.createIndexInfo(treeName, attributeName, IndexType.QUADTREE, null); assertEquals(treeName, index.getTreeName()); assertEquals(attributeName, index.getAttributeName()); assertEquals(IndexType.QUADTREE, index.getIndexType()); assertEquals(ImmutableMap.of(), index.getMetadata()); assertEquals(IndexInfo.getIndexId(treeName, attributeName), index.getId()); Map<String, Object> metadata = new HashMap<String, Object>(); metadata.put("meta1", 5L); metadata.put("meta2", "someValue"); index = indexDb.updateIndexInfo(treeName, attributeName, IndexType.QUADTREE, metadata); assertEquals(treeName, index.getTreeName()); assertEquals(attributeName, index.getAttributeName()); assertEquals(IndexType.QUADTREE, index.getIndexType()); assertEquals(metadata, index.getMetadata()); assertEquals(IndexInfo.getIndexId(treeName, attributeName), index.getId()); index = indexDb.getIndexInfo(treeName, attributeName).get(); assertEquals(treeName, index.getTreeName()); assertEquals(attributeName, index.getAttributeName()); assertEquals(IndexType.QUADTREE, index.getIndexType()); assertEquals(metadata, index.getMetadata()); assertEquals(IndexInfo.getIndexId(treeName, attributeName), index.getId()); }
private IndexInfo createIndex(String treeName, IndexDatabase target) { IndexInfo index = target.createIndexInfo(treeName, "the_geom", IndexType.QUADTREE, null); Envelope maxBounds = new Envelope(-180, 180, -90, 90); Envelope bounds = new Envelope(); RevTree tree = RevTree.EMPTY; for (int y = -90; y <= 90; y += 5) { RevTreeBuilder builder = RevTreeBuilder.quadBuilder(target, target, tree, maxBounds); for (int x = -180; x <= 180; x += 5) { bounds.init(x, x, y, y); String name = String.format("%d_%d", x, y); ObjectId oid = RevObjectTestSupport.hashString(name); Node node = RevObjectFactory.defaultInstance().createNode(name, oid, ObjectId.NULL, TYPE.FEATURE, bounds, null); builder.put(node); } tree = builder.build(); ObjectId originalTree = RevObjectTestSupport.hashString("fake" + tree.getId()); target.addIndexedTree(index, originalTree, tree.getId()); } return index; }