---
title: "Query NoSQL Table"
url: https://docs.catalyst.zoho.com/en/sdk/javascript/v1/cloudscale/nosql/query-table/
description: "This page describes the method to perform operations in the NoSQL component."
last_updated: 2026-09-09T10:45:38Z
service: CloudScale
type: general
related_links:
  - name: "Catalyst CloudScale"
    url: /en/cloud-scale/
  - name: "NoSQL Help Documentation"
    url: /en/cloud-scale/help/nosql/introduction/
  - name: "Java SDK Documentation"
    url: /en/sdk/java/v1/cloud-scale/nosql/query-table/
  - name: "Python SDK Documentation"
    url: /en/sdk/python/v1/cloud-scale/nosql/query-table/
  - name: "REST API Documentation"
    url: /en/api/code-reference/cloud-scale/nosql/query-table/#QueryTable
repository:
  name: "Repository"
  url: https://github.com/catalystbyzoho/zcatalyst-sdk-js
---

# Query NoSQL Table

> **Note:** Ensure you have installed the [required package](https://docs.catalyst.zoho.com/en/sdk/javascript/v1/cloudscale/nosql/overview/#prerequisites) to use this SDK method.

Using the `queryTable()` SDK method, you can query a NoSQL table and retrieve data by identifying the items using the [primary keys](https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/components/#table-keys) of the table. For instance, you can use just the partition key or a combination of the partition key and sort key to retrieve the item.

> **Note:** Catalyst enables you to retrieve a **maximum of 100 items** in bulk from a NoSQL table with pagination from a single SDK operation. You must use the `start_key` token received in the SDK response and construct the logic for pagination.

You can define the key condition that identifies the item by specifying the attributes, their required values, and the supported operator to be used. The supported operators are represented as shown below.

<table border="1" cellpadding="8" cellspacing="0">
  <thead>
    <tr>
      <th>Operators</th>
      <th>Notation</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>CONTAINS</td>
      <td><span class="badge">contains</span></td>
    </tr>
    <tr>
      <td>NOT_CONTAINS</td>
      <td><span class="badge">not_contains</span></td>
    </tr>
    <tr>
      <td>BEGINS_WITH</td>
      <td><span class="badge">begins_with</span></td>
    </tr>
    <tr>
      <td>ENDS_WITH</td>
      <td><span class="badge">ends_with</span></td>
    </tr>
    <tr>
      <td>IN</td>
      <td><span class="badge">in</span></td>
    </tr>
    <tr>
      <td>NOT_IN</td>
      <td><span class="badge">not_in</span></td>
    </tr>
    <tr>
      <td>BETWEEN</td>
      <td><span class="badge">between</span></td>
    </tr>
    <tr>
      <td>NOT_BETWEEN</td>
      <td><span class="badge">not_between</span></td>
    </tr>
    <tr>
      <td>EQUALS</td>
      <td><span class="badge">equals</span></td>
    </tr>
    <tr>
      <td>NOT_EQUALS</td>
      <td><span class="badge">not_equals</span></td>
    </tr>
    <tr>
      <td>GREATER_THAN</td>
      <td><span class="badge">greater_than</span></td>
    </tr>
    <tr>
      <td>LESS_THAN</td>
      <td><span class="badge">less_than</span></td>
    </tr>
    <tr>
      <td>GREATER_THAN_OR_EQUALS</td>
      <td><span class="badge">greater_equal</span></td>
    </tr>
    <tr>
      <td>LESSER_THAN_OR_EQUALS</td>
      <td><span class="badge">less_equal</span></td>
    </tr>
    <tr>
      <td>AND</td>
      <td><span class="badge">AND</span></td>
    </tr>
    <tr>
      <td>OR</td>
      <td><span class="badge">OR</span></td>
    </tr>
  </tbody>
</table>

The following example code snippet details the following logic:

* The required items are identified using its partition key: `fruitType`.
* The condition value is "`Citrus`".
* Implements `consistent_read` to indicate if the read operation must be done using the master or a slave cluster.
    - If the value is set as `true`, it is queried from the master.
    - If the value is set as `false`, it is queried from the slave.

> **Note:** In the master-slave replication, the master contains all the data of the database, and the slave contains copies from the master. Performing a read operation from the slave can reduce the overall cost with the trade-off being a minor delay in the updated data being reflected.

```javascript
const NoSQLOperator = new NoSQLEnum();
// Query a NoSQL table to fetch the items identified by the partition key 'fruitType' with the value "Citrus"
const queriedItem = await table.queryTable({
  // Define the key condition to query the items with
  key_condition: {
    // Specify the partition key attribute name of the table
    attribute: 'fruitType',
    // Define the supported operator to be used.
    // You can also use BETWEEN, GREATERTHAN, LESSERTHAN, GREATERTHANOREQUALTO, LESSERTHANOREQUALTO
    operator: NoSQLOperator.EQUALS,
    // Specify the value for comparison
    value: NoSQLMarshall.makeString('Citrus'),
  },
  // Set consistent_read to true to query from master.
  // If set to false, it is queried from slave.
  consistent_read: true,
  // Limit the number of rows to be returned by specifying a value
  limit: 10,
  // Set forward_scan to true to sort the results in ascending order.
  // Otherwise, it is sorted in descending order.
  forward_scan: true,
});
```