@Override public Iterator<Long> lookup(Object value) { Long result = indexData.get(value); return result != null ? IteratorUtil.singletonIterator(result) : IteratorUtil.<Long>emptyIterator(); }
public void verify(String dbPath) { EmbeddedGraphDatabase graphDb = new EmbeddedGraphDatabase(dbPath); assertEquals( "Reference node did not have zero relationships.", 0, IteratorUtil.count(graphDb.getReferenceNode().getRelationships())); assertEquals("There was more than one node.", 1, IteratorUtil.count(graphDb.getAllNodes())); graphDb.shutdown(); }
@Test @Transactional public void testUpdateBooleanPropertyIsReflectedInIndex() { Group group = persist(new Group()); group.setAdmin(true); assertEquals( 1, IteratorUtil.asCollection(groupRepository.findAllByPropertyValue("admin", true)).size()); group.setAdmin(false); assertEquals( 0, IteratorUtil.asCollection(groupRepository.findAllByPropertyValue("admin", true)).size()); }
public static int getDocumentSizeForFeature(GraphDatabaseService db, Long id) { int documentSize; String cacheKey = "DOCUMENT_SIZE_FEATURE_" + id; if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) { Node startNode = db.getNodeById(id); Iterator<Node> classes = db.traversalDescription() .depthFirst() .relationships(withName("HAS_CLASS"), Direction.OUTGOING) .evaluator(Evaluators.fromDepth(1)) .evaluator(Evaluators.toDepth(1)) .traverse(startNode) .nodes() .iterator(); documentSize = IteratorUtil.count(classes); vectorSpaceModelCache.put(cacheKey, documentSize); } else { documentSize = (Integer) vectorSpaceModelCache.getIfPresent(cacheKey); } return documentSize; }
private CypherResult doExecuteQuery(String query, boolean canProfile) { long time = System.currentTimeMillis(); Transaction tx = gdb.beginTx(); javax.transaction.Transaction resumeTx; try { resumeTx = suspendTx(query); ExecutionResult result = canProfile ? executionEngine.profile(query) : executionEngine.execute(query); final Collection<Map<String, Object>> data = IteratorUtil.asCollection(result); time = System.currentTimeMillis() - time; resumeTransaction(resumeTx); CypherResult cypherResult = new CypherResult( result.columns(), data, result.getQueryStatistics(), time, canProfile ? result.executionPlanDescription() : null, prettify(query)); tx.success(); return cypherResult; } finally { tx.close(); } }
@Override protected Object retrieveEntity(PersistentEntity pe, Serializable key) { List<Criterion> criteria = new ArrayList<Criterion>(1); criteria.add(new IdEquals(key)); return IteratorUtil.singleOrNull( new Neo4jQuery(session, pe, this).executeQuery(pe, new Conjunction(criteria)).iterator()); }
public static Map<Long, Integer> getTermFrequencyMapForDocument( GraphDatabaseService db, Long classId) { Map<Long, Integer> termDocumentMatrix; String cacheKey = "TERM_DOCUMENT_FREQUENCY_" + classId; if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) { Node classNode = db.getNodeById(classId); termDocumentMatrix = new HashMap<>(); IteratorUtil.asCollection( db.traversalDescription() .depthFirst() .relationships(withName("HAS_CLASS"), Direction.INCOMING) .evaluator(Evaluators.fromDepth(1)) .evaluator(Evaluators.toDepth(1)) .traverse(classNode)) .stream() .forEach( p -> termDocumentMatrix.put( p.endNode().getId(), (Integer) p.lastRelationship().getProperty("matches"))); vectorSpaceModelCache.put(cacheKey, termDocumentMatrix); } else { termDocumentMatrix = (Map<Long, Integer>) vectorSpaceModelCache.getIfPresent(cacheKey); } return termDocumentMatrix; }
@Override protected OperationResult executeOperation( IndexQueryNodeOnNeoPinEntertainmentVideoIndexOperation operation) { int resultCode; int result; Neo4jConnectionStateEmbedded connection = (Neo4jConnectionStateEmbedded) getDbConnectionState(); Transaction tx = connection.getDb().beginTx(); try { Iterator<Node> nodes = connection .getDb() .index() .forNodes(operation.getIndexName()) .query(operation.getIndexQuery()); resultCode = 0; result = IteratorUtil.count(nodes); } catch (Exception e) { resultCode = -1; result = 0; } finally { tx.finish(); } return operation.buildResult(resultCode, result); }
private Object unmarshall(PersistentEntity persistentEntity, Long id, Map<String, Object> data) { log.debug("unmarshalling entity {}, props {}, {}", id, data); EntityAccess entityAccess = new EntityAccess(persistentEntity, persistentEntity.newInstance()); entityAccess.setConversionService(persistentEntity.getMappingContext().getConversionService()); entityAccess.setIdentifier(id); data.remove("__id__"); for (PersistentProperty property : entityAccess.getPersistentEntity().getPersistentProperties()) { String propertyName = property.getName(); if (property instanceof Simple) { // implicitly sets version property as well entityAccess.setProperty(propertyName, data.remove(propertyName)); // } else if (property instanceof OneToOne) { // log.error("property " + property.getName() + " is of type " + // property.getClass().getSuperclass()); } else if (property instanceof ToOne) { ToOne to = (ToOne) property; CypherResult cypherResult = getSession() .getNativeInterface() .execute( CypherBuilder.findRelationshipEndpointIdsFor(to), Collections.singletonMap("id", id)); Map<String, Object> row = IteratorUtil.singleOrNull(cypherResult); if (row != null) { Long endpointId = (Long) row.get("id"); entityAccess.setProperty( propertyName, getMappingContext() .getProxyFactory() .createProxy(session, to.getAssociatedEntity().getJavaClass(), endpointId)); } } else if ((property instanceof OneToMany) || (property instanceof ManyToMany)) { LazyEnititySet lazyEnititySet = new LazyEnititySet( entityAccess, (Association) property, getMappingContext().getProxyFactory(), getSession()); entityAccess.setProperty(propertyName, lazyEnititySet); } else { throw new IllegalArgumentException( "property $property.name is of type ${property.class.superclass}"); } } if (!data.isEmpty()) { GroovyObject go = (GroovyObject) (entityAccess.getEntity()); go.setProperty(Neo4jGormEnhancer.UNDECLARED_PROPERTIES, data); } firePostLoadEvent(entityAccess.getPersistentEntity(), entityAccess); return entityAccess.getEntity(); }
@Override protected List<Object> retrieveAllEntities(PersistentEntity pe, Iterable<Serializable> keys) { List<Criterion> criterions = new ArrayList<Criterion>(1); criterions.add(new In("id", IteratorUtil.asCollection(keys))); Junction junction = new Conjunction(criterions); return new Neo4jQuery(session, pe, this).executeQuery(pe, junction); }
@Override public T getSingle() { try { return IteratorUtil.singleOrNull((Iterator<T>) this); } finally { close(); } }
@Test public void createAndClearCacheBeforeCommit() { Node node = getGraphDb().createNode(); clearCache(); node.createRelationshipTo(getGraphDb().createNode(), TEST); clearCache(); assertEquals(1, IteratorUtil.count(node.getRelationships())); }
private void assertPathIs(Iterable<Person> path, Person... expectedPath) { ArrayList<Person> pathArray = new ArrayList<Person>(); IteratorUtil.addToCollection(path, pathArray); assertThat(pathArray.size(), equalTo(expectedPath.length)); for (int i = 0; i < expectedPath.length; i++) { assertThat(pathArray.get(i), equalTo(expectedPath[i])); } }
/* * Helper method to convert an execution result to a collection * */ public Set<Node> nodeSetFromResult(ExecutionResult result, String column) { Set<Node> nodes = new HashSet<Node>(); Iterator<Node> columnIterator = result.columnAs(column); IteratorUtil.addToCollection(columnIterator, nodes); return nodes; }
public Collection<DynamicRecord> allocateFrom(SchemaRule rule) { RecordSerializer serializer = new RecordSerializer(); serializer = serializer.append(rule); Collection<DynamicRecord> records = new ArrayList<>(); allocateRecordsFromBytes( records, serializer.serialize(), IteratorUtil.iterator(forceGetRecord(rule.getId())), this); return records; }
public CypherResult( java.util.List<String> columns, String text, Iterable<scala.collection.Map<String, Object>> rows) { this.columns = columns; this.text = text; this.rows = IteratorUtil.addToCollection(iterate(rows), new ArrayList<Map<String, Object>>()); }
@SuppressWarnings({"unchecked", "rawtypes"}) protected Object createPage(Iterable<?> result, Pageable pageable) { final List resultList = IteratorUtil.addToCollection(result, new ArrayList()); if (pageable == null) { return new PageImpl(resultList); } final int currentTotal = pageable.getOffset() + pageable.getPageSize(); return new PageImpl(resultList, pageable, currentTotal); }
@RequestMapping(value = "/actors/{id}", method = RequestMethod.GET, headers = "Accept=text/html") public String singleActorView(Model model, @PathVariable String id) { Person person = moviesRepository.getPerson(id); model.addAttribute("actor", person); model.addAttribute("id", id); model.addAttribute("roles", IteratorUtil.asCollection(person.getRoles())); addUser(model); return "/actors/show"; }
@Test public void listing3_10_node_labels() { usersAndMovies.addLabelToMovies(); try (Transaction tx = graphDb.beginTx()) { ResourceIterable<Node> movies = GlobalGraphOperations.at(graphDb).getAllNodesWithLabel(DynamicLabel.label("MOVIES")); assertEquals(3, IteratorUtil.count(movies)); tx.success(); } }
@Nullable public Integer getLastInsertedBlockHeight() { Integer lastInsertedBlockHeight = null; try (Transaction ignored = graphDatabase.beginTx()) { Node block = IteratorUtil.singleOrNull(graphDatabase.findNodes(LabelType.LatestBlock)); if (block != null) { lastInsertedBlockHeight = new BCBlock(block).getHeight(); } } return lastInsertedBlockHeight; }
@Test public void shouldHandleSingleItemIterators() throws Exception { // Given ResourceIterator<Long> it1 = asResourceIterator(iterator(1l)); ResourceIterator<Long> it2 = asResourceIterator(iterator(5l, 6l, 7l)); CombiningResourceIterator<Long> combingIterator = new CombiningResourceIterator<>(iterator(it1, it2)); // When I iterate through it, things come back in the right order assertThat(IteratorUtil.asList(combingIterator), equalTo(asList(1l, 5l, 6l, 7l))); }
@Test @Transactional public void shouldFindGroupyByQueryString() { Group group = persist(new Group()); group.setFullTextName("queryableName"); final Iterable<Group> found = groupRepository.findAllByQuery(Group.SEARCH_GROUPS_INDEX, "fullTextName", "queryable*"); final Collection<Group> result = IteratorUtil.addToCollection(found.iterator(), new HashSet<Group>()); assertEquals(new HashSet<>(Arrays.asList(group)), result); }
@Test @Transactional public void testFindAllGroupsByIndex() { Group group = persist(new Group()); group.setName(NAME_VALUE); Group group2 = persist(new Group()); group2.setName(NAME_VALUE); final Iterable<Group> found = this.groupRepository.findAllByPropertyValue(NAME, NAME_VALUE); final Collection<Group> result = IteratorUtil.addToCollection(found.iterator(), new HashSet<Group>()); assertEquals(new HashSet<>(Arrays.asList(group, group2)), result); }
@Test public void correctlySaysNodeIsDeleted() throws Exception { // Given state.nodeDoDelete(1l); Node node = mock(Node.class); when(node.getId()).thenReturn(1l); when(ops.nodeGetAllProperties(1l)).thenReturn(IteratorUtil.<DefinedProperty>emptyIterator()); when(ops.nodeGetLabels(1l)).thenReturn(PrimitiveIntCollections.emptyIterator()); // When & Then assertThat(snapshot().isDeleted(node), equalTo(true)); }
@SuppressWarnings("unchecked") @Test @Transactional public void testQueryVariableRelationshipSingleResult() throws Exception { final Collection<Map<String, Object>> result = IteratorUtil.asCollection(michael.getOtherTeamMemberData()); assertThat( result, hasItems( testTeam.simpleRowFor(testTeam.emil, "member"), testTeam.simpleRowFor(testTeam.david, "member"))); }
private Iterator<PropertyBlock> propertiesIterator(Map<String, Object> properties) { if (properties == null || properties.isEmpty()) { return IteratorUtil.emptyIterator(); } return new IteratorWrapper<PropertyBlock, Map.Entry<String, Object>>( properties.entrySet().iterator()) { @Override protected PropertyBlock underlyingObjectToObject(Entry<String, Object> property) { return propertyCreator.encodePropertyValue( getOrCreatePropertyKeyId(property.getKey()), property.getValue()); } }; }
public static int getDocumentSize(GraphDatabaseService db) { int documentSize; String cacheKey = "GLOBAL_DOCUMENT_SIZE"; if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) { documentSize = IteratorUtil.count( GlobalGraphOperations.at(db).getAllNodesWithLabel(DynamicLabel.label("Class"))); vectorSpaceModelCache.put(cacheKey, documentSize); } else { documentSize = (Integer) vectorSpaceModelCache.getIfPresent(cacheKey); } return documentSize; }
private Iterator<Property> loadAllPropertiesOf(PrimitiveRecord primitiveRecord) { Collection<PropertyRecord> records = propertyStore.getPropertyRecordChain(primitiveRecord.getNextProp()); if (null == records) { return IteratorUtil.emptyIterator(); } List<Property> properties = new ArrayList<>(); for (PropertyRecord record : records) { for (PropertyBlock block : record.getPropertyBlocks()) { properties.add(block.getType().readProperty(block.getKeyIndexId(), block, propertyStore)); } } return properties.iterator(); }
@Test public void listing3_11_node_labels_and_property() { try { usersAndMovies.addLabelToMovies(); } catch (Exception e) { // ignore if index already exist } try (Transaction tx = graphDb.beginTx()) { ResourceIterable<Node> movies = graphDb.findNodesByLabelAndProperty(DynamicLabel.label("MOVIES"), "name", "Fargo"); assertEquals(1, IteratorUtil.count(movies)); tx.success(); } }
@Override protected List<Usuario> montaLista(ExecutionResult result) { Iterator<Node> n_column = result.columnAs("n"); Usuario usuario = null; List<Usuario> usuarios = new ArrayList<>(); for (Node node : IteratorUtil.asIterable(n_column)) { usuario = new Usuario(); usuario.setNome((String) node.getProperty("nome")); usuario.setLogin((String) node.getProperty("login")); usuarios.add(usuario); } return usuarios; }