What is a Jira Query Called? Understanding JQL and Advanced Search for Project Management

I remember the first time I really dug into Jira. I was working on a project with a pretty complex workflow, and we had hundreds, if not thousands, of issues. My manager asked me to pull a report on all the bugs that had been reopened in the last sprint, assigned to a specific team, and had a certain severity level. My immediate thought was, “How on earth am I going to find that?” I fumbled around in the basic search, trying to click through dropdowns and filters, and it felt like an uphill battle. That’s when someone pointed me towards what a Jira query is really called, and it was a game-changer. Essentially, a Jira query is most commonly referred to as a **Jira Query Language (JQL)** statement when you’re using Jira’s powerful search capabilities.

So, to answer the question directly: What is a Jira query called? When you’re looking to perform sophisticated searches within Jira, you’re typically writing a **JQL query**. While the simpler, more visual search options exist, JQL is the underlying language that unlocks the true power of Jira’s issue tracking and project management capabilities. Think of it as the secret handshake that lets you ask Jira to find exactly what you need, when you need it, with an astonishing degree of precision.

The Evolution of Jira Search: From Basic to Powerful

Before we dive deeper into JQL, it’s worth appreciating how Jira’s search has evolved. Initially, like many software tools, Jira offered basic search functionalities. This typically involved selecting fields from dropdown menus and applying simple criteria. For straightforward tasks, this was perfectly adequate. You could filter by assignee, by status, by project, and so on. However, as projects grew in complexity and the volume of data within Jira increased, these basic filters started to feel limiting.

The need for more granular control became apparent. Project managers, developers, testers, and business analysts all had unique requirements for slicing and dicing their data. They needed to find issues based on a combination of criteria that went beyond simple AND/OR logic. This is where the development of JQL became not just a feature, but a necessity for effective Jira usage. It transformed Jira from a simple issue tracker into a sophisticated data analysis and reporting tool.

Why JQL is the Core of Jira Queries

JQL is essentially a specialized query language designed by Atlassian, the creators of Jira. It’s built to interact with Jira’s database of issues, allowing you to retrieve specific sets of data based on a wide range of criteria. Unlike SQL, which is a general-purpose database query language, JQL is tailored specifically for Jira’s data model. This means it understands concepts like ‘projects,’ ‘issues,’ ‘versions,’ ‘components,’ ‘epics,’ ‘stories,’ and much more.

When you’re using Jira’s “Advanced search” feature, what you’re doing is either visually constructing a JQL query or, if you’re comfortable, typing it out directly in the JQL query bar. This advanced search functionality is what allows users to move beyond basic filtering and into the realm of truly powerful data retrieval. It’s the engine that drives most custom reports, dashboards, and automated workflows within Jira.

Breaking Down a JQL Query: The Anatomy of a Search

To truly understand what a Jira query is called and how it works, let’s dissect a typical JQL query. A JQL statement is structured with keywords, fields, operators, and values. It’s designed to be human-readable, which is a big plus for those who aren’t database experts.

Here’s a common structure:

Field: This is the attribute of an issue you want to search by (e.g., `project`, `assignee`, `status`, `created`, `priority`).
Operator: This specifies the relationship between the field and the value (e.g., `=`, `!=`, `>`, `<`, `>=`, `<=`, `IN`, `NOT IN`, `IS`, `IS NOT`, `WAS`, `WAS NOT`, `CHANGED`).
Value: This is the specific data you’re looking for within the field (e.g., a project name like ‘Alpha’, a user’s name like ‘john.doe’, a status like ‘Open’, a date like ‘startOfWeek()’).
Keywords/Functions: JQL also uses keywords like `AND`, `OR`, `ORDER BY` and functions like `startOfWeek()`, `currentUser()`, `membersOf()` to refine searches.

Let’s take an example:

project = "Alpha" AND status = "Open" AND priority = "High"

In this simple query:

`project`, `status`, and `priority` are fields.
`=` and `=` are operators.
`”Alpha”`, `”Open”`, and `”High”` are values.
`AND` is a logical keyword connecting the conditions.

This query would return all issues in the “Alpha” project that are currently in an “Open” status and have a “High” priority. It’s straightforward, yet incredibly powerful.

Common Jira Fields You’ll Query

Understanding the available fields is crucial to writing effective JQL queries. Jira has a vast number of default fields, and your instance might have custom fields as well. Here are some of the most frequently used fields:

Project: The project the issue belongs to.
Issue Type: The type of issue (e.g., Bug, Story, Task, Epic).
Status: The current stage of the issue in its workflow (e.g., To Do, In Progress, Done, Resolved).
Resolution: The outcome of the issue (e.g., Fixed, Won’t Fix, Duplicate).
Assignee: The user currently responsible for the issue.
Reporter: The user who created the issue.
Priority: The importance of the issue (e.g., Highest, High, Medium, Low, Lowest).
Labels: User-defined tags for categorizing issues.
Components: Sub-sections of a project that an issue relates to.
Versions: Releases of a project that an issue is associated with (e.g., affects version, fix version).
Created: The date and time the issue was created.
Updated: The date and time the issue was last updated.
Due Date: The target completion date for the issue.
Summary: The title or brief description of the issue.
Description: The detailed content of the issue.
Comments: The comments made on the issue.
Epic Link: For issues linked to an Epic.
Sprint: For issues currently in a sprint.
Text Search Fields: Fields like `summary`, `description`, `comments` can be searched for specific keywords using `~` operator.

Operators: The Language of Comparison

Operators are the verbs in your JQL sentences. They define how you compare a field to a value. Here are some of the most common ones:

Equality: `=` (equals), `!=` (not equals)
Comparison: `>`, `<`, `>=`, `<=` (for numerical or date fields)
Membership: `IN` (is one of these values), `NOT IN` (is not any of these values). Useful for searching multiple values at once. Example: `status IN (“Open”, “In Progress”)`
Presence: `IS` (field has a value, e.g., `assignee IS NOT EMPTY`), `IS NOT` (field is empty, e.g., `resolution IS EMPTY`).
History/Chains: `WAS`, `WAS NOT`, `WAS IN`, `WAS NOT IN`. These are particularly powerful as they look at the history of an issue. For example, `status WAS “Open” BEFORE “2026-10-26″` finds issues that were Open before a specific date. `assignee WAS “john.doe”` finds issues that were at some point assigned to John Doe.
Changes: `CHANGED`. This operator is used to find issues where a specific field has changed. For example, `description CHANGED BY “jane.doe”` finds issues where Jane Doe modified the description.

Keywords and Functions: Adding Logic and Context

JQL also offers keywords and functions to make your queries more dynamic and logical.

Logical Operators: `AND`, `OR`, `NOT`. These allow you to combine multiple conditions. `AND` requires all conditions to be true, `OR` requires at least one condition to be true, and `NOT` negates a condition.
Ordering: `ORDER BY`. This sorts your results. You can sort by multiple fields (e.g., `ORDER BY priority DESC, created ASC`). `DESC` means descending (e.g., High to Low), `ASC` means ascending (e.g., Low to High).
Jira Functions: These are pre-defined pieces of logic that can return dynamic values. Some incredibly useful ones include:
- `currentUser()`: Refers to the currently logged-in user. Very handy for “my open issues.”
- `membersOf(“groupname”)`: Returns all users in a specific Jira group.
- `startOfDay()`, `endOfDay()`, `startOfWeek()`, `endOfWeek()`, `startOfMonth()`, `endOfMonth()`, `startOfYear()`, `endOfYear()`: These are fantastic for relative date queries.
- `now()`: The current date and time.
- `earliestUnreleasedVersion(“project”)`: Finds the earliest unreleased version for a project.
- `latestReleasedVersion(“project”)`: Finds the latest released version for a project.

Using these functions makes your queries adaptable. For instance, `assignee = currentUser()` will always show issues assigned to whoever is running the query, without you having to manually update it.

JQL vs. Basic Search: When to Use What

It’s important to distinguish between Jira’s basic search and advanced search using JQL. Jira’s basic search is a user-friendly interface that uses dropdowns and simple filters. It’s excellent for quick, straightforward filtering.

When to Use Basic Search:

You’re new to Jira and still learning the basics.
You need to perform a very simple filter (e.g., “Show me all tasks assigned to me”).
You prefer a visual, point-and-click interface.

When to Use Advanced Search (JQL):

You need to combine multiple criteria in complex ways.
You want to search based on issue history (e.g., “issues that were assigned to John but are now assigned to Jane”).
You need to use relative dates (e.g., “issues due this week,” “issues created last month”).
You need to search within text fields for specific keywords.
You want to leverage Jira functions for dynamic results.
You’re building dashboards or reports that require precise data retrieval.
You need to find issues that have had specific fields changed.

The transition from basic to advanced search is a natural progression for any Jira user who wants to get more out of the tool. It’s about moving from simple requests to sophisticated data analysis.

Crafting Your First JQL Query: A Step-by-Step Approach

Let’s walk through creating a common scenario using JQL. Imagine you’re a QA lead, and you need to find all bugs that are currently in the “In Progress” or “In Review” status, were reported by anyone on your QA team, and are of “High” or “Highest” priority.

Navigate to Advanced Search: In your Jira instance, click on the “Search” or “Filters” option in the top navigation bar, and then select “Advanced search.”
Switch to JQL Mode: You’ll likely see a more complex search interface. Look for a toggle or button that says “Switch to JQL” or “Edit as text.” Click this to access the JQL editor.
Start with the first condition: You want issues in specific statuses. We can use the `IN` operator for this. Type:

status IN ("In Progress", "In Review")
Add the next condition using AND: Now, you want to filter by reporter. Let’s assume your QA team is in a Jira group called “QA Team.” We’ll use the `membersOf()` function. Connect this with `AND`:

status IN ("In Progress", "In Review") AND reporter IN membersOf("QA Team")
Add the priority condition: Finally, you want to filter by priority. Again, using the `IN` operator for multiple values:

status IN ("In Progress", "In Review") AND reporter IN membersOf("QA Team") AND priority IN ("High", "Highest")
Consider Ordering: It’s often helpful to sort these results. Let’s order them by priority (highest first) and then by creation date (earliest first):

status IN ("In Progress", "In Review") AND reporter IN membersOf("QA Team") AND priority IN ("High", "Highest") ORDER BY priority DESC, created ASC
Execute the Search: Click the search button.
Save Your Query: If this is a search you’ll run regularly, click the “Save as” button (usually near the top) and give it a descriptive name, like “QA High Priority Bugs – In Progress/Review.”

This step-by-step process should give you a solid foundation for constructing your own JQL queries.

Beyond the Basics: Advanced JQL Techniques

Once you’ve mastered the fundamentals, you can explore more advanced JQL techniques that unlock even greater power:

Searching Issue History with WAS and WAS NOT

This is where JQL really shines. You can query the past states of an issue. For example:

assignee WAS "bob.smith": Finds all issues that were *ever* assigned to Bob Smith.
status WAS NOT "Closed" DURING ("2026-01-01", "2026-06-30"): Finds issues that were not in the “Closed” status at any point during the first half of 2026.
priority CHANGED FROM "Low" TO "High": Finds issues where the priority was explicitly changed from Low to High.

These historical queries are invaluable for auditing, trend analysis, and understanding how issues have progressed over time.

Using Text Search with the Tilde (~) Operator

Sometimes, you need to find issues that contain specific words or phrases within their summary, description, or comments, rather than matching exact field values. The `~` operator is your friend here.

summary ~ "login issue": Finds issues where the summary contains the phrase “login issue.”
description ~ "performance AND bottleneck": Finds issues where the description contains both “performance” and “bottleneck.”
text ~ "critical error": The `text` field is a shorthand that searches across the summary, description, and comments.

You can also use wildcards with `~`. For example, `summary ~ “error*”` would find issues with summaries starting with “error”.

Leveraging Jira Functions for Dynamic Searches

As mentioned before, functions are powerful. Here are a few more practical examples:

resolution = EMPTY AND assignee = currentUser() AND updated <= -7d: Finds issues assigned to me that are still unresolved and haven't been updated in over 7 days. (`-7d` means 7 days ago).
project = "MobileApp" AND fixVersion = earliestUnreleasedVersion("MobileApp"): Finds all issues targeted for the next upcoming release of the MobileApp project.
sprint in openSprints() AND status != Done: Finds all issues in any currently active sprint that are not yet done.

The Power of `ORDER BY` for Reporting

When building dashboards or reports, the `ORDER BY` clause is essential for presenting information logically. You can sort by almost any field, and in either ascending or descending order.

ORDER BY created DESC: Shows the most recently created issues first.
ORDER BY resolution ASC, priority DESC: Sorts issues first by resolution (e.g., Fixed before Won't Fix), and then within each resolution, by priority (highest first).

Custom Fields and JQL

Many Jira implementations rely heavily on custom fields to track project-specific data. The good news is that you can query most custom fields using JQL, provided they are configured correctly. Custom fields typically appear with a `customfield_` prefix followed by a number (e.g., `customfield_10010`).

To find the name or ID of a custom field:

Go to Jira Administration > Issues > Custom Fields.
Locate your custom field. The name is what you see, and the ID is usually in the URL when you edit it (e.g., `customFieldId=10010`).

Once you have the ID, you can use it in your JQL.

Example: If you have a custom field called "Customer Impact" which is a select list (single choice) with the ID `customfield_10055`, and you want to find issues with "Critical" customer impact:

customfield_10055 = "Critical"

Important Note: The exact syntax for querying custom fields, especially those with multiple select options or complex types, might vary. It's often a good idea to start by building a query visually in the basic search and then switching to JQL mode to see how Jira translates your selections. This is a fantastic way to learn how your specific custom fields are represented in JQL.

Saving and Sharing Jira Queries (Filters)

A significant benefit of mastering JQL is the ability to save your complex queries as "Filters" in Jira. These saved filters can then be used in various places:

Dashboards: You can add gadgets to your Jira dashboards that display issues based on a saved filter (e.g., "My Open Tasks," "Critical Bugs").
Agile Boards: Filters define the issues that appear on your Scrum or Kanban boards.
Notifications: You can set up scheduled email notifications based on filter results.
Bulk Operations: Saved filters can be used to select a set of issues for bulk editing.
Automation Rules: Many automation rules in Jira are triggered by or act upon filter results.

To save a filter:

Perform your search in Jira's Advanced Search.
Click the "Save as" button.
Give your filter a descriptive name (e.g., "Stale Bugs - No Activity Last 14 Days").
Optionally, add a description.
Choose the sharing permissions:

Private: Only you can see it.
Specific groups: Only members of selected Jira groups can see it.
Specific projects: Anyone working on the selected projects can see it.
Public: Anyone in your Jira instance can see it. (Use with caution!)

Click "Save."

Sharing filters is a powerful way to disseminate important information and ensure everyone is looking at the same data.

Common Use Cases for JQL Queries

Let's explore some practical scenarios where JQL is indispensable:

1. Managing Personal Workload

assignee = currentUser() AND statusCategory != Done ORDER BY priority DESC, updated ASC

This query is fundamental for every individual contributor. It shows all the issues currently assigned to you that are not yet completed, sorted by priority (highest first) and then by the last time they were updated (most recent first, to easily see what needs attention). This is often the default filter on a user's personal Jira dashboard.

2. Tracking Team's Open Bugs

project = "MyProject" AND issuetype = Bug AND status != Closed AND resolution = EMPTY ORDER BY priority DESC, created DESC

A project manager or team lead would use this to get a clear view of outstanding bugs. It filters for the specific project, ensures it's an issue type of "Bug," that it hasn't been closed, and has no resolution set (meaning it's truly open). Sorting by priority and then creation date helps prioritize fixing the most critical and oldest bugs.

3. Identifying Stalled Issues

project = "MyProject" AND statusCategory != Done AND updated <= -14d ORDER BY updated ASC

This query finds issues within a project that are not yet done and haven't been updated in the last 14 days. These are candidates for follow-up. Sorting by `updated ASC` will show you the issues that have been stale the longest, so you can investigate why they aren't progressing.

4. Finding Issues in a Specific Sprint

sprint in openSprints() AND project = "ScrumTeam" ORDER BY status ASC, priority DESC

For Agile teams, this is crucial. It shows all issues associated with the currently active sprints for a given project. Sorting by status and then priority helps the team visualize their progress and identify bottlenecks.

5. Verifying Work on a Specific Version

project = "WebApp" AND fixVersion = "v2.1" AND status = Resolved ORDER BY resolution ASC

This query helps ensure that all work intended for a specific release version ("v2.1") has been completed and resolved. It's a key query for release management and quality assurance.

6. Auditing Assignee Changes

project = "BackendService" AND assignee WAS "old.developer" AND resolution = EMPTY AND updated > -7d ORDER BY updated DESC

This advanced query finds issues in the "BackendService" project that were assigned to "old.developer" at some point, are still not resolved, and have been updated in the last 7 days. This can be useful for understanding handover processes or tracking specific developers' past work.

7. Tracking Epics and their Stories

issuetype = Epic AND project = "InitiativeX" ORDER BY created DESC

To see all the Epics for a given project.

"Epic Link" = PROJ-123 AND issuetype != Epic ORDER BY created DESC

To see all the child issues (Stories, Bugs, Tasks) linked to a specific Epic (where PROJ-123 is the Epic's key).

8. Monitoring Team Capacity

project = "ScrumTeam" AND sprint in openSprints() AND assignee IS EMPTY AND statusCategory != Done

This query helps identify unassigned work within the current sprint, allowing the team to redistribute tasks and ensure efficient capacity utilization.

Best Practices for Writing Effective JQL Queries

To get the most out of your Jira queries, consider these best practices:

Be Specific: The more precise your criteria, the more accurate your results will be. Avoid overly broad searches unless necessary.
Use `AND` by Default: When in doubt, use `AND` to combine conditions. This is generally safer than `OR`, which can return more results than you expect.
Leverage Jira Functions: Functions like `currentUser()`, `startOfWeek()`, and `membersOf()` make your queries dynamic and reusable.
Save Frequently Used Queries: Don't rewrite complex JQL every time. Save your useful queries as filters.
Understand Your Fields: Know the names and types of your Jira fields, especially custom fields. Use the visual builder to help you identify them.
Test Your Queries: Always test your JQL queries to ensure they return the expected results. Refine them as needed.
Keep it Readable: Use spaces around operators and keywords. For long queries, consider breaking them down into logical sections.
Use Quotes Correctly: String values (like project names, statuses, or user names) should typically be enclosed in double quotes (`"`). For example, `status = "In Progress"`. If a value contains a space, quotes are mandatory.
Beware of Case Sensitivity: While many Jira fields are not case-sensitive, it's a good habit to match the case of your values as they appear in Jira. For example, `project = "MyProject"` is safer than `project = "myproject"`.
Consider Performance: Very complex queries with many `OR` conditions or searches across extremely large datasets can sometimes be slow. If you encounter performance issues, try to simplify your query or break it down. Searching for issues that `WAS` changed by many users across many projects can also be intensive.

Troubleshooting Common JQL Issues

Even experienced users run into problems. Here are some common JQL issues and how to resolve them:

"No issues found": This is the most common. Double-check your spelling, operators, and values. Are you sure issues matching all criteria exist? Try removing conditions one by one to isolate the problem. Ensure you have the correct project selected if you're filtering by project.
"Invalid query": Jira will usually highlight the syntax error. This often means a missing quote, an incorrect operator, or a typo in a keyword. Pay close attention to the red highlighting.
Unexpected Results:
- Too many results: You might be using `OR` too broadly, or a condition is too general. Consider adding more `AND` clauses or making existing conditions more specific.
- Too few results: You might be using `AND` too restrictively, or a condition is too specific. Check for typos in values. Ensure you're not accidentally filtering out valid results.
Custom Field Issues:
- Custom field not found: Ensure the custom field is enabled and visible for the project(s) you're searching. You might be using the wrong ID or name. Use the visual builder to find the correct representation.
- Incorrect values for custom fields: For select lists, radio buttons, or checkboxes, the value must match exactly. For multi-select fields, you might need to use `IN` or `~` operators.
Date/Time Issues: Relative dates (`-7d`) or specific date formats (`YYYY-MM-DD`) need to be correct. Make sure your Jira's timezone settings are consistent with your expectations.

The best way to troubleshoot is to systematically simplify the query. Start with a very basic known-working query (e.g., `project = "MyProject"`) and gradually add back your conditions until the problem reappears.

The Future of Jira Querying

While JQL is incredibly robust, Atlassian continues to enhance Jira's search capabilities. Expect ongoing improvements in performance, usability, and the introduction of new functions or operators to address evolving project management needs. The focus is always on making it easier for users to extract meaningful insights from their Jira data without requiring deep technical expertise.

The visual "Basic" search interface also continues to evolve, often acting as a gateway to JQL. As you build queries visually, you can see the JQL being generated, which is a fantastic learning tool. This synergy between visual and text-based querying ensures that Jira remains accessible to a wide range of users.

For many, the term "Jira query" directly translates to "JQL query." It's the language that empowers users to move beyond basic issue tracking and leverage Jira as a powerful data analysis and reporting engine. Mastering JQL is a significant step in becoming a proficient Jira administrator or power user.

Frequently Asked Questions about Jira Queries

Q1: What is the difference between basic and advanced search in Jira?

The primary difference lies in the interface and the underlying logic. Jira's basic search is a user-friendly, visual interface where you select criteria from dropdown menus and simple input fields. It's great for straightforward filtering and is ideal for users who are new to Jira or only need to perform simple searches. It abstracts away the complexity of how the search is performed.

On the other hand, advanced search utilizes Jira Query Language (JQL). This is a text-based query language that provides far more power and flexibility. With JQL, you can construct complex conditions, search issue history, use dynamic functions, and precisely define your search criteria. While it has a steeper learning curve, it's indispensable for detailed analysis, custom reporting, and managing large, complex projects. The advanced search interface in Jira allows you to either type JQL directly or use a visual builder that generates JQL for you, bridging the gap between the two approaches.

Q2: How do I find out what fields are available for JQL queries?

There are several ways to discover available fields for JQL queries. The most common and user-friendly method is to use Jira's **Advanced Search** interface and switch to the visual builder. As you start typing or clicking through the options, Jira will suggest fields and their possible values. This is often the easiest way for beginners to identify fields relevant to their search, especially custom fields.

Another method is to consult your Jira administrator. They can provide a list of all available fields, including custom fields, and explain their purpose. If you have administrative privileges, you can navigate to Jira Administration > Issues > Custom Fields to see a list of all custom fields configured in your instance. For system fields (like `project`, `status`, `assignee`), you can often find them by exploring Jira's documentation or by experimenting in the Advanced Search.

Additionally, many Jira plugins and add-ons introduce their own custom fields, which can also be queried using JQL. The documentation for these add-ons will typically specify how to query their introduced fields.

Q3: Can I search for issues that have not been updated in a long time?

Absolutely! This is a very common and useful query. You can achieve this using the `updated` field combined with a relative date. For example, to find all issues in a specific project that haven't been updated in the last 30 days, you would use a query like this:

project = "YourProjectName" AND statusCategory != Done AND updated <= -30d ORDER BY updated ASC

Let's break this down:

project = "YourProjectName": Filters the search to your specific project.
statusCategory != Done: This is an important addition. It ensures you're only looking at issues that are still active (not in a "Done" category). You might adjust this based on your workflow's categories.
updated <= -30d: This is the core of the query. It means "the last updated date is less than or equal to 30 days ago." Jira interprets `-30d` as "30 days prior to the current date." You can use `w` for weeks, `m` for months, or `y` for years (e.g., `-3m` for three months).
ORDER BY updated ASC: This sorts the results so that the issues that haven't been updated for the longest period appear at the top, making it easy to identify the most stale items.

This type of query is excellent for proactive project management, helping to identify bottlenecks, forgotten tasks, or issues that might require re-prioritization or reassignment.

Q4: How do I search for issues that have been assigned to a specific person, then reassigned to someone else?

This is where the `WAS` and `WAS NOT` operators come into play, allowing you to query issue history. To find issues that were *once* assigned to "userA" but are *now* assigned to "userB" (and are not yet resolved), you would use a query like this:

project = "MyProject" AND assignee WAS "userA" AND assignee WAS NOT "userA" AND assignee = "userB" AND resolution = EMPTY

Let's dissect this:

assignee WAS "userA": This finds issues that have *at some point* been assigned to "userA."
assignee WAS NOT "userA": This condition ensures that the issue is *no longer* assigned to "userA." This is crucial because the first condition would also match issues currently assigned to "userA."
assignee = "userB": This specifies that the issue must *currently* be assigned to "userB."
resolution = EMPTY: We add this to focus on currently open issues. If you wanted to see historical reassignments regardless of current status, you might omit this.

This type of historical query is incredibly powerful for tracking workflow changes, understanding task transitions, and performing audits.

Q5: What are "status categories" in Jira, and how do they relate to JQL?

Status categories are a fundamental concept in Jira workflows that group statuses into broader states: **To Do**, **In Progress**, and **Done**. Every status in your Jira instance is assigned to one of these categories. For example, a "New" or "Open" status might be in the "To Do" category, while "In Development" and "Code Review" would be in the "In Progress" category, and "Resolved" or "Closed" would fall under "Done."

In JQL, you can query these categories directly using `statusCategory`. This is extremely useful because it allows you to write queries that work across different workflows or statuses without needing to list every single status. For instance, if you want to find all issues that are not yet completed, regardless of their specific status (e.g., "Open," "In Review," "Testing"), you can use:

statusCategory != Done

This is much more robust than listing every possible "open" status, as new statuses might be added to your workflow later that still fall into the "To Do" or "In Progress" categories.

You can also use `statusCategory IN ("To Do", "In Progress")` to specifically target issues that are in either of those phases, or `statusCategory = "Done"` to find all completed issues.

Understanding status categories is key to writing flexible and maintainable JQL queries that adapt to changes in your project's workflow.

In conclusion, when you're asking "What is a Jira query called?" the most accurate and comprehensive answer, especially when discussing sophisticated searching, is a **JQL query**. It's the engine that drives effective data retrieval in Jira, empowering teams to manage projects with greater insight and efficiency.