Refine search
static NodeIterator executeQuery(final Session session, final Node templateQueryNode) throws RepositoryException { final String statement = templateQueryNode.getProperty("jcr:statement").getString(); final String language = templateQueryNode.getProperty("jcr:language").getString(); final QueryManager queryManager = session.getWorkspace().getQueryManager(); final Query query = queryManager.createQuery(statement, language); final QueryResult queryResult = query.execute(); return queryResult.getNodes(); }
private static void extractPrototype(final JcrMatcher matcher, final Map<String, Set<String>> types, final QueryManager qmgr, final Node queryTemplate) throws RepositoryException { try { Set<String> prototypes = new TreeSet<>(); if (queryTemplate.isNodeType("nt:query")) { Query query = qmgr.getQuery(queryTemplate); query = qmgr.createQuery(queryTemplate.getProperty("jcr:statement").getString(), query.getLanguage()); // HREPTWO-1266 QueryResult rs = query.execute(); for (NodeIterator iter = rs.getNodes(); iter.hasNext(); ) { Node typeNode = iter.nextNode(); if (typeNode.getName().equals(EssentialConst.HIPPOSYSEDIT_PROTOTYPE)) { String documentType = typeNode.getPrimaryNodeType().getName(); final boolean isTemplate = INTERNAL_TYPES_PREDICATE.apply(documentType); if (isTemplate && (matcher == null || matcher.matches(typeNode))) { prototypes.add(documentType); } } else { prototypes.add(typeNode.getName()); } } } types.put(queryTemplate.getName(), prototypes); } catch (InvalidQueryException ex) { log.error(MessageFormat.format("{0}: {1}", ex.getClass().getName(), ex.getMessage()), ex); } }
public QueryEngine(Session session, LuceneQueryFactory lqf, Map<String, Value> variables) throws RepositoryException { this.session = session; this.lqf = lqf; Workspace workspace = session.getWorkspace(); this.ntManager = workspace.getNodeTypeManager(); this.qomFactory = workspace.getQueryManager().getQOMFactory(); this.valueFactory = session.getValueFactory(); this.evaluator = new OperandEvaluator(valueFactory, variables); }
/** * Stores a {@link javax.jcr.query.Query#XPATH} query at: * <code>testRoot + "/" + nodeName1</code>. * @throws NotExecutableException if nt:query is not supported. */ public void testSave() throws RepositoryException, NotExecutableException { checkNtQuery(); Query query = superuser.getWorkspace().getQueryManager().createQuery(statement, Query.XPATH); query.storeAsNode(testRoot + "/" + nodeName1); assertTrue("Node has not been stored", testRootNode.hasNode(nodeName1)); Node queryNode = testRootNode.getNode(nodeName1); assertTrue("Query node is not of type nt:query", queryNode.isNodeType(ntQuery)); Query query2 = superuser.getWorkspace().getQueryManager().getQuery(queryNode); assertEquals("Persisted query does not match initial query.", query.getStatement(), query2.getStatement()); }
public void testUnknownQueryLanguage() throws RepositoryException { List<String> supported = Arrays.asList(qm.getSupportedQueryLanguages()); String language; do { language = createRandomString(5); } while (supported.contains(language)); try { qm.createQuery("foo", language); fail("createQuery() must throw for unknown query language: " + language); } catch (InvalidQueryException e) { // expected } } }
public void testSimpleQuerySQL1() throws Exception { Node foo = testRootNode.addNode("foo"); foo.setProperty("bla", new String[]{"bla"}); testRootNode.save(); String sql = "SELECT * FROM nt:base" + " WHERE jcr:path LIKE '" + testRoot + "/foo'" + " AND bla = 'bla'"; Query q = superuser.getWorkspace().getQueryManager().createQuery(sql, Query.SQL); QueryResult result = q.execute(); checkResult(result, 1); }
public String add(String category, String template, Map<String,String> arguments) throws WorkflowException, MappingException, RepositoryException, RemoteException { String name = arguments.get("name"); rootSession.save(); final QueryManager qmgr = userSession.getWorkspace().getQueryManager(); final Node queryFolder = userSession.getNode(TEMPLATES_PATH); if (!queryFolder.hasNode(category)) { throw new WorkflowException("No template query called '" + category + "' at " + TEMPLATES_PATH); final Node templateQuery = queryFolder.getNode(category); Query query = qmgr.getQuery(templateQuery); query = qmgr.createQuery(templateQuery.getProperty("jcr:statement").getString(), query.getLanguage()); QueryResult rs = query.execute(); for (Node prototypeNode : new NodeIterable(rs.getNodes())) { prototypeNode = rootSession.getNodeByIdentifier(prototypeNode.getIdentifier()); if (prototypeNode.getName().equals("hipposysedit:prototype")) {
protected Map<String, Set<String>> prototypes() throws RepositoryException { Map<String, Set<String>> types = new LinkedHashMap<>(); try { QueryManager qmgr = userSession.getWorkspace().getQueryManager(); Vector<Node> foldertypes = new Vector<>(); Node templates = userSession.getNode(TEMPLATES_PATH); Value[] foldertypeRefs = null; if (subject.hasProperty("hippostd:foldertype")) { try { foldertypeRefs = subject.getProperty("hippostd:foldertype").getValues(); for (final Value foldertypeRef : foldertypeRefs) { String foldertype = foldertypeRef.getString(); if (templates.hasNode(foldertype)) { foldertypes.add(templates.getNode(foldertype)); } else { Set<String> prototypes = new TreeSet<>(); if (foldertype.isNodeType("nt:query")) { Query query = qmgr.getQuery(foldertype); query = qmgr.createQuery(foldertype.getProperty("jcr:statement").getString(), query.getLanguage()); // HREPTWO-1266 QueryResult rs = query.execute(); for (NodeIterator iter = rs.getNodes(); iter.hasNext();) { Node typeNode = iter.nextNode(); if (typeNode.getName().equals("hipposysedit:prototype")) {
public void testScoreWithOr() throws Exception { Session session = superuser; QueryManager qm = session.getWorkspace().getQueryManager(); Node n1 = testRootNode.addNode("node1"); n1.setProperty("text", "hello"); n1.setProperty("id", "1"); session.save(); String xpath = "/jcr:root//*[jcr:contains(@text, 'hello') or @id = '1']"; Query q = qm.createQuery(xpath, "xpath"); String result = getResult(q.execute(), "jcr:path"); assertEquals("/testroot/node1", result); }
NamespaceRegistry nsReg = session.getWorkspace().getNamespaceRegistry(); Node rootNode = session.getRootNode(); QueryManager qMgr = getRepositorySession().getWorkspace().getQueryManager(); if (itemPath != null && !rootNode.getPath().equals(itemPath)) { String qNodeRelPath = itemPath.substring(1); if (rootNode.hasNode(qNodeRelPath)) { Node qNode = rootNode.getNode(qNodeRelPath); if (qNode.isNodeType(JcrConstants.NT_QUERY)) { return qMgr.getQuery(qNode); session.setNamespacePrefix(prefix, uri); q = qMgr.createQuery(sInfo.getQuery(), sInfo.getLanguageName()); q.setLimit(sInfo.getNumberResults()); q.setOffset(sInfo.getOffset()); if (itemPath != null && !getRepositorySession().itemExists(itemPath)) { try { q.storeAsNode(itemPath); } catch (RepositoryException e) {
when( nodeTrash.getNodes() ).thenReturn( nodeIterator ); when( nodeUserFolder.hasNode( anyString() ) ).thenReturn( true ); when( nodeUserFolder.getNode( anyString() ) ).thenReturn( nodeTrash ); when( nodeUserFolder.getIdentifier() ).thenReturn( "nodeUserFolderID" ); when( queryResult.getNodes() ).thenReturn( nodeIterator ); when( query.execute() ).thenReturn( queryResult ); when( queryManager.getQOMFactory() ).thenReturn( qomFactory ); when( queryManager.createQuery( anyString(), anyString() ) ).thenReturn( query ); when( workspace.getQueryManager() ).thenReturn( queryManager ); when( session.getItem( anyString() ) ).thenReturn( nodeUserFolder ); when( session.getValueFactory() ).thenReturn( valueFactory ); when( session.getWorkspace() ).thenReturn( workspace ); when( session.itemExists( anyString() ) ).thenReturn( true );
@Test public void date() throws Exception { Session session = getAdminSession(); Node t1 = session.getRootNode().addNode("t1"); t1.setProperty("x", "22.06.07"); Node t2 = session.getRootNode().addNode("t2"); t2.setProperty("x", "2007-06-22T01:02:03.000Z", PropertyType.DATE); session.save(); String query = "//*[x='a' or x='b']"; QueryResult r = session.getWorkspace(). getQueryManager().createQuery( query, "xpath").execute(); NodeIterator it = r.getNodes(); assertFalse(it.hasNext()); }
protected void nodeExists( Session session, String parentPath, String childName, boolean exists ) throws Exception { Node parent = session.getNode(parentPath); assertThat(parent.hasNode(childName), is(exists)); String path = parent.getPath(); if (parent.getDepth() != 0) path = path + "/"; path = path + childName; String sql = "SELECT * FROM [nt:base] WHERE PATH() = '" + path + "'"; Query query = session.getWorkspace().getQueryManager().createQuery(sql, Query.JCR_SQL2); QueryResult result = query.execute(); assertThat(result.getNodes().getSize(), is(exists ? 1L : 0L)); }
public void testGetSize() throws RepositoryException { QueryManager qm = superuser.getWorkspace().getQueryManager(); for (int i = 0; i < 10; i++) { String stmt = testPath + "/*[@" + propertyName1 + " < 1000]"; QueryResult result = qm.createQuery(stmt, Query.XPATH).execute(); assertEquals("Wrong size of NodeIterator in result", INITIAL_NODE_NUM - i, result.getNodes().getSize()); // remove node for the next iteration testRootNode.getNode("node" + i).remove(); testRootNode.save(); } }
QueryObjectModelFactory fac = session.getWorkspace().getQueryManager().getQOMFactory(); final String selectorName = "selector"; //$NON-NLS-1$ QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, fac.literal( session.getValueFactory().createValue( origParentFolderPath ) ) ); origNameConstraint = fac.comparison( fac.propertyValue( selectorName, pentahoJcrConstants.getPHO_ORIGNAME() ), QueryObjectModelConstants.JCR_OPERATOR_LIKE, fac.literal( session.getValueFactory().createValue( convertedFilter ) ) ); Constraint descendantNodeConstraint = fac.descendantNode( selectorName, trashNode.getPath() ); session.getWorkspace().getQueryManager().createQuery( query.getStatement(), Query.JCR_JQOM ).execute(); NodeIterator nodeIter = result.getNodes(); List<RepositoryFile> deletedFiles = new ArrayList<RepositoryFile>(); String user = PentahoSessionHolder.getSession().getName(); if ( trashFileIdNode.hasNodes() ) { nodeToDeletedFile( session, pentahoJcrConstants, trashFileIdNode.getNodes().nextNode(), user ) ); } else { throw new RuntimeException(
/** * Verify that the jcr:path is present in the query result. */ public void testJcrPath() throws RepositoryException, NotExecutableException { String nodeTypeName = session.getRootNode().getPrimaryNodeType().getName(); String queryStatement = "//element(*, " + nodeTypeName + ")"; // execute the search query Query query = session.getWorkspace().getQueryManager().createQuery(queryStatement, qsXPATH); QueryResult result = query.execute(); assertTrue("jcr:path must be present in query result row", Arrays.asList(result.getColumnNames()).contains(jcrPath)); } }
private void run0() throws RepositoryException { session.refresh(false); QueryManager qm = session.getWorkspace().getQueryManager(); Query q = qm.createQuery("select * from [nt:base] where [" + indexedPropName + "] = $status " + "option(index tag fooIndex)", Query.JCR_SQL2); q.bindValue("status", session.getValueFactory().createValue(randomStatus())); QueryResult result = q.execute(); //With property index at time traversing index wins (somehow reporting lower cost) //and that leads to warning. So limit the iterator size resultSize += Iterators.size(Iterators.limit(result.getNodes(), 500)); } }
if (!queryNode.hasProperty("jcr:language")) { queryNode.setProperty("jcr:language", "xpath"); if (!queryNode.hasProperty("jcr:statement")) { queryNode.setProperty("jcr:statement", "//*"); QueryManager qrm = queryNode.getSession().getWorkspace().getQueryManager(); try { Query query = qrm.getQuery(queryNode); language = query.getLanguage(); statement = query.getStatement(); } catch (InvalidQueryException e) { log.warn("Invalid query statement. Revert to default xpath statement //*");
public void testGetQuery() throws RepositoryException, NotExecutableException { checkNtQuery(); Node n = testRootNode.addNode(nodeName1, testNodeType); superuser.save(); List<Query> queries = new ArrayList<Query>(); QueryObjectModel qom = qf.createQuery( ); queries.add(qom); queries.add(qm.createQuery(qom.getStatement(), Query.JCR_SQL2)); if (isSupportedLanguage(qsXPATH)) { String xpath = testPath + "/element(*, " + testNodeType + ")"; queries.add(qm.createQuery(xpath, qsXPATH)); queries.add(qm.createQuery(sql, qsSQL)); String lang = q.getLanguage(); checkResult(q.execute(), new Node[]{n}); Node stored = q.storeAsNode(testRoot + "/storedQuery"); q = qm.getQuery(stored); assertEquals("language of stored query does not match", lang, q.getLanguage()); checkResult(q.execute(), new Node[]{n}); stored.remove();
try { Node reportNode = nodeModel.getObject(); if (reportNode.isNodeType(ReportingNodeTypes.NT_REPORT)) { Node queryNode = reportNode.getNode(ReportingNodeTypes.QUERY); QueryManager queryManager = ((UserSession) Session.get()).getQueryManager(); HippoQuery query = (HippoQuery) queryManager.getQuery(queryNode); if (reportNode.hasProperty(ReportingNodeTypes.PARAMETER_NAMES)) { Value[] parameterNames = reportNode.getProperty(ReportingNodeTypes.PARAMETER_NAMES).getValues(); Value[] parameterValues = reportNode.getProperty(ReportingNodeTypes.PARAMETER_VALUES)