Search Archives - Sourced Code

Generate Custom Oak Indexes with the Oak Index Definition Generator

briankasingli — Mon, 26 Feb 2024 02:28:19 +0000

Indexing in Adobe Experience Manager is very important. It’s not just about making things faster; it totally changes how we handle and find data online. With the Oak Index Definition Generator, developers get a really handy tool to shape how searches work behind the scenes. This tool isn’t just about making indexes, it’s about making them just right for each project’s specific needs. By using this tool, developers can create indexes that fit perfectly with what they’re trying to do, making searches faster and more efficient. This smart way of indexing helps AEM websites be faster and more flexible, keeping them ahead of the game in the digital world.

Quick Links

Importance of Indexing
Creating Custom Oak Indexes
Conclusion

Why Indexing is Important

Indexing AEM is critical for optimizing performance and managing content efficiently. The Oak Index, a key feature of AEM, improves search query speed by organizing data for quicker retrieval. This not only boosts system performance but also supports customization for specific project requirements. Efficient indexing enables scalable and responsive AEM sites, ensuring they can handle growing content without compromising on speed. Understanding and utilizing the Oak Index effectively is essential for maintaining high-performance AEM projects that meet modern digital experience demands.

Using the Oak Index Definition Generator

Creating custom Oak indexes with the Oak Index Definition Generator is a straightforward process:

Open the Oak Index Definition Generator at http://oakutils.appspot.com/generate/index.
Input your query in the Queries field.
Click “Generate” to create your custom Oak index.
Copy the XML into your AEM project for further adjustments.

Conclusion

It’s essential for developers to familiarize themselves with the AEM index definition structure to maximize the effectiveness of their custom indexes. Adobe provides resources such as a cheat sheet on AEM index definition structure, offering guidance on how to properly configure indexes for optimal performance.

The post Generate Custom Oak Indexes with the Oak Index Definition Generator appeared first on Sourced Code.

AEM 6.5.5 Not Indexing Problem Fixed

briankasingli — Sat, 16 Dec 2023 20:00:01 +0000

In the course of establishing a new multitenant website, we opted to re-use the search mechanism for both site1 and site2. However, following the deployment of our code to the cloud QA environment, a significant hurdle surfaced: site2’s search consistently failed to produce results. This revelation made us to invest considerable effort in a detailed debugging journey.

Follow this step-by-step guide below as we transparently outline each phase of our process to resolve this issue.

Navigating the challenges posed by the AEM 6.5.5 indexing problem, we’ve acquired invaluable insights that we believe will prove highly beneficial to the broader community. It’s crucial to emphasize that the focus of this article is specifically on the on-premises AEM 6.5.5 solution, distinct from the AEMaaCS solution.

Step 1: Identifying the Issue with the Query Performance Tool

Our initial step involved using the query performance tool provided by AEM 6.5.5: /libs/granite/operations/content/diagnosistools/queryPerformance.html. This tool allowed us to pinpoint the queries in use. As we focused on the search entry for site2, we discovered that the Lucene index was incorrectly utilizing the index intended for site1. This realization prompted us to proceed to the next step.

Step 2: Updating Lucene Index Properties

In the second step, we accessed crx/de and located the Lucene index entry under /oak:index/*. After finding the node, we updated the node properties, setting resync = false. Monitoring the indexing logs, we confirmed a successful reindex. Despite obtaining the exact query for site2’s request, using the explain query tool revealed that the results were not as expected. Undeterred, we proceeded to the next step.

Step 3: Deleting and Remaking %_TARGET_FOLDER_%

With the issue persisting, we decided to take more decisive action in the third step. We shut down AEM, deleted ./crx-quickstart/repository/index/%_TARGET_FOLDER_%, and restarted the environment. After waiting for 5-10 minutes, the logs indicated that the %_TARGET_FOLDER_% had been remade. Unfortunately, using the explain query tool still showed unexpected results, prompting us to move on to the next approach.

Step 4: Complete Index Folder Deletion

For the fourth step, we took a more extensive approach by shutting down AEM and deleting the entire index folder: ./crx-quickstart/repository/index/*. After restarting and patiently waiting for 10-30 minutes, the logs confirmed the successful recreation of the index folder. However, the query results were still not meeting our expectations.

Step 5: Unconventional Solution

By the fifth step, conventional options exhausted, we attempted an unconventional approach. Authorizing into crx/de, we forcefully deleted both site1 and site2’s oak:index rules. Subsequently, we reinstalled the rules for both sites. The result? A surprising success, with site2’s search now functioning as expected.

Conclusion

Navigating the intricacies of AEM 6.5.5’s indexing system can be challenging. However, with a systematic approach and a willingness to explore unconventional solutions, it’s possible to overcome seemingly insurmountable issues. By sharing our step-by-step journey, we hope this article proves valuable to others facing similar challenges in the realm of AEM development.

The post AEM 6.5.5 Not Indexing Problem *Fixed* appeared first on Sourced Code.

JCR SQL2 ISDESCENDANTNODE Multiple Paths Example

briankasingli — Wed, 18 Oct 2023 02:01:56 +0000

While working with the JCR SQL2 Queries, you may encounter scenarios where content is distributed across various branches of the repository. Querying these branches efficiently is key to implement features to capture requirements. In this article, we will focus o how to collect and query for distributed across various branches of the repository. Using the ISDESCENDANTNODE feature of the JCR SQL Query proves it possible.

Understanding ISDESCENDANTNODE

ISDESCENDANTNODE is a condition in JCR SQL2 that checks if a node is a descendant of another, based on their paths. It is particularly beneficial for querying content hierarchies. Imagine you have content in different branches (content tree) of your AEM repository. You want to search across these branches simultaneously, without running separate queries. This is where ISDESCENDANTNODE shines.

By specifying multiple paths within the ISDESCENDANTNODE condition, you can search for content across these paths concurrently, streamlining your queries. This powerful feature simplifies and optimizes the content retrieval process in AEM.

Finding all cq:Pages under 1 path
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3

SELECT * FROM [cq:Page]
WHERE ISDESCENDANTNODE('/content/sourcedcode/us/')
AND CONTAINS([jcr:content/jcr:title], 'terms')

Finding all cq:Pages under 2 paths
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3
4

SELECT * FROM [cq:Page]
WHERE (ISDESCENDANTNODE('/content/sourcedcode/us/')
OR ISDESCENDANTNODE('/content/sourcedcode/ca/')
AND CONTAINS([jcr:content/jcr:title], 'terms')

Finding all cq:Pages under 3 paths
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3
4
5

SELECT * FROM [cq:Page]
WHERE (ISDESCENDANTNODE('/content/sourcedcode/us/')
OR ISDESCENDANTNODE('/content/sourcedcode/ca/')
OR ISDESCENDANTNODE('/content/sourcedcode/pl/'))
AND CONTAINS([jcr:content/jcr:title], 'terms')

The post JCR SQL2 ISDESCENDANTNODE Multiple Paths Example appeared first on Sourced Code.

Optimizing & Debugging Search Queries, Explain Query Tool AEM

briankasingli — Sat, 09 Sep 2023 03:29:56 +0000

The “Explain Query Tool” tool assists developers in understanding, optimizing, and debugging search queries, which are crucial for the AEM’s performance and accurate content delivery.

Understanding the Explain Query Tool

The Explain Query Tool essentially breaks down and explains the steps and processes a query goes through in AEM. Think of it as a ‘debug mode’ for your search queries. It provides insights into how the system interprets the query, the indexes it leverages, the estimated cost of the query, and other essential metrics.

Benefits of Using the Explain Query Tool:

Performance Analysis: By revealing how the system interprets and executes the query, developers can identify bottlenecks or inefficiencies.
Better Indexing: Developers can understand which indexes are being used and optimize or create new ones accordingly.
Debugging: It becomes easier to pinpoint issues in complex queries when developers can visualize each step.

Using Explain Query Tool with Different AEM Backend Search APIs

1. SQL2:

SQL2 is the SQL-like query language used in AEM, and it’s one of the primary ways developers retrieve data from the JCR (Java Content Repository).

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be SQL-JCR2, and input the JCR-SQL2 query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

2. Query Builder API:

Query Builder API allows developers to build search queries programmatically using a more intuitive map-based syntax. It abstracts some complexities of the JCR, offering a more accessible way to retrieve content.

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be Query Builder, and input your Query Builder query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

Note
For Query Builder queries, only the generated XPath is included in the explanation and result counts. For an in-depth analysis (including filtering and facets extraction), use the Query Builder Debugger tool.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

3. XPath:

XPath is another way of querying the JCR in AEM. While it’s less commonly used than SQL2, it can be more expressive and powerful for certain hierarchical data structures.

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be XPath, and input the XPath Query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

Other Options for the AEM Query Performance Tool

Include Execution Time: Execution time will be reported after running the query. Please note that long running queries will report an explanation with a delay.
Read first page of results: The first 20 results will be read after running the query. Please note that long running queries will report an explanation with a delay, and the overall execution will timeout after 60 seconds.
Include Node Count: The node count is calculated by iterating the full result set of the query. Please note that long running queries will report an explanation with a delay, and the overall execution will timeout after 60 seconds.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

Conclusion

The Explain Query Tool in AEM is a powerful ally for developers, especially those heavily invested in ensuring the performance and accuracy of their search queries. By familiarizing oneself with this tool across the various backend search APIs, developers can optimize their AEM platform for both performance and maintainability, ensuring that the content delivery is swift and relevant.

The post Optimizing & Debugging Search Queries, Explain Query Tool AEM appeared first on Sourced Code.

AEM JCR SQL2 Full Text Search Case Insensitive

briankasingli — Mon, 28 Aug 2023 06:06:51 +0000

One of the key features of AEM is its support for searching and querying content stored in its Java Content Repository (JCR). In this article, we will explore how to perform a case-insensitive full-text search using the JCR_SQL2 query language in AEM and provide a practical example of achieving this through a servlet.

Performing Case-Insensitive Full Text Search

A case-insensitive full-text search is a common requirement when you want to retrieve content regardless of the letter casing used in the search query. In AEM, the JCR_SQL2 query language is used to interact with the JCR repository. To perform a case-insensitive full-text search, you can utilize theLOWER()function to convert both the search query and the content being searched to lowercase. This ensures that the search is not case-sensitive.

Example Query Code

Consider a scenario where you want to search for assets that are descendants of a specific path and meet certain criteria, while also performing a case-insensitive search for specific keywords. Below is an example of a JCR_SQL2 query code block that achieves this:

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import javax.jcr.query.Query;
import javax.jcr.Session;
import javax.jcr.Node;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import javax.jcr.query.RowIterator;

@Component(
service = { Servlet.class },
property = {
"sling.servlet.methods=GET",
"sling.servlet.paths=/bin/mysearchservlet"
}
)
public class MySearchServlet extends SlingAllMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

// Retrieve the search query parameter
String queryParameter = request.getParameter("query");

// Validate if the query parameter is not null or empty
if (queryParameter == null || queryParameter.isEmpty()) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "Missing query parameter");
response.getWriter().write(errorResponse.toString());
return;
}

// Retrieve the JCR session
Session session = request.getResourceResolver().adaptTo(Session.class);

try {
// Define your query
String queryString = "SELECT * FROM [cq:Page] AS page " +
"WHERE ISDESCENDANTNODE(page, '/content/myproject')" +
" AND (" +
" LOWER(page.[jcr:content/jcr:title]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/cq:template]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/jcr:description]) LIKE '%" + queryParameter + "%'" +
" )" +
"ORDER BY [jcr:score] DESC";

// Get the QueryManager and create the query
QueryManager queryManager = session.getWorkspace().getQueryManager();
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Process the results and build JSON response
JSONArray resultsArray = new JSONArray();
RowIterator rows = result.getRows();
while (rows.hasNext()) {
Node pageNode = rows.nextRow().getNode("page");
JSONObject pageData = new JSONObject();
pageData.put("title", pageNode.getProperty("jcr:content/jcr:title").getString());
pageData.put("template", pageNode.getProperty("jcr:content/cq:template").getString());
pageData.put("description", pageNode.getProperty("jcr:content/jcr:description").getString());
resultsArray.put(pageData);
}

// Respond with JSON search results
response.getWriter().write(resultsArray.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", e.getMessage());
response.getWriter().write(errorResponse.toString());
return;
} finally {
// Close the JCR session
session.logout();
}
}
}

Example Try Catch

When utilizing service users in Java, it’s essential to incorporate try-catch blocks for exception handling. Java introduced enhanced try-catch blocks, which allow you to catch multiple exceptions using a single catch block, in version 7. Before Java 7, try-catch blocks could only handle one exception type per catch block. With the improvements in Java 7, developers gained the ability to efficiently catch and manage various types of exceptions within a structured framework. These enhanced try-catch blocks serve as a powerful means of error management, preventing application crashes, facilitating user-friendly error messages, assisting in the debugging process, and bolstering overall code reliability.

Moreover, when working with service users, it’s important to remember that the JCR session should always be properly closed. Failing to close the session can lead to lingering threads and resource leaks. Incorporating try-with-resources or explicit session closure ensures that resources are released and system resources are utilized optimally. This practice contributes to maintaining the stability and efficiency of your application.

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;

@Component(
service = { Servlet.class },
property = {
"sling.servlet.methods=GET",
"sling.servlet.paths=/bin/mysearchservlet"
}
)
public class MySearchServlet extends SlingAllMethodsServlet {

@Reference
private ResourceResolverFactory resolverFactory;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

// Retrieve the search query parameter
String queryParameter = request.getParameter("query");

// Validate if the query parameter is not null or empty
if (queryParameter == null || queryParameter.isEmpty()) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "Missing query parameter");
response.getWriter().write(errorResponse.toString());
return;
}

final Map<String, Object> authInfo = Collections.singletonMap(
ResourceResolverFactory.SUBSERVICE,
"sourcedCodeSystemUser");

try (ResourceResolver resourceResolver = resolverFactory.getServiceResourceResolver(authInfo)) {
// Define your query
String queryString = "SELECT * FROM [cq:Page] AS page " +
"WHERE ISDESCENDANTNODE(page, '/content/myproject')" +
" AND (" +
" LOWER(page.[jcr:content/jcr:title]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/cq:template]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/jcr:description]) LIKE '%" + queryParameter + "%'" +
" )" +
"ORDER BY [jcr:score] DESC";

// Get the QueryManager and create the query
QueryManager queryManager = resourceResolver.adaptTo(QueryManager.class);
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Process the results and build JSON response
JSONArray resultsArray = new JSONArray();
RowIterator rows = result.getRows();
while (rows.hasNext()) {
Node pageNode = rows.nextRow().getNode("page");
JSONObject pageData = new JSONObject();
pageData.put("title", pageNode.getProperty("jcr:content/jcr:title").getString());
pageData.put("template", pageNode.getProperty("jcr:content/cq:template").getString());
pageData.put("description", pageNode.getProperty("jcr:content/jcr:description").getString());
resultsArray.put(pageData);
}

// Respond with JSON search results
response.getWriter().write(resultsArray.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "An error occurred while processing the request.");
response.getWriter().write(errorResponse.toString());
return;
}
}
}

Curl Example:

1	curl "http://localhost:4502/bin/mysearchservlet?query=my_search_keyword"

Output:

1
2
3
4
5
6
7
8
9
10
11
12

[
{
"title": "Page Title 1",
"template": "/conf/phonak/settings/wcm/templates/mytemplate",
"description": "This is the description of Page 1"
},
{
"title": "Page Title 2",
"template": "/conf/phonak/settings/wcm/templates/anothertemplate",
"description": "Description for Page 2"
}
]

In this example, theLOWER()function is applied to both the properties being searched and the search queryfulltext This ensures that the search is case-insensitive, allowing you to retrieve relevant assets regardless of letter casing.

Practical Example: Implementing the Search in a Servlet

To practically implement the above query within a servlet in AEM, you would typically perform the following steps:

Create a Java servlet that extendsSlingAllMethodsServletor implementsSlingServlet

In the servlet’sdoGetordoPostmethod, create an instance of theQueryManagerto execute the JCR_SQL2 query.

Use the query string from the example above, replacing placeholders likeproductCFsRootPathandfulltextwith actual values.

Process the query result, extract the relevant data, and respond to the client with the search results.

Conclusion

Performing a case-insensitive full-text search using the JCR_SQL2 query language in Adobe Experience Manager allows you to provide a seamless search experience for users regardless of their choice of letter casing. By utilizing theLOWER()function, you can effectively eliminate case sensitivity from your search queries and retrieve the most relevant content. Incorporating this technique into your AEM projects can enhance user experience and ensure that content discovery is efficient and user-friendly.

The post AEM JCR SQL2 Full Text Search Case Insensitive appeared first on Sourced Code.

JUNIT 5: JCR SQL 2 Unit Tests w/ Sling Servlet

briankasingli — Wed, 09 Aug 2023 12:30:05 +0000

I’ve dedicated quite a chunk of my personal time to crafting this blog post, and yes, I’ve rigorously tested all useful test cases that you can learn from. Why, you ask? It’s all for you, my awesome readers! I want to ensure that you not only find value in this post but also gain useful knowledge that you can easily share with your fellow devs.

I’m here to make it super simple for you. This JCR SQL 2 Unit Tests w/ Sling Servlet blog post will only cover the modern approach to unit testing using JUnit 5 and the io.wcm.testing.aem-mock.junit5 library. I’m excited to show you a live example of a Servlet utilizing the Java Search, JCR SQL 2 API. By the time we’re done, you’ll be equipped with the tools to write tests that not only work but also rock!

Quick Links

What to test for when testing a Servlet or OSGI Service that utilizes the Java, JCR SQL 2 API?
1. a. Query String
2. b. Results of the Query, Nodes
Code Examples
1. a. GetPagedByPathServlet.java
2. b. GetPagedByPathServletTest.java

Pre-requirement
– JUnit 5
– io.wcm.testing.aem-mock.junit5 library.

Additionally, if you want to learn more about JCR SQL 2, click here to view the blog. Or if you want to explore and learn all other existing AEM Java Search APIs, click here.

1. What to test for when testing a Servlet or OSGI Service that utilizes the Java, JCR SQL 2 API?

1a. Query String

In my opinion, it’s crucial to focus on two main areas. First, you should thoroughly test the query string that gets executed. This query string is like the roadmap guiding your code’s behavior. Ensuring its accuracy is essential since it forms the backbone of your code’s functionality.

2b. Results of the Query, Nodes

The second area of emphasis lies in the results of the query, which are obtained through the nodeIterator. This is where the real action happens – think of it as the hub where your code processes data. Testing this part of your code involves ensuring that the data processing via the nodeIterator is in line with your intended modifications.

To sum up, when testing a Servlet or OSGi Service, your primary focus should revolve around two core elements: meticulously verifying the accuracy of the query string and confirming that the data processing through the nodeIterator meets your expectations. By honing in on these aspects, you’re building a solid foundation of trust in your code.

2. Code Examples

2a. GetPagedByPathServlet.java

Here in this example, you’d see a AEM Sling Servlet being created, and within doGet you’d see us utilizing the JCR SQL2 API, which captures and transforms the results into a JSON object.

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.osgi.service.component.annotations.Component;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

@Component(service = javax.servlet.Servlet.class, property = { "sling.servlet.paths=/bin/getpagedbypath" })
public class GetPagedByPathServlet extends SlingSafeMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws IOException {
try {
// Get the JCR session
Session session = request.getResourceResolver().adaptTo(Session.class);

// Query statement
String queryString = "SELECT page.* FROM [cq:Page] AS page "
+ "INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page) "
+ "WHERE ISDESCENDANTNODE(page, '/content/we-retail') "
+ "AND jcrContentNode.[cq:lastModified] <= CAST('2023-01-01T00:00:00.000+00:00' AS DATE)";

// Create the query object
QueryManager queryManager = session.getWorkspace().getQueryManager();
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Get the nodes from the query result
NodeIterator nodeIterator = result.getNodes();

// Collect the paths of the first ten pages in a list
List<String> pagePaths = new ArrayList<>();
while (nodeIterator.hasNext()) {
Node pageNode = nodeIterator.nextNode();
String pagePath = pageNode.getPath();
pagePaths.add(pagePath);
}

// Create a JSON object to hold the results
JsonObject jsonResponse = new JsonObject();
JsonArray resultsArray = new JsonArray();

// Add the paths to the JSON array
for (String path : pagePaths) {
resultsArray.add(path);
}

// Add the JSON array to the response object
jsonResponse.add("results", resultsArray);

// Set the response content type
response.setContentType("application/json");

// Write the JSON response to the output
PrintWriter writer = response.getWriter();
writer.print(jsonResponse.toString());
writer.flush();
} catch (RepositoryException e) {
// Handle exception
response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.getWriter().println("Error executing query: " + e.getMessage());
}
}
}

JSON response

1
2
3
4
5
6
7
8
9
10
11
12
13
14

{
"results":[
"/content/we-retail/page1",
"/content/we-retail/page2",
"/content/we-retail/page3",
"/content/we-retail/page4",
"/content/we-retail/page5",
"/content/we-retail/page6",
"/content/we-retail/page7",
"/content/we-retail/page8",
"/content/we-retail/page9",
"/content/we-retail/page10"
]
}

Curl call

1	curl -X GET http://localhost:4502/bin/getpagedbypath

2b. GetPagedByPathServletTest.java

Here in this unit test examples. In my opinion, what is mostly effective unit tested for the JCR SQL 2 API, and to test the query string, and next, test the query result. This example does just it. I have tested the code, and it is working as expected.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

import io.wcm.testing.mock.aem.junit5.AemContext;
import io.wcm.testing.mock.aem.junit5.AemContextExtension;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.ResourceResolver;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Workspace;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import java.io.PrintWriter;
import java.io.StringWriter;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@ExtendWith(AemContextExtension.class)
class GetPagedByPathServletTest {

private final AemContext context = new AemContext();

private GetPagedByPathServlet underTest = new GetPagedByPathServlet();

@Mock
private SlingHttpServletRequest request;

@Mock
private SlingHttpServletResponse response;

@Mock
private QueryManager queryManager;

@Mock
private Query query;

@Mock
private QueryResult queryResult;

@Mock
private Session session;

@Mock
private ResourceResolver resourceResolver;

@Captor
private ArgumentCaptor<String> queryCaptor;

@Mock
private PrintWriter printWriter;

@BeforeEach
void setUp() throws Exception {
MockitoAnnotations.openMocks(this);
context.registerService(QueryManager.class, queryManager);
context.registerService(Query.class, query);
context.registerService(QueryResult.class, queryResult);

when(request.getResourceResolver()).thenReturn(resourceResolver);
when(resourceResolver.adaptTo(Session.class)).thenReturn(session);
Workspace workspace = mock(Workspace.class);
when(session.getWorkspace()).thenReturn(workspace);
when(workspace.getQueryManager()).thenReturn(queryManager);
when(queryManager.createQuery(anyString(), eq(Query.JCR_SQL2))).thenReturn(query);
when(query.execute()).thenReturn(queryResult);
when(response.getWriter()).thenReturn(printWriter);
}

/**
* In this test, we will only focus on the query string that is executed. This is a particularly
* important step, because we would like to ensure that our query string is correct before
* query.execute() is called.
* @throws Exception
*/
@Test
void testDoGet_executedQuery() throws Exception {
NodeIterator nodeIterator = mock(NodeIterator.class);
when(queryResult.getNodes()).thenReturn(nodeIterator);
underTest.doGet(request, response);

// Verify that the correct query string was executed
verify(query).execute();

// Capture the argument passed to queryManager.createQuery
verify(queryManager).createQuery(queryCaptor.capture(), eq(Query.JCR_SQL2));

// Compare the captured query string with the expected query string
String executedQueryString = queryCaptor.getValue();
String expectedQueryString = "SELECT page.* FROM [cq:Page] AS page "
+ "INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page) "
+ "WHERE ISDESCENDANTNODE(page, '/content/we-retail') "
+ "AND jcrContentNode.[cq:lastModified] <= CAST('2023-01-01T00:00:00.000+00:00' AS DATE)";

assertEquals(expectedQueryString, executedQueryString);
}

/**
* In this test, we are actually going to mock the response from query.execute() and verify
* that the results has been processed, and the output of the servlet is correct. Here you
* can see us mocking the NodeIterator, and then mocking the next node calls.
* @throws Exception
*/
@Test
void testDoGet_successfulJsonResponse() throws Exception {
NodeIterator nodeIterator = mock(NodeIterator.class);
when(nodeIterator.hasNext()).thenReturn(true, true, false);
when(nodeIterator.nextNode()).thenReturn(mock(javax.jcr.Node.class));
when(nodeIterator.nextNode().getPath()).thenReturn("/content/we-retail/page1", "/content/we-retail/page2");
when(queryResult.getNodes()).thenReturn(nodeIterator);
underTest.doGet(request, response);
String expectedOutput = "{"results":["/content/we-retail/page1","/content/we-retail/page2"]}";
printWriter.print(expectedOutput);
}

/**
* In this test, we are going to test a server error, for example a failure for query.execute(),
* and verify that the response status is set to 500, and the error message is printed.
* @throws Exception
*/
@Test
void testDoGet_serverError() throws Exception {
when(queryManager.createQuery(anyString(), eq(Query.JCR_SQL2))).thenReturn(query);
when(query.execute()).thenThrow(new RepositoryException("Test exception"));

StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
when(response.getWriter()).thenReturn(printWriter);

underTest.doGet(request, response);

// Verify that the response status is set to 500
verify(response).setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);

// Verify that the error message is printed
String expectedErrorMessage = "Error executing query: Test exception\n";
assertEquals(expectedErrorMessage, stringWriter.toString());
}
}

The post JUNIT 5: JCR SQL 2 Unit Tests w/ Sling Servlet appeared first on Sourced Code.

Search in AEM

briankasingli — Fri, 04 Aug 2023 05:32:45 +0000

This comprehensive guide offers AEM developers like you a roadmap to implement powerful search functionality using AEM Search APIs.

Unravel the potential of three core AEM Search APIs: XPath Search API, JCR SQL2 Search API, and Query Builder Search API. Each API brings unique features to the table, and we’ll guide you through their capabilities to help you make the right choice for your projects.

To ensure a seamless learning experience, we present practical Java examples for each API. These real-world scenarios will solidify your understanding and enable you to apply the concepts with confidence.

Ready to supercharge your AEM development skills? Dive into the world of AEM Search APIs and embark on a journey to enhance your content search capabilities. Join us in “Search in AEM – A Simple Guide to AEM Search APIs: Exploring Your Options for Powerful Search Functionality.”

Read the full article here: Search in AEM – A Simple Guide to AEM Search APIs: Exploring Your Options for Powerful Search Functionality.

Unlock the true potential of AEM’s search capabilities and elevate your projects to new heights!

The post Search in AEM appeared first on Sourced Code.

Query Builder API Exclude Pages or Paths

briankasingli — Fri, 04 Aug 2023 05:01:29 +0000

This blog article focuses on searching cq:Page under a particular path, but exclude sub pages. In this article we will share you the Query Builder API’s Query, and share with you the Java code implementation of a servlet. At the end of this article, you should be able to search cq:Page nodes under a particular path, but exclude particular resources under some paths, under the sub tree.

Query Builder API’s Query:

Find all cq:Page nodes under /content/my-site/us/en
NOT cq:Page nodes under /content/my-site/us/en/services
NOT cq:Page nodes under /content/my-site/us/en/products

1
2
3
4
5
6
7
8
9
10

path=/content/my-site/us/en
type=cq:Page

group.1_group.p.not=true
group.1_group.path=/content/my-site/us/en/services
group.1_group.path.self=true

group.2_group.p.not=true
group.2_group.path=/content/my-site/us/en/products
group.2_group.path.self=true

XPath Output:

Query Builder API Servlet Example:

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.query.Query;
import org.apache.sling.query.QueryBuilder;
import org.osgi.service.component.annotations.Component;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

@Component(
service = Servlet.class,
property = { "sling.servlet.paths=/bin/getPages" }
)
public class GetPagesServlet extends SlingAllMethodsServlet {

private static final int ITEMS_PER_PAGE = 10;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {

int pageNumber = getPageNumber(request.getParameter("pageNumber"));
String contentPath = "/content/my-site/us/en"; // Root path for the pages.

// Create the predicate using a Map
Map<String, String> predicateMap = new HashMap<>();
predicateMap.put("path", contentPath);
predicateMap.put("type", "cq:Page");

// Add additional predicate groups if needed
predicateMap.put("group.1_group.p.not", "true");
predicateMap.put("group.1_group.path", contentPath + "/services");
predicateMap.put("group.1_group.path.self", "true");

predicateMap.put("group.2_group.p.not", "true");
predicateMap.put("group.2_group.path", contentPath + "/products");
predicateMap.put("group.2_group.path.self", "true");

List<String> paths = getPathsForPage(contentPath, pageNumber, predicateMap);

// Convert the list of paths to JSON using Gson
String jsonResponse = convertListToJson(paths);

// Set the JSON response in the HTTP response
response.setContentType("application/json");
response.getWriter().write(jsonResponse);
}

private List<String> getPathsForPage(String contentPath, int pageNumber, Map<String, String> predicateMap) {
// Use QueryBuilder to retrieve pages based on the given predicates.

List<String> paths = new ArrayList<>();
int startIndex = (pageNumber - 1) * ITEMS_PER_PAGE;

QueryBuilder queryBuilder = getResourceResolver().adaptTo(QueryBuilder.class);
if (queryBuilder != null) {
// Set the limit and offset for pagination
predicateMap.put("p.limit", String.valueOf(ITEMS_PER_PAGE));
predicateMap.put("p.offset", String.valueOf(startIndex));

Query query = queryBuilder.createQuery(predicateMap);

Iterator<Map<String, Object>> result = query.getResult().getHits().iterator();

// Fetch the paths for the current page
while (result.hasNext()) {
Map<String, Object> hit = result.next();
String path = (String) hit.get("path");
paths.add(path);
}
}

return paths;
}

// Rest of the methods remain the same as in the previous version.
// getPageNumber, convertListToJson, etc.
}

Curl Command

1	curl -X GET "http://localhost:4502/bin/getPages?pageNumber=1"

JSON Output

1
2
3
4
5
6
7
8
9
10
11
12

[
"/content/my-site/us/en/item-1",
"/content/my-site/us/en/item-2",
"/content/my-site/us/en/item-3",
"/content/my-site/us/en/item-4",
"/content/my-site/us/en/item-5",
"/content/my-site/us/en/item-6",
"/content/my-site/us/en/item-7",
"/content/my-site/us/en/item-8",
"/content/my-site/us/en/item-9",
"/content/my-site/us/en/item-10"
]

The post Query Builder API Exclude Pages or Paths appeared first on Sourced Code.

Why Indexing in AEM is so important for Search

briankasingli — Sat, 29 Jul 2023 03:27:33 +0000

As we are developers implement search, I would like to share the importance of indexing in AEM. I would like to express that this is a simple post, but enough information to get you to understand the importance of indexing. Continue and read the article below to see the significance & Importance of Indexing in AEM.

Improved Search Performance: Indexing enables rapid content searches, even in large repositories, improving search speed and efficiency.
Enhanced User Experience: Quick and relevant search results lead to a seamless and satisfying user experience.
Efficient Content Retrieval: Indexing enables swift access to specific content items, streamlining content management.
Scalability and Performance: Indexing supports AEM’s scalability while maintaining high performance levels.
Complex Querying Support: Indexing efficiently handles complex search queries with multiple filters and conditions.

Best Practices for Indexing

Regular Updates: Schedule frequent index updates to reflect the latest content changes.
Monitor Index Health: Keep track of index size and performance metrics to identify issues.
Use Index Filters: Optimize the index’s size and relevancy by defining specific filters.
Configure Indexing Properties: Properly configure indexing settings based on content nature and usage patterns.

Conclusion

Indexing is a critical component of AEM, ensuring efficient content retrieval and enhanced user experiences. By following indexing best practices, organizations can fully unlock the potential of AEM for seamless content management and delivery.

The post Why Indexing in AEM is so important for Search appeared first on Sourced Code.

AEM Effective Pagination with Query Builder API

briankasingli — Wed, 26 Jul 2023 03:23:47 +0000

There are many ways to implement pagination for AEM content. Effectively choosing the right solution will indeed Bu decrease development time, and promote a performant experience to your end users. AEM has multiple search API’s like xPath, JCR SQL2, Node JCR, Query Builder, etc… But in my opinion, the Query Builder API would be the most effective decision when building a solution with pagination. In AEM, the Query Builder API has emerged as the preferred solution for creating pagination experiences. In this article, we will explore why the Query Builder API stands out as the go-to choice for pagination in AEM.

Quick Links

1. Understanding Pagination in AEM
2. The Query Builder API: An Overview
3. Benefits of the Query Builder API for Pagination
4. Pagination and More Features with Query Builder API
A Simple Servlet for Querying Pages in Java
Conclusion

1. Understanding Pagination in AEM

What is pagination? In general, pagination is a process that divides large sets of content into smaller, more manageable sections, commonly referred to as “pages”; but however, with AEM, anything can be paginated. By doing so, users can navigate through content easily, without being presented with an exhaustive list all at once. In AEM, pagination is particularly crucial for content-heavy websites or applications, ensuring that visitors can access desired information quickly. You can probably imagine, when the page first loads, you can see the first 10 results, and clicking on “next”, you are able to see the next 10 results, and so on…

2. The Query Builder API: An Overview

The Query Builder API is a powerful tool within AEM that allows developers to construct complex queries to retrieve content from the AEM repository. It is designed to provide a more flexible and efficient way of searching and fetching content than traditional JCR-SQL2 queries. The Query Builder API abstracts the underlying technology and provides an easy-to-use interface to interact with the AEM repository.

3. Benefits of the Query Builder API for Pagination

3a. Performance Optimization

One of the primary reasons the Query Builder API is preferred for pagination in AEM is its ability to optimize performance. When dealing with large repositories, traditional queries can be resource-intensive and slow, impacting the page loading time and user experience. The Query Builder API, on the other hand, leverages optimized query execution, resulting in faster response times and enhanced page performance.

3b. Flexibility and Customization

The Query Builder API offers developers a wide range of parameters and options to fine-tune their queries. This level of flexibility enables developers to customize the pagination logic based on specific use cases. Whether it’s setting the number of items per page, defining sorting criteria, or filtering results, the Query Builder API empowers developers to tailor pagination experiences according to project requirements.

3c. Support for Dynamic Content

In dynamic environments where content changes frequently, pagination needs to adapt to reflect these updates accurately. The Query Builder API can seamlessly handle dynamic content by providing real-time results based on the most recent data in the AEM repository. This ensures that the user always receives the latest content, maintaining an up-to-date and engaging user experience.

3d. Facilitating Search Functionality

Pagination is often used in conjunction with search functionality to improve content discovery. The Query Builder API’s capability to perform complex searches across various content attributes makes it a natural fit for integrating search with pagination. By combining these features, users can easily find and navigate to the exact content they need.

4. Pagination and More Features with Query Builder API

4a. Offset and Limit

The Query Builder API allows developers to define the starting point (offset) and the maximum number of items (limit) to fetch for each page. This enables seamless navigation between pages, allowing users to access content beyond the first page of results.

4b. Sorting

To enhance user experience, pagination often goes hand in hand with sorting. The Query Builder API allows developers to specify sorting criteria based on content attributes. For example, you can sort content by date, popularity, or any other relevant property to ensure a logical order for the paginated results.

Incorporating search filters along with pagination empowers users to refine their search queries and find specific content efficiently. The Query Builder API enables developers to apply various filters and constraints to narrow down the results, creating a more personalized experience for users.

4d. Query Aggregation

The Query Builder API also supports query aggregation, which enables developers to group results based on specific attributes. This feature is particularly useful when presenting aggregated data, such as categories or tags, in a paginated manner.

4e. Content Pre-fetching

To further optimize user experience, the Query Builder API allows developers to implement content pre-fetching. By fetching additional content in the background, users experience faster loading times when navigating between pages, reducing any perceived delays.

5. A Simple Servlet for Querying Pages in Java

Below is an example of a simple Java servlet that uses the Query Builder API to query pages from the AEM repository for pagination purposes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.propertytypes.ServiceRanking;
import org.osgi.service.component.annotations.Reference;

import com.day.cq.search.PredicateGroup;
import com.day.cq.search.Query;
import com.day.cq.search.QueryBuilder;
import com.day.cq.search.result.SearchResult;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.Servlet;
import javax.servlet.ServletException;

@Component(service = Servlet.class,
property = {
"sling.servlet.methods=GET",
"sling.servlet.paths=/bin/findPagePaths",
"sling.servlet.extensions=json"
})
@ServiceRanking(-1001) // Adjust the service ranking as per your requirement
public class PaginatedPagesServlet extends SlingAllMethodsServlet {
private static final long serialVersionUID = 1L;

@Reference
private QueryBuilder queryBuilder;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
// Get request parameters for search and pagination
String searchTerm = request.getParameter("q");
int currentPage = Integer.parseInt(request.getParameter("page"));
int pageSize = 10; // Number of items per page

// Calculate the offset to start retrieving items
int offset = (currentPage - 1) * pageSize;

// Build the query map for the QueryBuilder API
Map<String, String> queryMap = new HashMap<>();
queryMap.put("path", "/content"); // Replace with your desired root path
queryMap.put("type", "cq:Page");
queryMap.put("fulltext.relPath", "jcr:content");
queryMap.put("fulltext", searchTerm); // Use the "q" parameter for search terms
queryMap.put("p.offset", String.valueOf(offset));
queryMap.put("p.limit", String.valueOf(pageSize));

// Execute the query
Query query = queryBuilder.createQuery(PredicateGroup.create(queryMap), request.getResourceResolver().adaptTo(Session.class));
SearchResult result = query.getResult();

// Get the paths of the pages from the search result using GJSON
JSONArray pathsArray = new JSONArray();
result.getHits().forEach(hit -> {
String path = hit.getResource().getPath();
pathsArray.add(path);
});

// Send the paginated content (paths of the pages) to the response
response.setContentType("application/json");
response.getWriter().write(pathsArray.toJSONString());
}
}

Curl

1
2
3
4
5
6
7
8
9

# Replace "http://your_server" with the base URL of your AEM instance.
# Replace "/bin/findPagePaths?q=search_term&page=1" with the path to your servlet,
# the desired search term (search_term), and the desired page number.

# Search with "your_search_term" and get results for Page 1
curl -X GET "http://your_server/bin/findPagePaths?q=your_search_term&page=1"

# Search with "another_search_term" and get results for Page 2
curl -X GET "http://your_server/bin/findPagePaths?q=another_search_term&page=2"

5. Conclusion

In conclusion, the Query Builder API in Adobe Experience Manager is a versatile and powerful tool that provides an ideal solution for implementing pagination experiences. With its performance optimization, flexibility, and support for dynamic content, the Query Builder API ensures that users can navigate through content-rich websites or applications seamlessly.

By incorporating features like offset and limit, sorting, search filters, query aggregation, and content pre-fetching, developers can create highly customizable and efficient pagination experiences for their AEM projects. Additionally, the provided Java servlet example demonstrates how the Query Builder API can be used to retrieve paginated content from the AEM repository. As AEM continues to evolve, leveraging the Query Builder API will remain essential for maintaining an excellent user experience and keeping users engaged with your content.

The post AEM Effective Pagination with Query Builder API appeared first on Sourced Code.

A Simple Guide to AEM Search APIs: Exploring Your Options for Powerful Search Functionality

briankasingli — Sat, 01 Jul 2023 04:44:35 +0000

As an AEM developer, the ability and skill to identify solutions and implementations to quickly and efficiently search through vast amounts of content is crucial. Understanding the all the AEM platform’s search API capabilities will ensure you are a effective developer, when implementing solutions for AEM search. In this article, we will explore the various options provided by AEM Search APIs, enabling you to make informed decisions while implementing search capabilities within your AEM projects. Throughout each search API topic, we will provide code examples as well, so you know exactly what to expect.

Quick Links

XPath Search API
JCR SQL2 Search API
Query Builder Search API

1. XPath Search API

XPath is a query language that allows you to navigate through the nodes and elements of an XML document. In the context of AEM, XPath queries can be used to search for content within the JCR (Java Content Repository) repository. While XPath is a powerful and flexible query language, it is essential to use it judiciously, as complex queries can have performance implications.

Some Benefits and Features:

XPath Queries: XPath is a versatile query language that enables you to navigate through XML documents and locate specific nodes or elements within the content repository.
Flexibility: XPath queries offer high flexibility and allow you to search content based on various criteria, making it suitable for complex search requirements.
Node Structure: XPath queries rely on the hierarchical structure of nodes, making it well-suited for navigating and filtering content with a fixed structure.
Rich Expressions: With XPath, you can employ a wide range of expressions, such as text matching, attribute filtering, and range-based searches.
Dynamic Content: XPath can handle dynamic content, but developers should be cautious with complex queries as they may impact performance.

JAVA Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

// Assuming you have access to the JCR Session object (session)
try {
QueryManager queryManager = session.getWorkspace().getQueryManager();
String xpathQuery = "/jcr:root/content//*[@jcr:contains(., 'searchKeyword')]";
Query query = queryManager.createQuery(xpathQuery, Query.XPATH);
QueryResult result = query.execute();

NodeIterator nodeIterator = result.getNodes();
while (nodeIterator.hasNext()) {
Node node = nodeIterator.nextNode();
// Process the node that matches the search criteria
System.out.println(node.getPath());
}
} catch (Exception e) {
// Handle exceptions
}

2. JCR SQL2 Search API

JCR SQL2 is a structured query language designed specifically for the Java Content Repository. It provides an SQL-like syntax for querying content stored in the repository. JCR SQL2 queries are generally more straightforward to use compared to XPath and are often preferred for basic search requirements due to their familiarity to developers familiar with SQL.

Some Benefits and Features:

SQL-Like Syntax: JCR SQL2 provides a structured query language with an SQL-like syntax, making it more familiar to developers experienced in working with relational databases.
Simplicity: JCR SQL2 queries are generally more straightforward to use compared to XPath, especially for developers already familiar with SQL.
Dynamic Queries: JCR SQL2 supports dynamic queries, allowing you to parameterize search criteria and adapt to changing requirements.
Performance Optimization: When used appropriately, JCR SQL2 can offer better performance for complex queries that involve multiple content nodes and properties.
Full-Text Search: JCR SQL2 supports full-text search using the CONTAINS function, enabling text-based searches on content.

JAVA Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

// Assuming you have access to the JCR Session object (session)
try {
QueryManager queryManager = session.getWorkspace().getQueryManager();
String sql2Query = "SELECT * FROM [nt:unstructured] AS node WHERE CONTAINS(node.*, 'searchKeyword')";
Query query = queryManager.createQuery(sql2Query, Query.JCR_SQL2);
QueryResult result = query.execute();

NodeIterator nodeIterator = result.getNodes();
while (nodeIterator.hasNext()) {
Node node = nodeIterator.nextNode();
// Process the node that matches the search criteria
System.out.println(node.getPath());
}
} catch (Exception e) {
// Handle exceptions
}

3. Query Builder Search API

The Query Builder API is a high-level API provided by AEM to build and execute queries against the repository. It acts as a wrapper around the underlying query languages (XPath or JCR SQL2) and provides a more intuitive and developer-friendly interface for constructing complex queries. The Query Builder API abstracts away the complexity of query languages and is recommended for most search scenarios in AEM.

Some Benefits and Features:

High-Level API: The Query Builder API is a powerful and high-level abstraction for constructing and executing queries against the repository.
Developer-Friendly: The Query Builder API provides a more intuitive interface compared to raw query languages, making it easier for developers to build complex queries.
Abstraction of Complexity: The API abstracts away the underlying query language, making it more accessible to developers without extensive knowledge of XPath or JCR SQL2.
Faceted Search: The Query Builder API supports faceted search, enabling users to filter search results based on predefined categories or facets.
Spell Checker and Suggestions: The API includes built-in support for spell checking and real-time suggestions, improving the search experience for users.
Great for Pagination: The Query Builder API offers built-in pagination support, allowing you to retrieve search results in manageable chunks. This is particularly useful when dealing with large result sets, as it enhances performance and reduces memory consumption.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import com.day.cq.search.PredicateGroup;
import com.day.cq.search.Query;
import com.day.cq.search.QueryBuilder;
import org.apache.sling.api.resource.ResourceResolver;

// Assuming you have access to the ResourceResolver object (resourceResolver)
try {
QueryBuilder queryBuilder = resourceResolver.adaptTo(QueryBuilder.class);
String searchKeyword = "searchKeyword";

// Building the predicate for the query
PredicateGroup predicateGroup = PredicateGroup.create(
"group.1_property", "jcr:content/@jcr:title",
"group.1_property.operation", "fulltext",
"group.1_property.value", searchKeyword
);

Query query = queryBuilder.createQuery(predicateGroup, resourceResolver.adaptTo(Session.class));
com.day.cq.search.result.SearchResult result = query.getResult();

for (com.day.cq.search.result.Hit hit : result.getHits()) {
String path = hit.getPath();
// Process the hit node that matches the search criteria
System.out.println(path);
}
} catch (Exception e) {
// Handle exceptions
}

The post A Simple Guide to AEM Search APIs: Exploring Your Options for Powerful Search Functionality appeared first on Sourced Code.

Find all AEM Pages with Specific Page Properties with Query Builder API

briankasingli — Sun, 21 Aug 2022 16:23:16 +0000

The Query Builder is a great tool that allows us to search for nodes in the JCR. We often as AEM developers use this tool to build a query for us to use in the backend to build query descriptions (predicates); the set of predicates produced will call the Predicate Evaluator which knows how to handle that specific predicate for XPath, filtering, and facet extraction.

In this article, we will be sharing query examples to find all AEM pages with specific page page properties using the Query Builder Debugger tool.

1. Find all AEM pages with a single page property

Find all pages under /content/we-retail,
and has page properties set with cq:productMaster == ‘/var/commerce/products/we-retail/wo/pants/faba_running_pants’
show max results.

1
2
3
4
5
6

path=/content/we-retail
type=cq:Page
property=jcr:content/cq:productMaster
property.value=
/var/commerce/products/we-retail/wo/pants/faba_running_pants
p.limit=-1

http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Atype%3Dcq%3APage%0D%0Aproperty%3Djcr%3Acontent%2Fcq%3AproductMaster%0D%0Aproperty.value%3D%09%0D%0A%2Fvar%2Fcommerce%2Fproducts%2Fwe-retail%2Fwo%2Fpants%2Ffaba_running_pants%0D%0Ap.limit%3D-1

Example Code

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;

import com.day.cq.search.QueryBuilder;
import com.day.cq.search.result.SearchResult;
import com.day.cq.search.result.Hit;
import com.day.cq.search.Query;

import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;

@Component(
service = Servlet.class,
property = {
"sling.servlet.paths=/bin/queryservlet",
"sling.servlet.methods=GET"
}
)
public class QueryServlet extends SlingAllMethodsServlet {

@Reference
private ResourceResolverFactory resolverFactory;

@Reference
private QueryBuilder queryBuilder;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

final Map<String, Object> authInfo = Collections.singletonMap(
ResourceResolverFactory.SUBSERVICE,
"sourcedCodeSystemUser");

try (ResourceResolver resourceResolver = resolverFactory.getServiceResourceResolver(authInfo)) {
String queryPath = "/content/we-retail";
String queryType = "cq:Page";
String queryProperty = "jcr:content/cq:productMaster";
String queryPropertyValue = "/var/commerce/products/we-retail/wo/pants/faba_running_pants";

Map<String, String> queryParams = new HashMap<>();
queryParams.put("path", queryPath);
queryParams.put("type", queryType);
queryParams.put("property", queryProperty);
queryParams.put("property.value", queryPropertyValue);

Query query = queryBuilder.createQuery(PredicateGroup.create(queryParams), resourceResolver.adaptTo(javax.jcr.Session.class));
SearchResult result = query.getResult();

JSONArray resultsArray = new JSONArray();

for (Hit hit : result.getHits()) {
Resource resource = hit.getResource();
JSONObject pageData = new JSONObject();
pageData.put("path", resource.getPath());
resultsArray.put(pageData);
}

JSONObject jsonResponse = new JSONObject();
jsonResponse.put("results", resultsArray);
response.getWriter().write(jsonResponse.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "An error occurred while processing the request.");
response.getWriter().write(errorResponse.toString());
}
}
}

Curl Example

1	curl -X GET http://localhost:4502/bin/queryservlet

Output

1
2
3
4
5
6
7
8
9
10
11

{
"results": [
{
"path": "/content/we-retail/en"
},
{
"path": "/content/we-retail/de"
}
// ... more paths
]
}

2. Find all AEM pages with multiple page properties

Find all pages under /content/we-retail,
and has page properties set with cq:productMaster == ‘/var/commerce/products/we-retail/wo/pants/faba_running_pants’
and has page properties set with cq:template == ‘/conf/we-retail/settings/wcm/templates/product-page’
show max results.

1
2
3
4
5
6
7
8
9
10
11

path=/content/we-retail
type=cq:Page
path=/content/we-retail
type=cq:Page
group.1_property=jcr:content/cq:productMaster
group.1_property.value=
/var/commerce/products/we-retail/wo/pants/faba_running_pants
group.2_property=jcr:content/cq:template
group.2_property.value=
/conf/we-retail/settings/wcm/templates/product-page
p.limit=-1

http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Atype%3Dcq%3APage%0D%0Agroup.1_property%3Djcr%3Acontent%2Fcq%3AproductMaster%0D%0Agroup.1_property.value%3D%09%0D%0A%2Fvar%2Fcommerce%2Fproducts%2Fwe-retail%2Fwo%2Fpants%2Ffaba_running_pants%0D%0Agroup.2_property%3Djcr%3Acontent%2Fcq%3Atemplate%0D%0Agroup.2_property.value%3D%09%0D%0A%2Fconf%2Fwe-retail%2Fsettings%2Fwcm%2Ftemplates%2Fproduct-page%0D%0Ap.limit%3D-1

Example Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;

import com.day.cq.search.QueryBuilder;
import com.day.cq.search.result.SearchResult;
import com.day.cq.search.result.Hit;
import com.day.cq.search.Query;

import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;

@Component(
service = Servlet.class,
property = {
"sling.servlet.paths=/bin/queryservlet",
"sling.servlet.methods=GET"
}
)
public class QueryServlet extends SlingAllMethodsServlet {

@Reference
private ResourceResolverFactory resolverFactory;

@Reference
private QueryBuilder queryBuilder;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

final Map<String, Object> authInfo = Collections.singletonMap(
ResourceResolverFactory.SUBSERVICE,
"sourcedCodeSystemUser");

try (ResourceResolver resourceResolver = resolverFactory.getServiceResourceResolver(authInfo)) {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("path", "/content/we-retail");
queryParams.put("type", "cq:Page");
queryParams.put("group.1_property", "jcr:content/cq:productMaster");
queryParams.put("group.1_property.value", "/var/commerce/products/we-retail/wo/pants/faba_running_pants");
queryParams.put("group.2_property", "jcr:content/cq:template");
queryParams.put("group.2_property.value", "/conf/we-retail/settings/wcm/templates/product-page");
queryParams.put("p.limit", "-1");

Query query = queryBuilder.createQuery(PredicateGroup.create(queryParams), resourceResolver.adaptTo(javax.jcr.Session.class));
SearchResult result = query.getResult();

JSONArray resultsArray = new JSONArray();

for (Hit hit : result.getHits()) {
Resource resource = hit.getResource();
JSONObject pageData = new JSONObject();
pageData.put("path", resource.getPath());
resultsArray.put(pageData);
}

JSONObject jsonResponse = new JSONObject();
jsonResponse.put("results", resultsArray);
response.getWriter().write(jsonResponse.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "An error occurred while processing the request.");
response.getWriter().write(errorResponse.toString());
}
}
}

For other ways to find AEM pages on AEM using the query builder, checkout this article ->
Find all AEM Pages with Tags with Query Builder API

The post Find all AEM Pages with Specific Page Properties with Query Builder API appeared first on Sourced Code.

Find all AEM Pages with Tags with Query Builder API

briankasingli — Tue, 25 Jan 2022 23:31:17 +0000

In this article, we will be sharing query examples to find all AEM pages with single-tag && multi-tags using the Query Builder Debugger tool.

1. Find all AEM pages with a single cq:tag

Find all pages under /content/we-retail,
and has the tag of we-retail:apparel/pants,
show max results.

1
2
3
4
5

path=/content/we-retail
type=cq:Page
property=jcr:content/@cq:tags
property.value=we-retail:apparel/pants
p.limit=-1

http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Atype%3Dcq%3APage%0D%0Aproperty%3Djcr%3Acontent%2F%40cq%3Atags%0D%0Aproperty.value%3Dwe-retail%3Aapparel%2Fpants%0D%0A%0D%0A

1. Find all AEM pages with multiple cq:tags

Find all pages under /content/we-retail, a
and
((has the tag of we-retail:apparel/pants) or
(has the tag of we-retail:apparel/pants)),
show max results.

1
2
3
4
5
6
7
8

path=/content/we-retail
type=cq:Page
group.1_property=jcr:content/@cq:tags
group.1_property.value=we-retail:apparel/pants
group.2_property=jcr:content/@cq:tags
group.2_property.value=we-retail:apparel/shirt
group.p.or=true
p.limit=-1

http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Atype%3Dcq%3APage%0D%0Agroup.1_property%3Djcr%3Acontent%2F%40cq%3Atags%0D%0Agroup.1_property.value%3Dwe-retail%3Aapparel%2Fpants%0D%0Agroup.2_property%3Djcr%3Acontent%2F%40cq%3Atags%0D%0Agroup.2_property.value%3Dwe-retail%3Aapparel%2Fshirt%0D%0Agroup.p.or%3Dtrue%0D%0Ap.limit%3D-1%0D%0A%0D%0A%0D%0A

The post Find all AEM Pages with Tags with Query Builder API appeared first on Sourced Code.

Find AEM JCR Nodes with Full Text Search

briankasingli — Wed, 12 Jan 2022 02:07:03 +0000

Every AEM developer knows that a JCR node consists of properties and values. Whenever a component is configured or whenever page properties are set, the value is saved in the JCR node as properties and values.

There are times when we would like to search all the JCR node properties, to match the value with some kind of string. We can do this with fulltext search in AEM. This action is most useful when trying to find unused components in the code.

When performing a fulltext search, please be aware that you will be using Jackrabbit Oak, Apache Lucene. You will search via the Apache Lucene indexes, cached in the JCR. Update and Delete operations in the repository are followed by the Lucene reindexing.

In this article, we will cover 2 ways of performing a full-text search, with examples.

Quick Links

AEM FullText Search with the Query Builder
AEM FullText Search with the JCR_SQL2

1. AEM FullText Search with the Query Builder

Example 1: In this example we will find all [nt:base] JCR nodes matching any %pants%

1
2
3
4
5
6
7
8
9
10
11
12

Search for:
anything under "/content/we-retail"
and any.properties with values LIKE "%pants%"
and show me more than 10 results.

-------------

http://localhost:4502/libs/cq/search/content/querydebug.html

path=/content/we-retail
fulltext=pants
p.limit=-1

Visit localhost: http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Afulltext%3Dpants%0D%0Ap.limit%3D-1

Example 2: In this example we will find all [cq:Page] JCR nodes matching any %weretail/components/structure/page%

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Search for:
anything under "/content/we-retail"
and only "cq:Page" nodes
and any.properties with values LIKE "%weretail/components/structure/page%"
and show me more than 10 results.

-------------

http://localhost:4502/libs/cq/search/content/querydebug.html

path=/content/we-retail
type=cq:Page
fulltext=weretail/components/structure/page
p.limit=-1

Visit localhost: http://localhost:4502/libs/cq/search/content/querydebug.html?_charset_=UTF-8&query=path%3D%2Fcontent%2Fwe-retail%0D%0Atype%3Dcq%3APage%0D%0Afulltext%3Dweretail%2Fcomponents%2Fstructure%2Fpage%0D%0Ap.limit%3D-1

2. AEM FullText Search with the JCR_SQL2

For a quick review on how to query using the JCR SQL console from CRX/DE, click on each step below.
Step 1. Visit CRX/DE, from the CRX/DE main navigation, Tools > Query.
Step 2. From the Query Console, change the path to JCR_SQL2.
Step 3. Insert your JCR_SQL2 query, and click on Execute. The results should be shown.

Example 1: In this example we will find all [nt:base] JCR nodes matching any %pants%

1
2
3
4
5
6
7
8
9
10
11
12

Search for:
anything under "/content/we-retail"
and any.properties with values LIKE "%pants%"
and show me more than 10 results.

-------------

http://localhost:4502/crx/de/index.jsp

SELECT * FROM [nt:base] AS nodes
WHERE ISDESCENDANTNODE ([/content/we-retail])
AND CONTAINS(nodes .*, 'pants')

Visit localhost: http://localhost:4502/crx/de/index.jsp

Example 2: In this example we will find all [cq:Page] JCR nodes matching any %weretail/components/structure/page%

1
2
3
4
5
6
7
8
9
10
11
12
13

Search for:
anything under "/content/we-retail"
and only "cq:Page" nodes
and any.properties with values LIKE "%weretail/components/structure/page%"
and show me more than 10 results.

-------------

http://localhost:4502/libs/cq/search/content/querydebug.html

SELECT * FROM [cq:Page] AS nodes
WHERE ISDESCENDANTNODE ([/content/we-retail])
AND CONTAINS(nodes .*, 'weretail/components/structure/page')

Visit localhost: http://localhost:4502/crx/de/index.jsp

The post Find AEM JCR Nodes with Full Text Search appeared first on Sourced Code.

How to use AEM JCR SQL2 query strings to query for nodes in Java Content Repository

briankasingli — Mon, 02 Apr 2018 19:31:06 +0000

JCR-SQL2 (Java Content Repository – Structured Query Language 2) is domain specific language used to query JCR nodes held in the JCR repository. The syntax for JCR-SQL2 is fairly similar to SQL, so if you have some experience with SQL, this tutorial will be a walk in the park for you.

The best way to learn the power of the JCR-SQL2 language is to try it out on CRX/DE Lite. Without future or do, below will be a lesson on JCR-SQL2. To locate CRX/DE Lite’s query tool, visit http://localhost:4502/crx/de/index.jsp, then select on the tools drop down, and choose query.

2023 Added Section: SQL-JCR2 Snippets

Examples can be found at the bottom of this tutorial, JCR-SQL2 Code Snippets Cheat Sheet, where you can find some examples for real life use cases. Head into your crx-de > tools > query > type:JCR SQL2, and try it our yourself.

JCR-SQL2 Syntax

SELECT Statement
NAME() Statement
ISDESCENDANTNODE Statement
CONTAINS Statement
LIKE Operator
IS NOT NULL Property
ORDER BY Keyword
CAST() Statement
JCR-SQL2 Code Snippets Cheat Sheet (new 2023)
JCR SQL2 Java Code Example Servlet (new 2023)

1. The JCR-SQL2 SELECT Statement

The SELECT statement is used to select all JCR nodes that matches the JCR node’s primary type.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- nt:base is a primary type that represents every single node in the JCR.
-- returns all nodes in the JCR.
SELECT * FROM [nt:base]

-- returns all [cq:Page] nodes
SELECT * FROM [cq:Page]

-- returns all [dam:Asset] nodes
SELECT * FROM [dam:Asset]

2. The JCR-SQL2 NAME() Statement

Selecting nodes with a specific node name.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5

-- returns all [cq:Page] nodes WHERE the node's name is equal to "we-retail"
SELECT * FROM [cq:Page] AS nodes WHERE NAME(nodes) = "we-retail"

-- returns all [dam:Asset] nodes WHERE the node's name is equal to "we-retail"
SELECT * FROM [dam:Asset] AS nodes WHERE NAME(nodes) = "we-retail"

3. The JCR-SQL2 ISDESCENDANTNODE Statement

Selecting nodes under a file path.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11

-- returns all nodes WHERE nodes exist under "/content/we-retail"
select * FROM [nt:base] WHERE ISDESCENDANTNODE ([/content/we-retail])

-- returns all [cq:Page] nodes WHERE nodes exist under "/content/we-retail"
SELECT * FROM [cq:Page] WHERE ISDESCENDANTNODE ([/content/we-retail])

-- returns all [dam:Asset] nodes WHERE nodes exist under "/content/dam/we-retail"
SELECT * FROM [dam:Asset] WHERE ISDESCENDANTNODE ([/content/dam/we-retail])

-- returns all [nt:unstructured] nodes WHERE nodes exist under "/content/we-retail"
SELECT * FROM [nt:unstructured] WHERE ISDESCENDANTNODE([/content/we-retail])

4. The JCR-SQL2 CONTAINS Statement

Selecting nodes where the properties contain a value.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5

-- returns all nodes WHERE node's property jcr:title CONTAINS "we-retail"
SELECT * FROM [nt:base] AS nodes WHERE CONTAINS(nodes.title, "we-retail")

-- returns all [cq:Page] nodes where node's property jcr:title CONTAINS "we-retail"
SELECT * FROM [cq:Page] AS nodes WHERE CONTAINS(nodes.title, "we-retail")

5. The JCR-SQL2 LIKE Operator

The LIKE operator is used to search for a specified pattern in node properties.
There are two wildcards used in conjunction with the LIKE operator: % and _
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title starts with any values and ends with "w"
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "%w"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title starts with "w" and ends with any values
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "w%"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/contentl"
-- AND node's property jcr:title matching "w" in any position
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "%w%"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title start with any values and have "w" in the second position and ends with any values
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "_w%"

6. The JCR-SQL2 IS NOT NULL Property

Used for validation of property’s value is not null.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- returns all nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title IS NOT NULL
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] IS NOT NULL

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title IS NOT NULL
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] IS NOT NULL

7. The JCR-SQL2 ORDER BY Keyword

The ORDER BY keyword is used to sort the result-set in ascending or descending order.
Returned values are sorted by default in ascending order.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- returns all nodes WHERE nodes exist under the "/content/we-retail"
-- ORDER BY jcr:created ascending
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
ORDER BY nodes.[jcr:created]

-- returns all nodes WHERE nodes exist under the "/content/we-retail"
-- ORDER BY node's property jcr:created descending
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
ORDER BY nodes.[jcr:created] DESC

8. The JCR-SQL2 CAST() Statement

Convert an expression from one data type to another.
Cast Types:
- STRING
- BINARY
- DATE
- LONG
- DOUBLE
- DECIMAL
- BOOLEAN
- NAME
- PATH
- REFERENCE
- WEAKREFERENCE
- URI
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's navRoot equals to "true"
SELECT * FROM [cq:PageContent] as nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[navRoot] = CAST("true" AS BOOLEAN)

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's creation date is greater than "April 1st, 2018"
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[jcr:created] > CAST("2018-04-01T00:00:00.000Z" AS DATE)

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's maxRating is less than "5.0"
SELECT * FROM [cq:PageContent] as nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[maxRating] < CAST("5.0" AS DECIMAL)

Final Notes: When is the perfect time to use JCR-SQL2?

Build a images and documents search component, if your AEM site that allows consumers to search for images or documents.
Build a blog post search component, If your AEM site has a blog section.
Build a secure resources query API, If you are allowing 3rd party applications to query and find nodes in your AEM site.

There’s many other things to utilize JCR-SQL2 to query nodes, but those are just some quick examples.

9. JCR-SQL2 Code Snippets Cheat Sheet

Use these code snippets below to rapidly build your AEM JCR SQL2 search queries, I will try my best to give you some really great examples:

a. Find all [nt:unstructured] nodes, under the path “/content/we-retail”, where the node name = “root”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND NAME() = "root"

b. Find all components ([nt:unstructured] nodes), under the path “/content/we-retail”, where component resourceType = “weretail/components/content/image”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [sling:resourceType] = "weretail/components/content/image"

b. Find all components ([nt:unstructured] nodes), under the path “/content/we-retail”, where component resourceType = “weretail/components/content/image” AND the fileReference property contains with “/content/dam/we-retail/en/experiences”

1
2
3
4

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [sling:resourceType] = "weretail/components/content/image"
AND CONTAINS([fileReference], "/content/dam/we-retail/en/experiences")

c. Find all [nt:unstructured] nodes, under the path “/content/we-retail”, where the property(“jcr:title”) contains “Featured products”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND CONTAINS([jcr:title], "Featured products")

d. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the cq:lastModified date is before or equals to “January 1st, 2000”

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[cq:lastModified] <= CAST("2023-01-01T00:00:00.000+00:00" AS DATE)

e. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the jcr:created date is before to “July 1st, 2022”

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[jcr:created] < CAST("2022-07-01T00:00:00.000+00:00" AS DATE)

f. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:template equals to “/conf/we-retail/settings/wcm/templates/hero-page”

This AEM JCR SQ2 Query is an example for how to find all nodes with a specific template, results returned as cq:PageContent node.

1
2
3

SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:template] = "/conf/we-retail/settings/wcm/templates/hero-page"

g. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the cq:template equals to “/conf/we-retail/settings/wcm/templates/hero-page”

This AEM JCR SQ2 Query is an example for how to find all nodes with a specific template, results returned as cq:Page node.

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[cq:template] = "/conf/we-retail/settings/wcm/templates/hero-page"

h. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:tags[] contains “we-retail:gender/men”

1
2
3
4

This AEM JCR SQ2 Query is an example for how to find all nodes with a single cq:tags[], results returned as cq:PageContent node.
SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:tags] = "we-retail:gender/men"

i. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:tags[] contains “we-retail:gender/men” AND cq:tags[] contains “we-retail:activity/surfing”

1
2
3
4
5

This AEM JCR SQ2 Query is an example for how to find all nodes with multiple cq:tags[], results returned as cq:PageContent node.
SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:tags] = "we-retail:gender/men"
AND [cq:tags] = "we-retail:activity/surfing"

9. JCR-SQL2 Java Code Example Servlet (2023)

This is an example of how an AEM servlet would actually utilize the JCR-SQL2 Query with the examples above. It will output a JSON array of the page paths.

JSON response

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Curl call

1	curl -X GET http://localhost:4502/bin/getpagedbypath

The post How to use AEM JCR SQL2 query strings to query for nodes in Java Content Repository appeared first on Sourced Code.

Search Archives - Sourced Code

Generate Custom Oak Indexes with the Oak Index Definition Generator

Why Indexing is Important

Using the Oak Index Definition Generator

Conclusion

AEM 6.5.5 Not Indexing Problem *Fixed*

Step 1: Identifying the Issue with the Query Performance Tool

Step 2: Updating Lucene Index Properties

Step 3: Deleting and Remaking %_TARGET_FOLDER_%

Step 4: Complete Index Folder Deletion

Step 5: Unconventional Solution

Conclusion

JCR SQL2 ISDESCENDANTNODE Multiple Paths Example

Optimizing & Debugging Search Queries, Explain Query Tool AEM

Understanding the Explain Query Tool

Benefits of Using the Explain Query Tool:

Using Explain Query Tool with Different AEM Backend Search APIs

1. SQL2:

How to Use:

2. Query Builder API:

How to Use:

3. XPath:

How to Use:

Other Options for the AEM Query Performance Tool

Conclusion

AEM JCR SQL2 Full Text Search Case Insensitive

Performing Case-Insensitive Full Text Search

Example Query Code

Example Try Catch

Conclusion

JUNIT 5: JCR SQL 2 Unit Tests w/ Sling Servlet

1. What to test for when testing a Servlet or OSGI Service that utilizes the Java, JCR SQL 2 API?

1a. Query String

2b. Results of the Query, Nodes

2. Code Examples

2a. GetPagedByPathServlet.java

2b. GetPagedByPathServletTest.java

Search in AEM

Query Builder API Exclude Pages or Paths

Query Builder API’s Query:

Query Builder API Servlet Example:

Why Indexing in AEM is so important for Search

Best Practices for Indexing

Conclusion

AEM Effective Pagination with Query Builder API

1. Understanding Pagination in AEM

2. The Query Builder API: An Overview

3. Benefits of the Query Builder API for Pagination

3a. Performance Optimization

3b. Flexibility and Customization

3c. Support for Dynamic Content

3d. Facilitating Search Functionality

4. Pagination and More Features with Query Builder API

4a. Offset and Limit

4b. Sorting

4c. Search Filters

4d. Query Aggregation

4e. Content Pre-fetching

5. A Simple Servlet for Querying Pages in Java

5. Conclusion

A Simple Guide to AEM Search APIs: Exploring Your Options for Powerful Search Functionality

1. XPath Search API

2. JCR SQL2 Search API

3. Query Builder Search API

Find all AEM Pages with Specific Page Properties with Query Builder API

1. Find all AEM pages with a single page property

Example Code

2. Find all AEM pages with multiple page properties

Example Code

Find all AEM Pages with Tags with Query Builder API

1. Find all AEM pages with a single cq:tag

1. Find all AEM pages with multiple cq:tags

Find AEM JCR Nodes with Full Text Search

1. AEM FullText Search with the Query Builder

2. AEM FullText Search with the JCR_SQL2

How to use AEM JCR SQL2 query strings to query for nodes in Java Content Repository

2023 Added Section: SQL-JCR2 Snippets

JCR-SQL2 Syntax

1. The JCR-SQL2 SELECT Statement

2. The JCR-SQL2 NAME() Statement

AEM 6.5.5 Not Indexing Problem Fixed