# NoSQL



--------------------------------------------------------------------------------
title: "Introduction"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.184Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Catalyst NoSQL

### Introduction

Catalyst Cloud Scale NoSQL is a fully-managed, powerful database that offers a non-relational approach to data storage. It allows you to handle unstructured, semi-structured, and disparate data without relying on traditional SQL models. The highly scalable proprietary infrastructure, powered by Catalyst, ensures that you can create and manage databases effortlessly without worrying about backend tasks like provisioning, configuring, or scaling. This flexibility makes it ideal for modern, data-driven applications.

Catalyst offers NoSQL in addition to its conventional relational database, the Data Store in the CloudScale service. Depending on your business requirements and various other factors, such as the possibility of a fixed schema in your database or the need for a read-heavy system, you can determine the right data storage option for your use case. Refer to [this comparison section](#catalyst-data-store-vs-nosql) between Data Store and NoSQL for more help. 

Catalyst supports the **key-value pair based** document-type data storage in NoSQL, with provisions to store your data in a Custom JSON format that supports numerous data types. With the ability to partition the data across clusters, NoSQL offers an high-volume storage option, as well as enables multi-level scalability.

If you choose to build an application with Catalyst NoSQL, you can easily create tables in your project, configure them, add data, or query data from the Catalyst console. You can also easily migrate your existing NoSQL databases from third-party sources into Catalyst in a few simple steps.  

Catalyst provides server-side SDKs to perform various NoSQL CRUD operations, such as adding or querying data, in the following programming environments:

* Java
* Node.js
* Python

Refer to the linked SDK documentations to learn about the SDK methods available. You can also avail NoSQL APIs in Catalyst for these operations. Refer to the API documentation for details.

<br>

### Catalyst Data Store vs NoSQL

Catalyst provides both Data Store and Catalyst NoSQL as two different data storage options, where the former is a SQL and relational database and the latter, a non-relational database. You can opt for the database suited to your needs based on various factors such as your business logic, your application's data structure, or your usage. 

Storing unstructured data in a relational database poses problems in schema organization and often leads to data redundancy. You must therefore choose the right storage platform suitable to your use case.

Here's a handy guide that will help you decide on the best database option for your requirements.

#### Catalyst Data Store

Choose Catalyst Data Store if the following conditions are met-

* Architecture: Your database's architecture is relational, i.e., the data points are related to one another. 

* Data Structur: Your data is well-structured and can be tightly organized into rows and columns to collectively form a table.

* Schema: The schema of your database is uniform, known in advance, and can be designed and finalized statically ahead of data operations.

* Query Language: You require using SQL to query, update, and maintain the database. SQL goes well with relational, structured databases.

* Priorities: Your priority for your database is ACID compliance (Atomicity, Consistency, Isolation, and Durability), and not horizontal scalability.

* Read/Write Throughput: You require fast, error-free, efficient querying with minimal lag and overhead for a read-heavy database.


#### Catalyst NoSQL

Choose Catalyst NoSQL if the following conditions are met-

* Architecture: There are no inter-dependencies or relationships between the data points in your database, and they exist as independent entities.

* Data Structure: Your database contains semi-structured or unstructured disparate data that cannot be stored in the conventional tabular format, and is loosely organized.

* Schema: You require the schema of your database to be highly flexible where all the items need not adhere to the same structure, easy to set up, or if it cannot be designed in advance.

* Data Format: Your data will primarily be in the JSON format, and you require the support of multiple data types.

* Priorities: Your priority is high scalability, both vertically and horizontally, and you require storage across multiple database nodes with dynamic resource allocation.

* Read/Write Throughput: You are building a write-heavy system where partitioning storage across distributed clusters with peer-to-peer replication can be beneficial.




--------------------------------------------------------------------------------
title: "Benefits"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.185Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/benefits/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Benefits


1. Rapid Horizontal and Vertical Auto-Scaling

Catalyst offers a low latency, high throughput database solution with NoSQL where its robust servers can auto-scale up or down seamlessly depending on the load. NoSQL's architecture also facilitates both horizontal and vertical scaling, wherein new resources are added to the existing system (vertical scaling), and new server racks are provisioned (horizontal scaling) based on demand. These together ensure that you are provided with a durable and reliable infrastructure upon which you can efficiently store and manage large volumes of data.

<br>

2. Fully-Managed, Secure Infrastructure for your Database

You can experience a fully-managed database that allows you to offload all administrative tasks with Catalyst, as compared to a self-hosted NoSQL database, and focus only on building your schema and working with your data. You also benefit from a secure and trusted platform built on Zoho's tried-and-tested infrastructure that protects your data and provides ease of development, functionality, and performance at scale.

<br>

3. Fast and Powerful Querying with NoSQL Components

Catalyst NoSQL provides dynamic, flexible querying by supporting composite primary keys that are composed of both partition keys and sort keys. This proves beneficial while querying, as the former attribute is used to determine the partition an item is stored in, while the latter can determine its range in its sorted order. In addition to these, Catalyst enables you to query using additional sort keys, besides the main sort key, as well as create and query with indexes in your table for convenience. These functionalities are advantageous and ensure you can build and deploy high-performance, dependable applications.

<br>

4. Easy and Secure Third-Party Meta and Data Migration

You can utilize a convenient method of migrating large volumes of metadata as well as data stored in third-party services into Catalyst with the click of a few buttons. NoSQL currently supports migration from AWS DynamoDB by configuring the required access tokens. This handy feature lets you migrate the schema and meta information of your NoSQL tables set up in AWS in the development environment of Catalyst, while availing the ability to migrate data from your AWS NoSQL tables in the production environment.

<br>

5. Optimized and Highly Available Storage

The general underlying architecture of NoSQL facilitates high data storage optimization through the usage of flexible data models by default. Catalyst NoSQL's support of the key-value pair based data storage eliminates the dependency on object-oriented storage, which further ensures storage optimization. Additionally, partitioning and replicating the storage across clusters provides high fault tolerance and high availability of data, even during crucial situations. 

<br>

6. Cost-Efficient Storage Solution

When you choose NoSQL for the right requirements, you can benefit from a highly cost-efficient way of operating and managing your data. Catalyst offers the best pricing for performing CRUD operations in NoSQL through its innovating pricing strategies, that further enhances cost efficiency. NoSQL also provides an automated way of deleting items from your tables by marking their expiration periods through a TTL (Time To Live) attribute, that saves you from performing unnecessary writes for manual deletion.

<br>

7. Ease of Access with the Console, Server-Side SDK, and API

You can create tables in NoSQL for your project from the Catalyst console, as well as perform table configuration and management, data addition and querying there. NoSQL data operations are also available in the Java, Node.js, and Python SDKs, allowing you to incorporate them into your server-side logic with ease. Catalyst also enables you to avail of multiple APIs for these NoSQL operations.



--------------------------------------------------------------------------------
title: "Components of NoSQL"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.185Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/components/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Components of NoSQL

To understand the architecture of Catalyst NoSQL databases and learn about working with them, you must first understand the components that make up NoSQL databases. 

### Basic Components
The fundamental components involved in Catalyst NoSQL are explained below.

#### Terminology

<br>

<table class="content-table nosql-components-table">

<thead>
        <tr>
            <th class="w10p">Component Name</th>
            <th class="w30p">Description</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>Table</td>
        <td>A table is the fundamental structure that NoSQL stores data in. Similar to relational databases, tables are composed of records or items. <br><br>
        The sample table Travel shown below holds data about travel destinations that one could visit, with key information about each place.</td>
    </tr>
    <tr>
        <td>Attributes</td>
        <td>An attribute represents a characteristic of a data value in a table. Attributes in NoSQL are like fields or columns in a relational database wherein each attribute holds data of a specific data type. <br><br>
        The sample table Travel below contains the attributes DestinationName, Distance, BestTimeToVist, Location, and EstimatedCost.</td>
    </tr>
    <tr>
        <td>Items</td>
        <td>An item is a collection of attributes that hold the data of a single data point. Items in NoSQL are similar to rows or records in a relational database wherein they can contain values for different attributes. <br><br>
        In the sample table Travel, each collection of data uniquely identified by the DestinationName is an item. For example, the record "Honululu" that also contains a set of values for the Distance, BestTimeToVisit, and EstimatedCost is an item. Similarly, the record identified by "Prague" with different attribute values is an item.<br><br>
        Note: The maximum total size of an item provisioned in Catalyst NoSQL is 400 KB.</td>
    </tr>
    <tr>
        <td>Data</td>
        <td>In Catalyst NoSQL's terms, the data of a table is composed of all the attributes and items in it, present in the Catalyst Custom JSON format. <br><br>
        The JSON code given below for the Travel table represents the data of the table. The Working with Data help section elaborates on the custom JSON data format and the supported data types.</td>
    </tr>
</tbody>
</table>

<br>

#### Sample Table Representation

Table Name: Travel

{
 "item": {
  "DestinationName": {
		"S": "Honolulu"
			},
 	"Distance": {
		"N": 4960
		},
	 "BestTimeToVist": {
		"L":
		   [
			{
  "S": "September"
			},
			{
  "S": "October"
			},
			{
  "S": "November"
			}
   ]
			}, 
"EstimatedCost": {
		"N": 2500
			}
},
	"item": {
 "DestinationName": {
		"S": "Prague"
			},
 	"Distance": {
		"N": 4081
			},
	"Location": {
		"M": {
  	"Country": {
			"S": "Czech Republic"
				},
 	"Continent": {
			"S": "Europe"
				}
			}
  	},
 "EstimatedCost": {
			"N": 3000
			}
 },
"item": { 
	"DestinationName": {
		"S": "Marrakesh"
			},
 "Distance": {
		"N": 3700
			},
 "BestTimeToVist": {
		"L":
		[
			{
   "S": "March"
			},
			{
   "S":	"April"
			},
			{
   "S": "September"
			},
			{
 	"S": "October"
			}
  	]
	}, 
 "Location": {
			"M": {
  	"Country": {
			"S": "Morocco"
			},
		"Continent": {
			"S": "Africa"
			}
  	}
		},
 "EstimatedCost": {
		"N": 1700
		}
 }
}



The *Travel* table represents a simple NoSQL table in the Custom JSON format. The structure includes nested attributes and arrays: the BestTimeToVist is present as an array of the data type list ("L"), and the Location attribute is a nested attribute of the data type map ("M") containing the keys Country and Continent.

Note: The table presented here is a representation of the Catalyst Custom JSON format. The formats for constructing data in each server-side SDK in this JSON format varies. To learn about the general syntax of the Catalyst Custom JSON format present in this table, as well as the supported data types and their notations, refer to this section. 

<br>

### Table Keys

Following a typical NoSQL architecture, Catalyst NoSQL stores data in partitions across clusters, also known as shards. These shards can also be replicated over many servers in mirrors. This distributed storage across multiple nodes breaks down datasets into smaller chunks and promotes optimization. 

While querying data in a NoSQL table, we must be able to locate the partition a specific item is stored in. Moreover, sorting through a partition to locate an item also involves additional efforts. These are accomplished with the help of distinct keys that identify partitions or sort through them, as described below.

#### Terminology

<br>

<table class="content-table nosql-components-table">

<thead>
        <tr>
            <th class="w10p">Component Name</th>
            <th class="w30p">Description</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>Partition Key</td>
        <td>The partition key identifies a logical partition in a distributed storage that a data item is stored in. These logical partitions are mapped to physical storage nodes in the backend through hash functions.<br><br>
        In the sample table Menu discussed below, the attribute Category is a partition key.</td>
    </tr>
    <tr>
        <td>Sort Key</td>
        <td>The primary sort key sorts through a specific partition to locate a data item and returns it in a sorted order if more than 1 item matches with the partition key in the data. This is done by identifying it from a range of key hashes. Catalyst enables you to add a sort key optionally while creating a NoSQL table. <br><br>
        In the sample table Menu discussed below, the attribute DishName is regarded as a sort key.</td>
    </tr>
    <tr>
        <td>Simple Primary Key</td>
        <td>A simple primary key in Catalyst NoSQL denotes the partition key alone. <br><br>
        When you choose to only configure a partition key for a NoSQL table without a sort key, the partition key will act as the primary key of the table by uniquely identifying an item in it. This is similar to the concept of a primary key in a relational database. <br><br>
        In the sample table Travel discussed in the previous section, the attribute DestinationName is regarded as the primary key, as this attribute must be present in all items and no two items with the same values for this attribute can exist.<br><br>
        However, in the sample table Menu discussed below, the partition key Category does not uniquely identify an item, because multiple items can exist with the same value for it. This is because the Menu table uses a composite primary key.
</td>
    </tr>
    <tr>
        <td>Composite Primary Key</td>
        <td>The composite primary key includes both a partition key and a sort key to uniquely identify an item, i.e., the combination of both keys act as a primary key. Querying a table with the composite primary key is global, as the data spans across multiple partitions.<br><br>
        Unlike the simple primary key which requires the partition key to be unique, you can store non-unique values for the partition key here, as long as you define a sort key as well. <br><br>
        Note: For all the items that have the same partition key in a table, the sort keys must be unique.
        The sample table Menu discussed below contains a composite primary key wherein the partition key Category and the sort key DishName together uniquely identify a data item (a dish).</td>
    </tr>
    <tr>
        <td>Additional Sort Keys</td>
        <td>Catalyst NoSQL allows you to configure additional sort keys, besides the main sort key, which is a part of the composite primary key. <br><br>
        Additional sort keys are used if you require the sorting to be performed based on a different key besides the main sort key, or if the main sort key is unknown for a specific item. In this case, a combination of the partition key and an additional sort key will be used as a composite primary key.<br><br>
        Querying a table with additional sort keys are similar to local indexing, as they are all used with the same partition key to sort in that specific partition alone.<br><br>
        Note: Catalyst allows you to configure a maximum of 5 additional sort keys for a table.
        In the sample table Menu discussed below, the attributes PreparationTime and Calories are configured as additional sort keys.</td>
    </tr>
</tbody>
</table>

<br>

#### Sample Table Representation

Table Name: Menu

{
 "item": {
	"Category": {
		"S": "Pizza"
			},
 "DishName": {
		"S": "Vegan"
			},
 "Calories": {
		"N": 350
			},
 "PreparationTime": {
		"N": 20
			},
 	"Cost": {
		"N:" 25
			},
 "DiscountPercentage": {
		"N": 5
			},
 "KeyIngredients": {
		"L": [
 		{
		"S": "Pizza Base"
		},
		{
 		"S": "Pizza Sauce"
		},
		{
 		"S": "Olives"
		},
		{
 		"S": "Bell Peppers"
		},
		{
 		"S": "Corn"
		},
		{
 		"S": "Onions"
		}
 		]
		}
	},
	"item": {
 	"Category": {
		"S": "Pizza"
			},
 "DishName": {
		"S": "Chicken Overload"
			},
 "Calories": {
		"N": 450
			},
 "PreparationTime": {
		"N": 30
			},
 "KeyIngredients": {
 	"L":	[
			{
   "S": "Pizza Base"
			},
			{
 		"S": "Pizza Sauce"
			},
			{
 		"S": "Fried Chicken"
			},
			{
		"S": "Paprika"
			}
 	]
	}
	},
	"item": {
 "Category": {
		"S": "Sandwich"
			},
 "DishName": {
		"S": "Vegan"
			},
 "Calories": {
		"N": 300
			},
	"PreparationTime": {
		"N": 20
			},
 	"Cost": {
		"N": 25
		},
"DiscountPercentage": {
		"N": 15
		}
}
}


<br>

The Menu table includes various attributes of which Category is the partition key, DishName is the sort key, and PreparationTime and Calories are additional sort keys. 

Note: The table presented here is a representation of the Catalyst Custom JSON format. The formats for constructing data in each server-side SDK in this JSON format varies. To learn about the general syntax of the Catalyst Custom JSON format present in this table, as well as the supported data types and their notations, refer to this section. 

The composite primary key enhances data querying. If this table was configured with just the simple primary key, i.e., with Category (example: "Pizza"), then querying it will fetch all items of that Category (all the "pizzas" in the menu). However, because it is configured with a composite primary key, i.e, with Category and DishName, then querying it with both the keys will retrieve a unique item of those values (example: "Pizza" and "Vegan").

Similarly, the additional sort keys provide further flexibility while querying the table within the same partition. You can choose to query the table with the additional sort key PreparationTime in combination with the partition key Category (example: "Sandwich" and "20").

Before discussing indexing, let's understand a special attribute that Catalyst NoSQL provides for all tables.

<br>
 
### Time To Live (TTL)

Time To Live (TTL) provides an automated way of deleting items in the Catalyst NoSQL tables after a specific point of time. You can configure an attribute to hold the expiration timestamp in your table while you create it. You can then add the expiration timestamp of each item in the table in the Unix epoch time format while adding the data. Catalyst will permanently delete the items in the table past their expiration time automatically, saving you from performing manual updates and consuming write throughputs.

The TTL attribute is handy in removing items that will not be needed beyond a specific point of time or whose validity is short-lived. The items that are deleted by Catalyst automatically after they are past their expiration date will be removed from the table and from anywhere they are indexed.

Catalyst operates a built-in scheduler once every 24 hours to check for any items whose TTL attribute values indicate expired. This check is performed in all NoSQL tables of all your projects, and the items past their expiration are deleted permanently.

Let's understand TTL with an example. Assume we create an attribute named Expiry to store the TTL timestamp in the Menu table given in the previous section. We can then define the expiration timestamp for all the items in the table in the following manner. 

#### Sample Table Representation

Table Name: Menu

{
 "item": {
	"Category": {
 	"S": "Pizza"
  	},
 "DishName": {
 	"S": "Vegan"
  	},
 "Calories": {
 	"N": 350
  	},
 "PreparationTime": {
 	"N": 20
  	},
 	"Cost": {
 	"N:" 25
  	},
 "DiscountPercentage": {
 	"N": 5
  	},
"Expiry": {
		"N": 1715755926
		}
	},
	"item": {
 	"Category": {
 	"S": "Pizza"
  	},
 "DishName": {
 	"S": "Chicken Overload"
  	},
 "Calories": {
 	"N": 450
  	},
 "PreparationTime": {
 	"N": 30
  	},
	"Expiry": {
 	"N": 1715565610
 	}
	},
	"item": {
 "Category": {
 	"S": "Sandwich"
  	},
 "DishName": {
 	"S": "Vegan"
  	},
 "Calories": {
 	"N": 300
  	},
	"PreparationTime": {
 	"N": 20
  	},
 	"Cost": {
 	"N": 25
 	},
"DiscountPercentage": {
 	"N": 15
 	}
"Expiry": {
 		"N": 1715700869
 		}
}
}



<br>

Note: The table presented here is a representation of the Catalyst Custom JSON format. The formats for constructing data in each server-side SDK in this JSON format varies. To learn about the general syntax of the Catalyst Custom JSON format present in this table, as well as the supported data types and their notations, refer to this section. 

Points to remember:

* You will be able to update the TTL attribute value for items in a NoSQL table anytime you require. When the built-in Catalyst scheduler runs, it will identify and process the items based on the latest TTL value.

* You can also delete the TTL attribute for items as per your needs, based on the given values


--------------------------------------------------------------------------------
title: "Create and Manage Tables"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.212Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/create-manage-tables/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Create and Manage Tables in NoSQL

Let's now discuss working with NoSQL tables from the Catalyst console. 

Note: The configurations made in this section, such as adding and managing tables, can only be done from the remote console, and not through the SDKs or API. You can perform data operations from the server-side SDKs and API. 

You can access NoSQL in your Catalyst project from the CloudScale service in your console. 

### Create a Table

To create a table in Catalyst NoSQL in your project:

1. Navigate to the CloudScale service in the console, then click NoSQL. 

<br>

2. Click Create Table.

3. Enter a name for the table. You must configure the Partition Key by providing a key name and selecting the data type of the key. 

Note: You can only configure the partition key with the data types String, Numeric, or Binary. To learn about the supported data types and their notations, refer to this section. 



Note: You will not be able to modify or delete the partition key configured for a table, or delete the partition key attribute from any data item, after you configure it. Because this is the primary key, all items must include this value. <br>

4. You can optionally configure a Sort Key for the table to include a Composite Primary Key by selecting Yes for "Include Sort Key?". However, if you only prefer having the partition key (Simple Primary Key), then select No. <br>

    If you include a sort key, enter the key name and select the data type of the key.

Note:

* You will not be able to modify or delete the Sort Key in a table, after you configure it. 

* You can only configure the sort key key with the data types String, Numeric, or Binary. To learn about the supported data types and their notations, refer to this section. 

<br>

5. If you require Additional Sort Keys to be included in your table, you can add them by providing the key name and selecting the data type. You can add multiple keys by clicking (+).



Note:

* You will not be able to modify or delete the Additional Sort Keys in a table, after you configure it.

* Catalyst allows you to configure a maximum of 5 Additional Sort Keys in a table.

* You can only configure the additional sort key keys with the data types String, Numeric, or Binary. To learn about the supported data types and their notations, refer to this section. 

<br>

6. Configure an attribute to store the TTL timestamp for the table. You can add values for this attribute for each item in the table to indicate their expiration date.



Note: You can disable the TTL attribute in a table after you configure it. However, you will not be able to change the attribute's name, or enable/configure it again once disabled.<br>

7. After you configure the table, click Create. 

The NoSQL table will be created and listed under Tables in your project. Catalyst will automatically create a unique Table ID for your table that you can use to refer it while performing SDK and API actions.

There are three sections in the table: Overview, Indexes, and Data.

<br>

### The Overview Section

The Overview section provides a glimpse of the table's configuration and details. It displays all essential information, such as the unique Table ID, details of the person who created it, the TTL attribute, etc. 



The Storage Size indicates the size of the table. An empty table will contain 0 bytes, as well as 0 data items. Catalyst operates a built-in scheduler once every 24 hours that calculates and updates the Storage Size and No. of Items of each table.

You can also view the partition key, sort key, and additional sort keys configured for the table. The No. of Indexes indicates the number of indexes created from the table. Click View here to navigate to the Indexes section.

<br>

### Edit a Table

You can edit a table in NoSQL and modify the table name, or disable the TTL attribute configured for a table. However, you will not be able to modify the partition key, sort key, and additional sort keys that you set up, or the name of the TTL attribute.

To edit a NoSQL table:

1. Click the ellipsis icon from the Overview section of the table, then click Edit.

<br>

2. Modify the required details of the table, then click Update.



Note: If you disable the TTL attribute, you will not be able to enable or configure it again for the table. Disabling the TTL attribute will stop Catalyst from automatically deleting expired data items from the table. 

<br>

### Delete a Table

You can permanently delete a table and all the data it contains in NoSQL in the following manner:

1. Click the ellipsis icon from the Overview section of the table, then click Delete.

<br>

2. Click Delete in the confirmation pop-up.




--------------------------------------------------------------------------------
title: "Query Search"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.213Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/query-search/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Query Search in NoSQL

### Overview

Catalyst enables you to perform query searches to read table data in NoSQL from the console, the server-side SDK in Java, Node.js, or Python, or through API. The Data section in the console includes a query section where you can seach for data and the results will be displayed in it.

A query operation in NoSQL is scoped to a partition of the data storage. This means that you can search within a partition for an item based on the partition key alone, in case the table is configured with a simple primary key. If the table is configured with a composite primary key, the search occurs using the combination of a primary key and sort key. You can also utilize additional sort keys that you configured for a table with the combination of the partition key to execute query searches. Refer to this page to learn about table keys.

You can base a query search off a table or off an index of the table. This will inform Catalyst to look for the appropriate partition and provision the appropriate primary keys for the search.

<br>

### Supported Operators

Catalyst supports several operators that you can use to execute queries. These operators can only be used with the primary sort key and additional sort keys. Depending upon the data type of the sort keys, the supported operators vary.

Note: You can only use the "EQUALS" operator with the partition key. The operators listed below can only be used with the sort key of an index, or the sort key and additional sort keys of a table.

<br>

<table class="content-table nosql-components-table">

<thead>
        <tr>
            <th class="w10p">Data Type of the Sort Key</th>
            <th class="w10p">Supported Operators</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>String</td>
        <td>Equals, Not Equals, Between, Not Between, Greater Than, Lesser Than, Greater Than or Equal To, Lesser Than or Equal To</td>
    </tr>
    <tr>
        <td>Numeric</td>
        <td>Equals, Not Equals, Between, Not Between, Begins With, Ends With, Greater Than, Lesser Than, Greater Than or Equal To, Lesser Than or Equal To, Contains, Not Contains, In, Not In</td>
    </tr>
</tbody>
</table>
<br>

Note: All the supported operators are available through SDK and API operations, while some of these supported operators are not available in the console search. Refer to the respective SDK and API help documentation for details.

<br>

### Execute a Query Search

You can execute a query search from the Catalyst console to read data from a NoSQL table in the following manner:

1. Navigate to the Data section of the table in NoSQL.


<br>

2. You can select the table name or any one of the indexes to perform the search in, from the drop-down on top. Catalyst will list the table and all indexes.


<br>

3. If the table is configured with the simple primary key, enter a value for the partition key to search. The data type configured for the partition key will be automatically shown.

    If the table is configured with the composite primary key, enter the value for the partition key, then select the required operator from the list for the sort key and enter a value to search. You can choose the main sort key or any one of the additional sort keys, if configured. The data type configured for the sort key will be automatically shown.



Note: You can only use the ["EQUALS" operator](#supported-operators) with the partition key. Depending on the data type of the primary or additional sort key, appropriate operators will be available for selection. <br>

4. You can also check the "Enable this to search using ascending sort" box to list the search results in the ascending order. Descending sort will be used by default. If no sort key is configured for the table or the index you select, the sorting order of retrieved data is based on the partition key of the table.

5. After you configure the query parameters, click Search.

<br>

The query results will be displayed in this section. If no results are found, Catalyst will display an appropriate message.



You can use the filter option to choose the columns to be displayed, or view the data as JSON, as discussed in the previous section.



--------------------------------------------------------------------------------
title: "Third-Party Migration"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.213Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/third-party-migration/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Third-Party Migration

### Introduction

Catalyst provides the ability to migrate NoSQL databases from third-party sources. This migration is supported only for databases of the NoSQL type and not for relational or other databases.

The provision to migrate a database from an external source enables you to easily switch to Catalyst for your NoSQL needs. If you had been maintaining NoSQL databases for Catalyst applications or microservices in an external environment, you can benefit from integrating it within your Catalyst ecosystem and manage the entire setup here.

You can perform the migration from the Catalyst console with just the click of a few buttons. All you would need to do to migrate databases is to provide the required credentials to access the third-party database, and choose the tables to migrate. Catalyst ensures you face zero downtime or latency issues during the migration process. After the database is migrated, you can access the tables in the NoSQL section in console inside your project.

Note: You can refer to the Pricing page for the pricing information of storage as well as CRUD operations in NoSQL.

<br>

Catalyst currently supports migration from this third-party source: AWS DynamoDB


There are two different migration options that you can utilize:

* Migrating Metadata: This option will only migrate the schema and metadata of your tables from the third-party source. This is available only in the development environment in Catalyst.

* Migrating Data: This option will migrate the data of your tables along with the configurations from the third-party source. This is available only in the production environment in Catalyst.

You can choose the appropriate option you require and perform migration from the suitable environment.

<br>

## Migrating from AWS DynamoDB

To perform migrations from AWS, you will be required to configure AWS Access Key Credentials with Catalyst. The AWS access key credentials allow you to access AWS resources through their CLI or API.

AWS access keys are composed of two parts: Access Key ID and Secret Access Key. You will need to configure both in Catalyst, and also provide information about the AWS region your AWS account fall under.

Note: Refer to the links provided above to learn about creating or obtaining access key credentials for your AWS account, as well as to find your account's region.

<br>

### Migrate Metadata from DynamoDB

You can migrate metadata of the tables in your AWS DynamoDB while you work in the development environment of Catalyst. This is the default environment in Catalyst and therefore, you can access this migration option by default. You can use this option if you prefer creating new data for your database, and only require the table configurations.

The metadata migration will migrate the table configurations and index configurations of the tables you select, such as their configured partition keys and sort keys, as well as any other meta information or configurations that Catalyst NoSQL supports.

To migrate metadata from AWS DynamoDB into Catalyst NoSQL in your project:

1. Navigate to NoSQL from the CloudScale section from the development environment in the console, then click Third-Party Meta Migration.



<br>

2. This will open a pop-up. Enter the Access Key ID, Secret Access Key, and the region of your AWS account. Then, click Next.


<br>

3. Select the tables whose metadata you want to migrate from your DynamoDB. Then, click Import.
	


<br>

Catalyst will then schedule the migration process. The time taken to complete the migration depends on the number of tables and their sizes. 



<br>

After the tables are migrated, you will be notified.



<br>

You can then access the imported tables in your project by refreshing the console. You will find the imported tables with their configurations in NoSQL, and you can then proceed to add data.



<br>

### Migrate Data from DynamoDB

To migrate data of the tables in your AWS DynamoDB, you will first need to access the production environment in Catalyst. If you have never deployed your Catalyst project to production, you must first do that to enable production. Refer to this help page for deploying projects to the production environment.

Once you are able to access the production environment of your project, you can switch to the production environment in the console from the header.



You can use the option to migrate data along with the schema if you require the entire database to be migrated. 
This will import the data of the tables you select, as well as the configurations and metadata of the tables you select. This includes the table configurations and index configurations of the tables you select, such as their configured partition keys and sort keys, as well as any other meta information or configurations that Catalyst NoSQL supports.

<br>

To migrate data from AWS DynamoDB into Catalyst NoSQL in your project:

1. Navigate to NoSQL from the CloudScale section from the production environment in the console, then click Third-Party Data Migration.



<br>

2. This will open a pop-up. Enter the Access Key ID, Secret Access Key, and the region of your AWS account. Then, click Next.



<br>

3. Select the tables whose data you want to migrate from your DynamoDB. Then, click Import.


	
Catalyst will then schedule the migration process. The time taken to complete the migration depends on the number of tables, and their sizes based on the volume of the data. 



<br>

After the tables are migrated, you will be notified. 



<br>

You can then access the imported tables with their data in your project. You can update or delete items, or process the data as required.




## Indexing



--------------------------------------------------------------------------------
title: "Introduction"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.248Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/indexing/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Indexing in NoSQL

Catalyst NoSQL provides the ability to create indexes for NoSQL tables that will allow you to execute alternate queries on the table data, without making use of the primary keys. This means that you can create and utilize secondary indexes and search for data items by other attributes besides the partition key and sort key.

Indexes facilitate convenience and add flexibility in data retrieval operations, as come in handy during scenarios that require you to prioritize non-conventional attributes in a table. Querying using indexes quickens the data read process and promotes efficiency. You can also modify or delete indexes in a table based on your requirements without affecting the main table in any manner.

### Architecture of Indexes

Catalyst NoSQL indexes span across the entire table and all partitions that the table data is stored in. This cross-partition or global indexing feature proves highly beneficial as it allows you to execute queries across all partition keys of a table. 

Catalyst enables you to create a maximum of 20 indexes for a table. You can configure individual partition keys and sort keys for each index you create. Because the indexing is global, you will be able to configure partition and sort keys different from the ones configured in the main table. 

Essentially, an index can be regarded as a copy of the main table created with different partition and sort keys for different requirements in querying data. In terms of the architecture, when an index is created for a table, a copy of it is stored in different storage nodes with the same partitioning rules as applicable for the main table. Therefore, when you execute queries based on a secondary index, you can still access all the attributes and data of the table.

Note: Catalyst will automatically update indexes when you add, update, or delete data from its base table.

<br>

### Index Types

Catalyst provides three different ways to index a table in NoSQL:

* Indexing All Attributes: This will create an index of all the attributes in a table. When you choose this option, Catalyst will essentially replicate all the table attributes and store them based on the partition key you configure for the index.

* Indexing Only Keys: This will index only the partition key, sort key, and the additional sort key attributes, if any, in a table. These key attributes are stored based on the partition key you configure for the index.

* Indexing Specific Attributes: This will index specific attributes of a table that you select. The select attributes are replicated and stored based on the partition key you configure for the index.

When you execute a query based on an index, the partition key and sort key attributes of the table and the index will be returned along with other attributes based on the type you configured.

Let's understand indexing better with an example. The Menu table discussed in the previous sections is updated and shown below.

#### Sample Table Representation

Table Name- Menu

{
 "item": {
	"Category": {
 	"S": "Pizza"
  	},
 "DishName": {
 	"S": "Vegan"
  	},
 "Calories": {
 	"N": 350
  	},
 "PreparationTime": {
 	"N": 20
  	},
"DiscountPercentage": {
 	"N": 12
 	},
 "KeyIngredients": {
 	"L": [
 		{
 	"S": "Pizza Base"
 	},
 	{
 		"S": "Pizza Sauce"
 	},
 	{
 		"S": "Olives"
 	},
 	{
 		"S": "Bell Peppers"
 	},
 	{
 		"S": "Corn"
 	},
 	{
 		"S": "Onions"
 	}
 		]
 	}
	},
	"item": {
  "Category": {
 	"S": "Pizza"
  	},
 "DishName": {
 	"S": "Chicken Overload"
  	},
"Cost": {
 "N": 25
 },
"DiscountPercentage": {
 "N": 15
 },
 "Calories": {
 	"N": 450
  	},
 "PreparationTime": {
 	"N": 30
  	}
	},
	"item": {
 "Category": {
 	"S": "Sandwich"
  	},
 "DishName": {
 	"S": "Vegan"
  	},
 "Calories": {
 	"N": 300
  	},
	"PreparationTime": {
 	"N": 20
  	},
  "Cost": {
 	"N": 20
 	},
"DiscountPercentage": {
 	"N": 10
 	}
}
}



Note: The table presented here is a representation of the Catalyst Custom JSON format. The formats for constructing data in each server-side SDK in this JSON format varies. To learn about the general syntax of the Catalyst Custom JSON format present in this table, as well as the supported data types and their notations, refer to this section. 

Assume you create an index, Pricing, for this table with the following configurations-

* Partition Key: Cost
* Sort Key: DiscountPercentage
* Index Type: Specific Attributes (Calories and PreparationTime)

Given below is a representation of the created index.

#### Sample Index Representation

Index Name- Pricing

{
"item": {
	"Cost": {
 	"N": 25
 	},
	"DiscountPercentage": {
 	"N": 15
 	},
"Category": {
 	"S": "Pizza"
 	},
"DishName": {
 	"S": "Chicken Overload"
 	}
"Calories": {
 "N": 450
 },
 "PreparationTime": {
 "N": 30
 }
},

"item": {
	"Cost": {
		"N": 20
		},
	"DiscountPercentage": {
		"N": 10
		},
	"Category": {
		"N": "Sandwich"
		},
	"DishName": {
		"N": "Vegan"
		},
"Calories": {
 "N": 300
 },
 "PreparationTime": {
 "N": 20
 }
	}
}


Note: Data items that do not contain the partition key of an index are skipped from being indexed. In this example, the item identified by "Pizza" and "Vegan" from the main table is not indexed because it does not include the value for the index's partition key, Cost. 

When you execute a query based on the index Pricing, Catalyst will search for items against the attribute Cost and will sort the results based on the attribute DiscountPercentage if more that one result matches. The selected attributes (Calories and PreparationTime) will be returned in the query for the matching items, along with the primary keys of the table and the index.

--------------------------------------------------------------------------------
title: "Create and Manage Indexes"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.261Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/indexing/create-manage-indexes/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Create and Manage Indexes

Let's look at creating and working with indexes in your NoSQL table in the Catalyst console.

Note: The configurations made in this section, such as creating and managing indexes, can only be done from the remote console, and not through the SDKs or API. You can perform data operations from the server-side SDKs and API.

### Create an Index

To create an index for a NoSQL table in your project:

1. Navigate to the Indexes section of the table from the NoSQL component, then click Add Index.



2. Enter a name for the index. You must configure the Partition Key for the index by providing a key name and selecting the data type of the key. 



Note: You will not be able to modify or delete the Partition Key of the index, after you configure it. 

3. You can optionally configure a Sort Key if you require for the index by selecting Yes for "Include Sort Key?". However, if you only prefer having the partition key, then select No. If you include a sort key, enter the key name and select the data type of the key.

Note: You will not be able to modify or delete the Sort Key of the index, after you configure it.

4. Select an Attribute Type for the index. 



If you select Include Columns, specify the attributes to index. Catalyst will enable you to add multiple attributes in the window. You can click (-) to remove an attribute.



5. After you configure the index, click Create.

The index for your NoSQL table will be created and listed in the Indexes section. Catalyst will automatically create a unique Index ID for your index that you can use to refer it while performing SDK and API actions.

<br>

### The Index Section

The Index section provides a glimpse of all the indexes configured for a particular table and their details. It displays essential information, such as the unique Index ID, the partition key and sort key configured for it, and the size and the number of items in the index.



An empty table will contain 0 bytes and 0 data items. Catalyst operates a built-in scheduler once every 24 hours that calculates and updates the Storage Size and No. of Items of each index.

For the indexes created for specific attributes, the index section will display a View button to display all attributes that are indexed. 


 
You can view the attributes by clicking it.



<br>

### Edit an Index 

You can edit an index created for a table in NoSQL to modify the index name. However, you will not be able to modify the partition key, sort key, or attribute types that you configured for it.

To edit the index of a table:

1. Click the ellipsis icon for the index in the Indexes section, then click Edit.

<br>

2. Modify the index name, then click Update.



<br>

### Delete an Index

You can permanently delete the index of a table in NoSQL. This will delete it from the storage and you will no longer be able to execute queries based on the index.

To permanently delete an index of a NoSQL table:

1. Click the ellipsis icon for the index in Indexes section, then click Delete.

<br>

2. Click Delete in the confirmation pop-up.




## Working with Data



--------------------------------------------------------------------------------
title: "Introduction"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.262Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/working-with-data/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Working with Data in NoSQL


The data units in NoSQL are referred to as *Items*, wherein each data item is similar to a record or row in a relational database, as described in this Terminology. Catalyst enables you to perform CRUD operations on your NoSQL tables using the server-side SDKs of Java, Node.js, or Python and through API. 

Note: You can also perform CRUD operations from the Catalyst console to test working with data in NoSQL. However, you will only be able to add one item in a table from the console.

Catalyst supports the key-value pair based document-type data storage with the ability to add data in the Catalyst Custom JSON format, which is explained in the next section. 

Note: You can add data in the regular JSON format that follows the International standard syntax from the Catalyst console alone to test. However, when working with the SDKs and API, you will only be able to add data in the Custom JSON format.

Catalyst also enables you to use multiple data types in the JSON data, that you can configure NoSQL attributes with. You can declare the right data type for an attribute while adding or updating data in the table.

<br>

### Supported Data Types

The data types supported in Catalyst for NoSQL attributes are listed below.

<br>

<table class="content-table nosql-components-table">

<thead>
        <tr>
            <th class="w10p">Data Type</th>
            <th class="w10p">Notation</th>
            <th class="w30p">Description</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>String</td>
        <td>S</td>
        <td>Stores a sequence of characters </td>
    </tr>
    <tr>
        <td>Number</td>
        <td>N</td>
        <td>Stores a numerical value</td>
    </tr>
    <tr>
        <td>Binary</td>
        <td>B</td>
        <td>Stores a binary number that represents a sequence of bytes </td>
    </tr>
    <tr>
       <td>Boolean</td>
        <td>BOOL</td>
        <td>Stores one of these boolean values: true or false </td>
    </tr>
    <tr>
        <td>Set of String</td>
        <td>SS</td>
        <td>A set that stores one or more unique strings </td>
    </tr>
    <tr>
        <td>Set of Numbers</td>
        <td>SN</td>
        <td>A set that stores a collection of numbers </td>
    </tr>
    <tr>
        <td>Set of Binary</td>
        <td>SB</td>
        <td>A set that stores a collection of binary numbers as a byte set </td>
    </tr>
    <tr>
        <td>List</td>
        <td>L</td>
        <td>Stores ordered elements of the same data type </td>
    </tr>
    <tr>
        <td>Map</td>
        <td>M</td>
        <td>Stores an unordered collection of key-value pair elements </td>
    </tr>
    <tr>
        <td>Null</td>
        <td>NULL</td>
        <td>Stores only one value: NULL </td>
    </tr>
</tbody>
</table>

To understand the notations and usage of these data types while adding data in NoSQL, refer to the [Catalyst Custom JSON format section](#the-catalyst-custom-json-format).

Note: 

* When you configure a table or an index in NoSQL from the console, Catalyst allows you to only select one of the two data types, String or Number, for the primary keys of the table. This includes the partition key, sort key, and additional sort keys.

* While adding or updating data in your NoSQL table, you must ensure that always you add the appropriate value for an attribute that matches the data type that you declare for it. Any mismatches between the data types and values will throw errors.

<br>

### The Catalyst Custom JSON Format

The Catalyst Custom JSON is the format of JSON data that Catalyst can process for NoSQL. The syntax is similar to the standard JSON Format with the addition of specifying the [data type](#supported-data-types) that each attribute is configured with.

Let's look at a sample table to understand the Catalyst Custom JSON format. 

#### Sample Table Representation

Table Name- Employees

{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"YearOfJoining":{
  	"N": 2011
  	},
 	"PriorExperience":{
  	"BOOL": false
  	},
 	"Location": {
  	"M": {
   	"Country": {
    	"S": "USA"
   	},
   	"City": {
    	"S": "New York"
    	}
   	}
  	}
},

"item": {
  	"EmpID": {
   	"N": "10113"
   	},
  	"FirstName":{
   	"S": "Lana"
   	},
  	"LastName":{
   	"S": "Belle"
   	},
  	"YearOfJoining":{
   	"N": 2019
   	},
  	"PriorExperience":{
   	"BOOL": true
   	},
  	"Department": {
   	"S": "IT"
  	}
},
	"item": {
  	"EmpID": {
   	"N": "29123"
   	},
  	"FirstName":{
   	"S": "Kevin"
   	},
  	"LastName":{
   	"S": "Wilson"
   	},
  	"YearOfJoining":{
   	"N": 2023
   	},
 "Clubs":{
  	"L":
 		[
    {
   	"S": "Innovate"
   	},
   	{
   	"S": "Swimmers of NPY"
   	},
  	{
 			"S": "Technova"
 			}
 		]
  	}
  } 
}


The *Employees* table includes nested JSON properties under the Location attribute, as well as an attribute, Clubs, with array values. In this table, each attribute is denoted with the data type configured for it, such as N (Number) for EmpI and YearOfJoining, or S for FirstName and LastName. The boolean attribute PriorExperience is denoted as BOOL.

Refer to the [Supported Data Types section](#supported-data-types) for all data types and their notations that you can use.

#### Important Points to Remember:

* The primary keys of the table- the partition key and the sort keys, must be present in the root while constructing an item for adding or updating data in a table. The format shown here is only a representation. The formats for constructing data in each server-side SDK in this JSON format varies.

* You can add or update data for your NoSQL table from the Catalyst console in either the standard JSON Format or the Catalyst Custom JSON Format to test. 

* You can only add or update data in your NoSQL table through the server-specific SDK of Java, Node.js, or Python, or through API, in the Catalyst Custom JSON format. The SDK help resources contain the formats and examples of constructing data items and inserting them in that programming environment.

* If you use the standard JSON format while adding or updating data from the console, the data types associated with the primary key attributes while creating the table or index will be processed automatically. For all other attributes, their data types are recognized automatically by Catalyst based on the values you provide.



--------------------------------------------------------------------------------
title: "Add and Manage Data"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. Create, manage, and query data in NoSQL tables with ease, and perform CRUD operations in Java, Node.js, and Python."
last_updated: "2026-06-10T06:04:37.263Z"
source: "https://docs.catalyst.zoho.com/en/cloud-scale/help/nosql/working-with-data/add-manage-data/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Add and Manage Data in a NoSQL Table

### Overview

This section covers performing CRUD operations in Catalyst NoSQL, as well as managing data from the Catalyst console. Refer to the Java, Node.js, and Python SDK and the API documentation for performing data operations through code or API.

Here are a few points to remember when you add or update data in a Catalyst NoSQL table:

* The values for the configured partition key of a table must be present in each data item, if it is configured with a simple primary key. In case of a composite primary key, both partition key and sort key values must be present in each data item.

* The data types configured for the partition key and sort key of a table must match with the data types you provide for the values of those attributes.

* You will not be able to change the data types of the partition key and sort key in a table or the attributes associated with them, when you add or update data in the table.

* The maximum total size of an item provisioned in Catalyst NoSQL is 400 KB.

<br>

### Add Data in a Table

To add data in a NoSQL table from the Catalyst console to test:

1. Navigate to the Data section of the table from the NoSQL component, then click Add Data.



<br>

2. This will open a pop-up where you can add data to the table. Catalyst will display a template for the data, which will include the partition key and sort key configured for the table, in both the Custom and Standard JSON formats.

Note: You can only add one item in the table from the console. This is because, the data operations provided in the console are solely for testing purposes.


<br>

You can switch between the standard and Custom JSON view using the toggle button. However, there are certain conditions that data in the standard format must satisfy for you to be able to switch to the Custom format. This is explained below.



<br>

3. Add the data for the table in either of the formats, then click Create.
	
Custom JSON Format:



Standard JSON Format:


<br>

#### Conditions when the JSON View Toggle Button is Disabled

In certain cases, you will not be able to toggle between the Standard and the Custom JSON format while adding or updating data in the console. These include:

1. When the data type of an attribute is invalid or not supported in Catalyst

2. When the value provided for a key in the JSON is invalid

3. When the JSON code added is invalid, or contains syntax or logical errors

4. When the data is valid but includes certain supported data types that cannot be rendered in the Standard JSON view. For example, SS (Set of Strings) or SN (Set of Numbers) cannot be rendered, but the data you provide will be added to the table.

After you add the data in a NoSQL table, it will be displayed in the Data section in a tabular manner for easy viewing.



Note: Please remember that the table data will not be displayed persistently in the Data section. You will be able to view the table data only by querying in this section.

You can filter columns to be displayed upon querying or right after adding data through the console, using the Filter icon in the bottom-right corner. Select the required columns and click Apply.



This will display the selected columns.



<br>

#### View Table Data as JSON

1. You can view the table data in the JSON format by clicking the ellipsis icon against the table.



<br>

2. Then, click View JSON from the options.



This displays the table data in Catalyst Custom JSON format.



<br>

### Update Data in a Table

You can update your NoSQL table data easily from the console to test. All the specifications and constraints described for data addition apply to the data update operation as well. 

Note: If you update the data in a table from the console, it will essentially overwrite the existing data, as this is for testing purposes. However, if you update data from code through the SDKs, or through the API, the standard update process of a CRUD operation is applied.

To update the data of a NoSQL table in your project:

1. Click the ellipsis icon against the table, then click Edit.



<br>

2. Update the data in the Standard or the Custom JSON format, then click Update.



<br>

### Delete Data in a Table

To permanently delete the data you added in a NoSQL table for testing purposes:

1. Click the ellipsis icon against the table, then click Delete.



2. Click Delete in the confirmation pop-up.




---

## API Reference — NoSQL

--------------------------------------------------------------------------------
title: "Insert New Item"
description: "This API enables you to insert a new item in a NoSQL table."
last_updated: "2026-06-10T06:04:37.383Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/insert-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# NoSQL

Catalyst NoSQL is a fully managed non-relational, NoSQL data storage feature that enables you to store the semi-structured, unstructured, and disparate data of your applications. Catalyst supports document-type data storage in the key-value pair based JSON format. 

The Catalyst NoSQL APIs enable you to perform CRUD operations on your NoSQL tables. You can insert, update, delete, or fetch items, as well as execute queries on a table or a table's index.


# Insert Item

### Description

This API enables you to insert a new item in a NoSQL table in your project. The table is referred to by its unique ID or name. 

You can insert an item with or without specifying any conditions by passing the data in the Custom JSON format. 

Note: The table must already be created. You can create a NoSQL table from the console.

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}/item</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.item.INSERT



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

 Contains the main data to be inserted in the table. The item must be inserted in the Custom JSON format. Specify the partition key, if the table was configured with a simple primary key. Specify both the partition key and sort key, if the table was configured with a composite primary key.  

 The existing data of the table is retrieved and evaluated against this condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted. There are three ways to initialize a condition:


 The two built-in functions are: attribute_exist, which can be used to check for the presence of an attribute, and attribute_type, which can be used to check if the given attribute name belongs to the given type. 

 To perform direct comparison operations. Supported operators: contains, not_contains, begins_with, ends_with, in, not_in, between, not_between, equals, not_equals, greater_than, less_than, greater_equal, less_equal.  

To combine two or more conditions. Supported group operators: and, or.   

To negate the result of the conditions.    

### Response Details

The response will return the status of the insert operation, as well as the details of the item inserted such as the table_name, partition_key and sort_key, if configured.







curl -X POST \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/item \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d ‘{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	},
 	"Location": {
  	"M": {
   	"Country": {
    	"S": "USA"
   	},
   	"City": {
    	"S": "New York"
    	}
   	}
  	}
}
    }’




    {
    "status": "success",
    "data": {
        "table_name": "employeeDetails",
        "project_details": {
            "id": 4000000006007,
            "project_name": "EmpDatabase",
            "project_type": "Live"
        }
    }
    }
    

   

Insert Items- Java SDK</br></br>
Insert Items- Node.js SDK</br></br>
Insert Items- Python SDK
</br></br>






--------------------------------------------------------------------------------
title: "Update Item"
description: "This API enables you to update an item in a NoSQL table."
last_updated: "2026-06-10T06:04:37.384Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/update-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# Update Item

### Description

This API enables you to update an item from the existing data in a NoSQL table in your project. The table is referred to by its unique ID or name. 

You can pass the attributes to be updated with or without specifying any conditions in the Custom JSON format. 

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}/item</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.item.UPDATE



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

Denotes the partition key and sort key of the table.  

 Denotes the attribute to be updated along with its value. The update can be of two types: PUT (to add a new attribute within the item) and DELETE (to remove an attribute from the item). The attribute_path indicates the path within the item where the actual operation is to be done. The value to be updated can be of two types:


The actual value to be updated. 

 There are four functions that can be used: <br> if_not_exists - Checks the existence of the attribute and declares a value if it is not present.
append_list - Appends data to a list
add - Adds a value along with existing value or add an element in a set
reduction - Sub-traces a value from existing value or remove an element in a set. 

 
 The existing data of the table is retrieved and evaluated against this condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted. There are three ways to initialize a condition:


 The two built-in functions are: attribute_exist, which can be used to check for the presence of an attribute, and attribute_type, which can be used to check if the given attribute name belongs to the given type. 

 To perform direct comparison operations. Supported operators: contains, not_contains, begins_with, ends_with, in, not_in, between, not_between, equals, not_equals, greater_than, less_than, greater_equal, less_equal.  

To combine two or more conditions. Supported group operators: and, or.   

To negate the result of the conditions.    


### Response Details

The response will return the status of the insert operation, as well as the details of the item updated such as the table_name, partition_key and sort_key, if configured.







curl -X PUT \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/item \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d ‘{
	keys:{
		partition_key:{
			"S":"Country"
		},
		sort_key:{
			"N":"EmpID"
		},
	}
	update_attributes:{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	},
 	"Location": {
  	"M": {
   	"Country": {
    	"S": "USA"
   	},
   	"City": {
    	"S": "New York"
    	}
   	}
  	}
	}
}
    }’




    {
    "status": "success",
    "data": {
        "table_name": "employeeDetails",
        "project_details": {
            "id": 4000000006007,
            "project_name": "EmpDatabase",
            "project_type": "Live"
        }
    }
    }
    

   

Update Items- Java SDK</br></br>
Update Items- Node.js SDK</br></br>
Update Items- Python SDK
</br></br>






--------------------------------------------------------------------------------
title: "Fetch Item"
description: "This API enables you to fetch an existing item from a NoSQL table."
last_updated: "2026-06-10T06:04:37.384Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/fetch-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# Fetch Item

### Description

This API enables you to fetch an item from a NoSQL table in your project. The table is referred to by its unique ID or name. 

You can specify the attributes of the items to be fetched, and even denote if they need to be fetched from the master or a slave cluster.

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}/item/fetch</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.item.READ



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

Denotes the partition key and sort key of the table.  

List of attributes to be returned.  

Declares if the read has to be done from master or slave. If set to false, it is queried from the slave. Accepted values: true, false.  


### Response Details

The response will return the status of the fetch operation, as well as the items that are fetched. Either all the attributes or specified attributes of the items will be fetched.







curl -X GET \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/item/fetch \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d ‘{
	keys:{
		partition_key:{
			"S":"Country"
		},
		sort_key:{
			"N":"EmpID"
		},
	}
	required_attributes: {
		"EmpID",
 	"FirstName",
	"LastName",
	"PriorExperience"
  	},
	consistent_read: "true"
	}’




    {
    "status": "success",
    "data": {
        fetched_attributes:{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	}
  	}
    }
	}
	}
    

   

Fetch Items- Java SDK</br></br>
Fetch Items- Node.js SDK</br></br>
Fetch Items- Python SDK
</br></br>






--------------------------------------------------------------------------------
title: "Delete Item"
description: "This API enables you to delete an item from a NoSQL table."
last_updated: "2026-06-10T06:04:37.384Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/delete-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# Delete Item

### Description

This API enables you to insert a new item in a NoSQL table in your project. The table is referred to by its unique ID or name. 

You can insert an item with or without specifying any conditions by passing the data in the Custom JSON format. 

Note: The table must already be created. You can create a NoSQL table from the console.

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}/item</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.item.INSERT



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

 Contains the main data to be inserted in the table. The item must be inserted in the Custom JSON format. Specify the partition key, if the table was configured with a simple primary key. Specify both the partition key and sort key, if the table was configured with a composite primary key.  

 The existing data of the table is retrieved and evaluated against this condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted. There are three ways to initialize a condition:


 The two built-in functions are: attribute_exist, which can be used to check for the presence of an attribute, and attribute_type, which can be used to check if the given attribute name belongs to the given type. 

 To perform direct comparison operations. Supported operators: contains, not_contains, begins_with, ends_with, in, not_in, between, not_between, equals, not_equals, greater_than, less_than, greater_equal, less_equal.  

To combine two or more conditions. Supported group operators: and, or.   

To negate the result of the conditions.    

### Response Details

The response will return the status of the insert operation, as well as the details of the item inserted such as the table_name, partition_key and sort_key, if configured.







curl -X DELETE \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/item \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d ‘{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	},
 	"Location": {
  	"M": {
   	"Country": {
    	"S": "USA"
   	},
   	"City": {
    	"S": "New York"
    	}
   	}
  	}
}
    }’




    {
    "status": "success",
    "data": {
        "table_name": "employeeDetails",
        "project_details": {
            "id": 4000000006007,
            "project_name": "EmpDatabase",
            "project_type": "Live"
        }
    }
    }
    

   

Insert Items- Java SDK</br></br>
Insert Items- Node.js SDK</br></br>
Insert Items- Python SDK
</br></br>






--------------------------------------------------------------------------------
title: "Query Table"
description: "This API enables you to query a NoSQL table and fetch data."
last_updated: "2026-06-10T06:04:37.385Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# Query Table

### Description

This API enables you to query a NoSQL table in your project and fetch data. The table is referred to by its unique ID. 

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}/item/query</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.POST



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

Contains the condition in the format similar to the CRUD operations of items. Only the partition key and sort key conditions can be given. Partition key can only have the "equals" operator. The condition can be partition key = value, or a group with partition key equals condition and the sort key condition. Refer to the full list of supported operators. 

List of attributes to be returned.  

Declares if the read has to be done from master or slave. If set to false, it is queried from the slave. Accepted values: true, false.  

These are conditions that are applied over the retrieved data. The response is sent after these conditions are applied.   

This is used to indicate if the query has to be done in ascending or descending order. 

This is used for pagination purposes to fetch the next set of data items.  

This is used to indicate if the query is made against the table with additional sort keya. This contains the additional sort key attribute names.  

This indicates the maximum count of items that should be returned.   


### Response Details

The response will return the status of the query operation, as well as the items that are fetched according to the conditions set in the query.







curl -X POST \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/item/query \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d -d ‘{
	key_condition:{
		partition_key:{
			"S":"Country"
		},
		sort_key:{
			"N":"EmpID"
		},
	}
	required_attributes: {
		"EmpID",
 	"FirstName",
	"LastName",
	"PriorExperience"
  	},
	consistent_read: "true"
	}’




   {
    "status": "success",
    "data": {
        fetched_data:{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	}
  	}
    }
	}
	}
    

   

Query Table- Java SDK</br></br>
Query Table- Node.js SDK</br></br>
Query Table- Python SDK
</br></br>






--------------------------------------------------------------------------------
title: "Query Index"
description: "This API enables you to query a NoSQL index and fetch data."
last_updated: "2026-06-10T06:04:37.389Z"
source: "https://docs.catalyst.zoho.com/en/api/code-reference/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# Query Index

### Description

This API enables you to query a NoSQL index in your project and fetch data. The index is referred to by its unique ID. 

### Request Details

#### Request URL

<p>{api-domain}/baas/v1/project/{{project_id}}/nosqltable/{{table_identifier}}//index/{{index_identifier/}}/item/query</p>

The DC-specific domain to access Catalyst API

The unique ID of the project

The unique ID of the table or table name

The unique ID of the index


#### Request Headers
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**Optional Headers** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### Scope

ZohoCatalyst.nosql.POST



 Note: This operation can also be executed with Catalyst user authentication permissions using Catalyst SDKs. Refer to the [Catalyst API Prerequisites section](/en/api/introduction/overview-and-prerequisites/#prerequisites) for details.

### Request JSON Properties

Contains the condition in the format similar to the CRUD operations of items. Only the partition key and sort key conditions can be given. Partition key can only have the "equals" operator. The condition can be partition key = value, or a group with partition key equals condition and the sort key condition. Refer to the full list of supported operators. 

List of attributes to be returned.  

Declares if the read has to be done from master or slave. If set to false, it is queried from the slave. Accepted values: true, false.  

These are conditions that are applied over the retrieved data. The response is sent after these conditions are applied.   

This is used to indicate if the query has to be done in ascending or descending order. 

This is used for pagination purposes to fetch the next set of data items.  

This is used to indicate if the query is made against the table with additional sort keya. This contains the additional sort key attribute names.  

This indicates the maximum count of items that should be returned.   


### Response Details

The response will return the status of the query operation, as well as the items that are fetched according to the conditions set in the query.







curl -X POST \
https://api.catalyst.zoho.com/baas/v1/project/4000000006007/nosqltable/3376000003171728/index/786387162881/item/query \
-H "Authorization: Zoho-oauthtoken 1000.910*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*16.2f*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*57" \
-H "Content-Type:application/json" \
-d -d ‘{
	key_condition:{
		partition_key:{
			"S":"Country"
		},
		sort_key:{
			"N":"EmpID"
		},
	}
	required_attributes: {
		"EmpID",
 	"FirstName",
	"LastName",
	"PriorExperience"
  	},
	consistent_read: "true"
	}’




   {
    "status": "success",
    "data": {
        fetched_data:{
	"item": {
 	"EmpID": {
  	"N": "10999"
  	},
 	"FirstName":{
  	"S": "Paul"
  	},
 	"LastName":{
  	"S": "Smith"
  	},
 	"PriorExperience":{
  	"BOOL": false
  	}
  	}
    }
	}
	}
    

   

Query Index- Java SDK</br></br>
Query Index- Node.js SDK</br></br>
Query Index- Python SDK
</br></br>






---

## SDK — Java — NoSQL

--------------------------------------------------------------------------------
title: "Get Table Metadata"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch the metadata of a NoSQL table."
last_updated: "2026-06-10T06:04:37.461Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Node.js SDK (/en/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/)
- NoSQL Python SDK (/en/sdk/python/v1/cloud-scale/nosql/get-component-instance/)

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


# NoSQL

Catalyst NoSQL is a fully managed non-relational, NoSQL data storage feature that enables you to store the semi-structured, unstructured, and disparate data of your applications. Catalyst supports document-type data storage in the key-value pair based JSON format. 

The Catalyst NoSQL Java SDK package enables you to perform CRUD data operations on your NoSQL tables in your project. You can fetch the metadata of your NoSQL tables, create NoSQL items of various supported data types, and insert, update, fetch, or delete items in a specific table. You can also query tables or indexes of tables by specifying query conditions.

## Get Table Metadata

Catalyst enables you to fetch the metadata of a NoSQL table by obtaining an instance of the Java SDK using the getInstance() method. You can get the metadata of a single table or of all tables in your project.

### Get Metadata of Single Table

The metadata of a single table in Catalyst NoSQL can be obtained in two ways as mentioned in this page. The response will contain details of the table configuration, such as the partition key and sort key, TTL attribute, and more.

#### Get Table Metadata with Table ID 

You can fetch the metadata of a NoSQL table in your project by referring to its unique Table ID using the method getTable() as given below.

//public ZCNoSQLTable getTable(String tableName) throws Exception;
//public ZCNoSQLTable getTable(Long tableId) throws Exception;
// Get table metadata using the Table ID
ZCNoSQL.getInstance().getTable(2144568989001);

<br>

#### Get Table Metadata with Table Name

You can fetch the metadata of a NoSQL table in your project by referring the table name using the method getTable() as given below.

//public ZCNoSQLTable getTable(String tableName) throws Exception;
//public ZCNoSQLTable getTable(Long tableId) throws Exception;
// Get table metadata using the Table name
ZCNoSQL.getInstance().getTable('Employees');

Note: If you rename the table, you will need to update the changes in your code.

<br>

### Get Metadata of All Tables

Catalyst enables you to fetch the metadata of all the tables in your project using the getAllTables() method as shown below.

//public List<ZCNoSQLTable> getAllTables() throws Exception;
ZCNoSQL.getInstance().getAllTables();

--------------------------------------------------------------------------------
title: "Create Table Instance"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to create an instance for a NoSQL table."
last_updated: "2026-06-10T06:04:37.462Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/create-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/en/cloud-scale/help/nosql/create-manage-tables/)

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


# Create Table Instance

Catalyst NoSQL enables you to fetch an empty table instance of a NoSQL table. You can then use this instance to refer to that table and perform all supported table operations. This process will not fire a server-side call. 

You can get an instance of your NoSQL table in two ways as described in this section. 


### Get Instance with Table ID

Get a table instance by passing the unique ID of the table to getTableInstance() as shown below.

//public ZCNoSQLTable getTableInstance(Long tableId);
//public ZCNoSQLTable getTableInstance(String tableName);
// Create a table instance with Table ID
ZCNoSQL.getInstance().getTableInstance(37898901211);

<br>

### Get Instance with Table Name

Get a table instance by passing the table name to getTableInstance() as shown below.

//public ZCNoSQLTable getTableInstance(Long tableId);
//public ZCNoSQLTable getTableInstance(String tableName);
// Create a table instance with Table ID
ZCNoSQL.getInstance().getTableInstance('Employees');




--------------------------------------------------------------------------------
title: "Construct NoSQL Item"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to construct a NoSQL item."
last_updated: "2026-06-10T06:04:37.462Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Construct NoSQL Item

Catalyst NoSQL items represent a collection of attributes that hold the data of a single data point, like records. You can insert or update items into an existing NoSQL table in your project in a Custom JSON format. However, before you insert or update an item in Catalyst, you will need to construct the item. 

You can construct a NoSQL item of attributes containing different data types supported by Catalyst as described in the section below. Catalyst supports several data types such as String, Number, Set of Strings, Set of Numbers, List, and Map. Refer to the full list of supported data types in the shared resource to learn more. 

You must mandatorily provide the values for the partition key attribute that you configured for a table in every data item. Refer to Table Keys help section to learn about the table keys, TTL attribute, and other details.

<br>

### Create a New NoSQL Item

You can create a new NoSQL item using the ZCNoSQLItem() method, as shown below.

ZCNoSQLItem item = new ZCNoSQLItem();

#### Create a New NoSQL Item with JSON / Map

You can create a new NoSQL item from a plain JSON data or from a Map after you define them as shown below.

//public static ZCNoSQLItem fromJSON(String json) throws Exception;
ZCNoSQLItem.fromJSON(<json string>);

<br>


### Construct NoSQL Items of Different Data Types

The code snippet below shows the formats for constructing an item with attributes of different data types:

//public ZCNoSQLItem withString(String attrName, String val) throws Exception;
item.withString("attribute name", "<string value>");
//public ZCNoSQLItem withNumber(String attrName, BigDecimal val) throws Exception;
//public ZCNoSQLItem withNumber(String attrName, Number val) throws Exception;
item.withNumber("attribute name", "<numeric value>");
//public ZCNoSQLItem withInt(String attrName, int val) throws Exception;
item.withInt("attribute name", "<integer value>");
//public ZCNoSQLItem withBigInteger(String attrName, BigInteger val) throws Exception;
item.withBigInteger("attribute name", "<BigInt value>");
//public ZCNoSQLItem withShort(String attrName, short val) throws Exception;
item.withShort("attribute name", "<Short value>");
//public ZCNoSQLItem withFloat(String attrName, float val) throws Exception;
item.withFloat("attribute name", "<Float value>");
//public ZCNoSQLItem withDouble(String attrName, double val) throws Exception;
item.withDouble("attribute name", "<Double value>");
//public ZCNoSQLItem withLong(String attrName, long val) throws Exception;
item.withLong("attribute name", "<Long value>");
//public ZCNoSQLItem withBinary(String attrName, byte[] val) throws Exception;
//public ZCNoSQLItem withBinary(String attrName, ByteBuffer val) throws Exception;
item.withBinary("attribute name", "<Byte value>");
//public ZCNoSQLItem withStringSet(String attrName, Set<String> val) throws Exception;
//public ZCNoSQLItem withStringSet(String attrName, String... val) throws Exception;
item.withStringSet("attribute name", "<StringSet/String variadic param value>");
//public ZCNoSQLItem withBigDecimalSet(String attrName, Set<BigDecimal> val) throws Exception;
//public ZCNoSQLItem withBigDecimalSet(String attrName, BigDecimal... vals) throws Exception;
item.withBigDecimalSet("attribute name", "<DecimalSet/Decimal Variadic param value>");
//public <T extends Number> ZCNoSQLItem withNumberSet(String attrName, T... vals) throws Exception;
//public <T extends Number> ZCNoSQLItem withNumberSet(String attrName, Set<T> vals) throws Exception;
item.withNumberSet("attribute name", "<Numeric/Numeric Variadic param value>");
//public ZCNoSQLItem withBinarySet(String attrName, Set<byte[]> val) throws Exception;
//public ZCNoSQLItem withBinarySet(String attrName, byte[]... vals) throws Exception;
//public ZCNoSQLItem withBinarySet(String attrName, ByteBuffer... vals) throws Exception;
item.withBinarySet("attribute name", "<Byte Set value>");
//public ZCNoSQLItem withByteBufferSet(String attrName, Set<ByteBuffer> val) throws Exception;
item.withByteBufferSet("attribute name", "<Byte Set value>");
//public ZCNoSQLItem withList(String attrName, List<?> val) throws Exception;
//public ZCNoSQLItem withList(String attrName, Object... vals) throws Exception;
item.withList("attribute name", "<List/Variadic Param value>");
//public ZCNoSQLItem withMap(String attrName, Map<String, ?> val) throws Exception;
item.withMap("attribute name", "<Map value>");
//public ZCNoSQLItem withJSON(String attrName, String json) throws Exception;
item.withJSON("attribute name", "<JSON String value>");
//public ZCNoSQLItem withBoolean(String attrName, boolean val) throws Exception;
item.withBoolean("attribute name", "<Boolean value>");
//public ZCNoSQLItem withNull(String attrName) throws Exception;
item.withNull("attribute name");
//public ZCNoSQLItem with(String attrName, Object val) throws Exception;
item.with("attribute name", "<Value>");

--------------------------------------------------------------------------------
title: "NoSQL Item Operations"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK methods to perform various NoSQL item operations."
last_updated: "2026-06-10T06:04:37.463Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/item-operations/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQL Item Operations


Catalyst NoSQL items represent a collection of attributes that hold the data of a single data point, like records. Given below are the methods that you can use with an item and perform various operations on it.

#### Remove attributes from a constructed item


//public ZCNoSQLItem removeAttribute(String attrName) throws Exception;
item.removeAttribute("attribute name");

#### Get all the keys from the item being constructed

//public Iterable<Map.Entry>String, Object>> attributes();
item.attributes();

#### Check if the constructed item contains a specific attribute

//public boolean hasAttribute(String attrName);
item.hasAttribute("attribute name");

#### Getting the item as a map

//public Map<String, Object> asMap();
item.asMap();
//public Map<String, Object> getAllAttributesAsMap();
item.getAllAttributesAsMap();

#### Get the item as a JSON

//public String toJSON() throws Exception;
item.toJSON();

#### Get the count of the attributes in the constructed item

//public int numberOfAttributes();
item.numberOfAttributes();

<br>

### ZCNoSQLAttribute

You can use the ZCNoSQLAttribute class to indicate the attributes upon which you perform the operations. To access the nested elements of a Map, you can separate the attributes using ',' while using ZCNoSQLAttribute. To access a specific index of a list, you can denote it as "[<index>]". This is demonstrated in the example below.

//public static ZCNoSQLAttribute getInstance(String ...pathElements) throws Exception;
//public ZCNoSQLAttribute(List<String> pathElements) throws Exception;
ZCNoSQLAttribute.getInstance("", ...);
new ZCNoSQLAttribute("", ...)

The datatypes supported by NoSQL can be denoted with the ZCNoSQLAttribute as follows:

<table class="content-table nosql-components-table">

<thead>
        <tr>
            <th class="w10p">Supported Data Type</th>
            <th class="w10p">Notation with ZCNoSQLAttribute</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>String</td>
        <td>ZCNoSQLValue.DataType.S </td>
    </tr>
    <tr>
        <td>Numeric</td>
        <td>ZCNoSQLValue.DataType.N</td>
    </tr>
    <tr>
        <td>Binary</td>
        <td>ZCNoSQLValue.DataType.B </td>
    </tr>
    <tr>
       <td>Boolean</td>
        <td>ZCNoSQLValue.DataType.BOOL</td>
    </tr>
    <tr>
        <td>Set of String</td>
        <td>ZCNoSQLValue.DataType.SS</td>
    </tr>
    <tr>
        <td>Set of Numbers</td>
        <td>ZCNoSQLValue.DataType.SN</td>
    </tr>
    <tr>
        <td>Set of Binary</td>
        <td>ZCNoSQLValue.DataType.SB</td>
    </tr>
    <tr>
        <td>List</td>
        <td>ZCNoSQLValue.DataType.L</td>
    </tr>
    <tr>
        <td>Map</td>
        <td>ZCNoSQLValue.DataType.M</td>
    </tr>
    <tr>
        <td>Null</td>
        <td>ZCNoSQLValue.DataType.NuLL</td>
    </tr>
</tbody>
</table>

<br>

### ZCNoSQLValue

Objects of this class are used to indicate the value of attributes along with their data type, as shown below.

// public ZCNoSQLValue(DataType dataType, Object value) throws Exception;
//public static ZCNoSQLValue getInstance(DataType dataType, Object value) throws Exception;
new ZCNoSQLValue(<ZCNoSQLValue.DataType>, <Value>)
ZCNoSQLValue.getInstance(<ZCNoSQLValue.DataType>, <Value>)

<br>

### ZCNoSQLResponseBean

This class contains the response of the SDK calls made to the server. This includes the following methods. 

* getSize - Used to return the size of data read/write from or to the server.


//public int getSize();
responseBean.getSize();

* getStartKey - Used to return the start key for next set of data for pagination, if more data exists.

//public ZCNoSQLItem getStartKey();
responseBean.getStartKey();

* getResponseDataList - Returns the actual data. Based on the NOSQL_RETURN_VALUE, either the old or new data is returned in getNew_item() or getOld_Item() method.

//public List<Data> getResponseDataList();
responseBean.getResponseDataList().get(<index>).getNew_item();
responseBean.getResponseDataList().get(<index>).getOld_item();
responseBean.getResponseDataList().get(<index>).setStatus();

--------------------------------------------------------------------------------
title: "Insert Items in Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to insert items in a NoSQL table."
last_updated: "2026-06-10T06:04:37.463Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Insert NoSQL Items in Table

Catalyst enables you to insert items in a specific NoSQL table after you construct them. The items can be inserted in different ways as described in this section.

You can refer to the help sections on adding and working with data, the Catalyst custom JSON format, and the supported data types to learn these topics in detail.

Note: Catalyst enables you to insert a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.

### Insert Items without Conditions

You can insert new items into a NoSQL table without any conditions either by using the ZCNoSQLTable instance, or the ZCNoSQLInsertHelper instance which can be used to construct the various parts of the request. 

You can insert data with the ZCNoSQLTable instance as shown below.

//public ZCNoSQLResponseBean insert(ZCNoSQLItem item) throws Exception;
table.insert(<ZCNoSQLItem>);

You can insert data with the ZCNoSQLInsertHelper instance as shown below.

//public ZCNoSQLInsertHelper getInsertHelper(ZCNoSQLItem item) throws Exception;
//public ZCNoSQLResponseBean insert() throws Exception;
table.getInsertHelper(<ZCNoSQLItem>).insert();

This class can be used to insert data into a table with conditions. This can be obtained from ZCNoSQLTable instance.

<br>

### Insert Items with Conditions

You can insert attributes in existing items in a NoSQL table using specific conditions that you define. In this type, the existing data of the table is retrieved and evaluated against the specified condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted.

The snippet below shows inserting items with conditions using ZCNoSQLCondition.

//public ZCNoSQLInsertHelper withCondition(ZCNoSQLCondition condition) throws Exception;
table.getInsertHelper(<ZCNoSQLItem>).withCondition(<ZCNoSQLCondition>).insert();

Condition can be passed with the help of ZCNoSQLCondition instance which can be obtained by using a constructor or calling the getInstance() method. Conditions can be initialized in 3 methods

#### 1. Using functions

//public static ZCNoSQLCondition getInstance(NoSQLConditionFunction function) throws Exception;
//public ZCNoSQLCondition(NoSQLConditionFunction function) throws Exception;
ZCNoSQLCondition.getInstance(<NoSQLCondtitionFunction>);
new ZCNoSQLCondition(<NoSQLCondtitionFunction>)

There are two built in-functions available.

i. ZCNoSQLAttributeTypeFunction

Check if the data type of the given attribute matched the given datatype.

//public ZCNoSQLAttributeTypeFunction(ZCNoSQLAttribute attribute, ZCNoSQLValue.DataType dataType) throws Exception;
//public static ZCNoSQLAttributeTypeFunction getInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue.DataType dataType) throws Exception;
ZCNoSQLAttributeTypeFunction.getInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue.DataType>);
new ZCNoSQLAttributeTypeFunction(<ZCNoSQLAttribute>, <ZCNoSQLValue.DataType>);

ii. ZCNoSQLAttributeExistFunction 

This is used to evaluate if an attribute already exists in the retrieved item.

//public ZCNoSQLAttributeExistFunction(ZCNoSQLAttribute attribute);
//public static ZCNoSQLAttributeExistFunction getInstance(ZCNoSQLAttribute attribute);
ZCNoSQLAttributeExistFunction.getInstance(<ZCNoSQLAttribute>);
new ZCNoSQLAttributeExistFunction(<ZCNoSQLAttribute>)

<br>
            
#### 2. Using operator, operand and value

//public static ZCNoSQLCondition getInstance(ZCNoSQLAttribute attribute, NOSQL_OPERATOR operator, ZCNoSQLValue value) throws Exception;
//public ZCNoSQLCondition(ZCNoSQLAttribute attribute, NOSQL_OPERATOR operator, ZCNoSQLValue value) throws Exception;
ZCNoSQLCondition.getInstance(<ZCNoSQLAttribute>, <NOSQL_OPERATOR>, <ZCNoSQLValue>);
new ZCNoSQLCondition(<ZCNoSQLAttribute>, <NOSQL_OPERATOR>, <ZCNoSQLValue>);
  
#### NOSQL_OPERATOR

The allowed NOSQL_OPERATOR values are contains, not_contains, begins_with, ends_with, in, not_in, between, not_between, equals, not_equals, greater_than, less_than, greater_equal, less_equal

#### Using group of conditions

//public static ZCNoSQLCondition getInstance(List<ZCNoSQLCondition> groups, NOSQL_CONDITION_GROUP_OPERATOR groupOperator) throws Exception;
//public ZCNoSQLCondition(List<ZCNoSQLCondition> groups, NOSQL_CONDITION_GROUP_OPERATOR groupOperator) throws Exception;
ZCNoSQLCondition.getInstance(List<ZCNoSQLCondition>,<NOSQL_CONDITION_GROUP_OPERATOR>)
new ZCNoSQLCondition(List<ZCNoSQLCondition>,<NOSQL_CONDITION_GROUP_OPERATOR>)
 
#### NOSQL_CONDITION_GROUP_OPERATOR

The allowed NOSQL_CONDITION_GROUP_OPERATOR values are AND, OR

#### NOSQL_RETURN_VALUE 

Indicates the return value after evaluating condition.

//public ZCNoSQLInsertHelper withReturnValue(NOSQL_RETURN_VALUE returnValue) throws Exception
table.getInsertHelper(<ZCNoSQLItem>).withReturnValue(<NOSQL_RETURN_VALUE>).insert();
       
The allowed NOSQL_RETURN_VALUE values are NEW, OLD, NULL

#### Insert with Condition and Return Value

table.getInsertHelper(<ZCNoSQLItem>).withCondition(<ZCNoSQLCondition>).withReturnValue(<NOSQL_RETURN_VALUE>).insert();




--------------------------------------------------------------------------------
title: "Update Items"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to update items in a NoSQL table."
last_updated: "2026-06-10T06:04:37.463Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Update Items in a NoSQL Table

Catalyst enables you to update items in a specific NoSQL table after you construct them. An item can be updated by identifying it using its primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to identify the item. You can then define the update operation type with the appropriate HTTP request method and provide the attributes and values to be updated in the item. 

Note: Catalyst enables you to update a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.


There are two ways to update the data. Data can be updated without any conditions by using the ZCNoSQLTable instance or it can be updated with the help of ZCNoSQLUpdateHelper instance which can be used to construct the various parts of the request.

You can update the data with the ZCNoSQLTable instance as shown below.


//public ZCNoSQLResponseBean update(ZCNoSQLItem item, ZCNoSQLUpdateAttributeOperation updateAttributeOperation) throws Exception;
table.update(<ZCNoSQLItem>, <ZCNoSQLUpdateAttributeOperation>);


To update with ZCNoSQLUpdateHelper

#### ZCNoSQLUpdateHelper


//public ZCNoSQLInsertHelper getInsertHelper(ZCNoSQLItem item) throws Exception;
//public ZCNoSQLResponseBean insert() throws Exception;
table.getUpdateHelper(<ZCNoSQLItem>, <ZCNoSQLUpdateAttributeOperation>).update();



#### ZCNoSQLUpdateAttributeOperation

This class is used update the item by either adding/updating existing attribute or deleting existing attribute. An instance of the above can be obtained using the below methods.

For inserting or updating attributes


//ZCNoSQLUpdateAttributeOperation(ZCNoSQLAttribute attribute, ZCNoSQLValue updateValue);
//ZCNoSQLUpdateAttributeOperation(ZCNoSQLAttribute attribute, NoSQLUpdateAttributeFunction updateFunction);
//public static ZCNoSQLUpdateAttributeOperation getPutAttributeInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue updateValue);
// public static ZCNoSQLUpdateAttributeOperation getPutAttributeInstance(ZCNoSQLAttribute attribute, NoSQLUpdateAttributeFunction updateFunction);
new ZCNoSQLUpdateAttributeOperation(<ZCNoSQLAttribute>, <ZCNoSQLValue>);
new ZCNoSQLUpdateAttributeOperation(<ZCNoSQLAttribute>, <NoSQLUpdateAttributeFunction>);
ZCNoSQLUpdateAttributeOperation.getPutAttributeInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue>);
ZCNoSQLUpdateAttributeOperation.getPutAttributeInstance(<ZCNoSQLAttribute>, <NoSQLUpdateAttributeFunction>)



For Deleting attributes

//ZCNoSQLUpdateAttributeOperation(ZCNoSQLAttribute attribute);
//public static ZCNoSQLUpdateAttributeOperation getDeleteAttributeInstance(ZCNoSQLAttribute attribute);
new ZCNoSQLUpdateAttributeOperation(<ZCNoSQLAttribute>);
ZCNoSQLUpdateAttributeOperation.getDeleteAttributeInstance(<ZCNoSQLAttribute>);


Update also have certain prebuilt functions that can be used to update the values. These functions can be grouped under the type NoSQLUpdateAttributeFunction and can be used while obtaining the ZCNoSQLUpdateAttributeOperation instance.

### NoSQLUpdateAttributeFunction

There are 4 prebuild functions.

#### ZCNoSQLIfNotExistFunction

This function is used update the attribute with the value of another existing attribute. If the attribute does not exist, then the given value is updated.


//public ZCNoSQLIfNotExistFunction(ZCNoSQLAttribute attribute, ZCNoSQLValue value)
//public static ZCNoSQLIfNotExistFunction getInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue value);
new ZCNoSQLIfNotExistFunction(<ZCNoSQLAttribute>, <ZCNoSQLValue>)
ZCNoSQLIfNotExistFunction.getInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue>)


#### ZCNoSQLAppendListFunction
  
This function is append elements to existing or new list attribute.


//public ZCNoSQLAppendListFunction(ZCNoSQLValue...values);
//public static ZCNoSQLAppendListFunction getInstance(ZCNoSQLValue...values);
new ZCNoSQLAppendListFunction(<List of ZCNoSQLValue>)
ZCNoSQLAppendListFunction.getInstance(<List of ZCNoSQLValue>)



#### ZCNoSQLAdditionFunction
 
This function is used to add elements to a set or add numeric value to existing attribute. The type of operation depends on the targetted attribute type.

//public ZCNoSQLAdditionFunction(ZCNoSQLAttribute attribute, ZCNoSQLValue value);
//public static ZCNoSQLAdditionFunction getInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue value);
new ZCNoSQLAdditionFunction(<ZCNoSQLAttribute>, <ZCNoSQLValue>)
ZCNoSQLAdditionFunction.getInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue>)


#### ZCNoSQLReductionFunction

This function is used to remove elements from a set or subtract numeric value to existing attribute. The type of operation depends on the targetted attribute type.


//public ZCNoSQLReductionFunction(ZCNoSQLAttribute attribute, ZCNoSQLValue value) throws Exception;
//public static ZCNoSQLReductionFunction getInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue value) throws Exception;
new ZCNoSQLReductionFunction(<ZCNoSQLAttribute>, <ZCNoSQLValue>)
ZCNoSQLReductionFunction.getInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue>)


Other methods available in ZCNoSQLUpdateHelper

#### ZCNoSQLCondition

The Same conditions described above can be reused for update too.

NOSQL_RETURN_VALUE 

The Same return value described above can be reused for update too.

Update with Condition and Return Value


table.getUpdateHelper(<ZCNoSQLItem>,<ZCNoSQLUpdateAttributeOperation>).withCondition(<ZCNoSQLCondition>).withReturnValue(<NOSQL_RETURN_VALUE>).update();


--------------------------------------------------------------------------------
title: "Fetch Items from NoSQL Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch items from a NoSQL table."
last_updated: "2026-06-10T06:04:37.464Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Fetch Items from NoSQL Table

Catalyst enables you to fetch items from a NoSQL table by identifying them with their primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to fetch the item. You can also optionally filter the attributes to be fetched by specifying the required attributes. 

Note: Catalyst enables you to fetch a maximum of 100 items from a NoSQL table in a single SDK read operation.

Data can be fetched without filtering specific attributes by using the ZCNoSQLTable instance or it can be fetched with the help of ZCNoSQLFetchHelper instance which can be used to construct the various parts of the request.

To fetch data with ZCNoSQLTable Instance, the below can be used.

//public ZCNoSQLResponseBean fetch(ZCNoSQLItem key) throws Exception;
table.fetch(<ZCNoSQLItem>);

To fetch with ZCNoSQLFetchHelper

#### ZCNoSQLFetchHelper

This class can be used to fetch data from the table and filter our specific attributes. This can be obtained from ZCNoSQLTable instance.

//public ZCNoSQLFetchHelper getFetchHelper(ZCNoSQLItem key) throws Exception;
//public ZCNoSQLResponseBean fetch() throws Exception;
table.getFetchHelper(<ZCNoSQLItem>).fetch();

Other methods available in ZCNoSQLFetchHelper

#### Required Attributes

This method can be used to filter and retrieve only the specific required attributes


/public ZCNoSQLFetchHelper withRequiredAttributes(List<ZCNoSQLAttribute> requiredAttributesList) throws Exception;
table.getFetchHelper(<ZCNoSQLItem>).withRequiredAttributes(<List of ZCNoSQLAttributes>).fetch();


You can also use consistency to indicate if the read operation must be done using the master or a slave cluster. When set to true, it is queried from the master. If 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.


//public ZCNoSQLFetchHelper withConsistency(boolean consistency) throws Exception;
table.getFetchHelper(<ZCNoSQLItem>).withConsistency(true/false).fetch();

Fetch with Required Attributes and Consistency

table.getFetchHelper(<ZCNoSQLItem>).withRequiredAttributes(<List of ZCNoSQLAttributes>).withConsistency(true/false).fetch();

--------------------------------------------------------------------------------
title: "Query NoSQL Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch the metadata of a NoSQL table."
last_updated: "2026-06-10T06:04:37.464Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Query NoSQL Table

Catalyst enables you to query a NoSQL table and retrieve data by identifying the items using the primary 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 can define the key condition that identifies the item by specifying the attributes, their required values, and the supported operator to be used. Refer to the help section for a list of supported operators and help on querying from the Catalyst console. 

To query the data with ZCNoSQLTable Instance, the snippet below can be used.

//public ZCNoSQLResponseBean queryTable(ZCNoSQLPartitionKeyCondition partitionKeyCondition, boolean forwardScan, int limit) throws Exception;
table.query(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>);


To query with ZCNoSQLQueryHelper
ZCNoSQLQueryHelper
This class can be used to query data from the table and also specifiy other conditions, sorting order, limit etc. This can be obtained from ZCNoSQLTable instance.

//public ZCNoSQLQueryHelper getQueryHelper(ZCNoSQLPartitionKeyCondition partitionKeyCondition, boolean forwardScan, int limit) throws Exception;
//public ZCNoSQLResponseBean queryTable() throws Exception;
table.getQueryHelper(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>).queryTable();


ZCNoSQLPartitionKeyCondition

This is used to construct partition key criteria. This is necessary to query data from the table or index.

//public ZCNoSQLPartitionKeyCondition(ZCNoSQLAttribute attribute, ZCNoSQLValue value) throws Exception;
//public static ZCNoSQLPartitionKeyCondition getInstance(ZCNoSQLAttribute attribute, ZCNoSQLValue value) throws Exception;
new ZCNoSQLPartitionKeyCondition(<ZCNoSQLAttribute>, <ZCNoSQLValue>)
ZCNoSQLPartitionKeyCondition.getInstance(<ZCNoSQLAttribute>, <ZCNoSQLValue>)


Secondary Key Condition
This is used to construct sort key criteria. This will be used to indicate if sort key should be used or additional sort key should be used while querying the table.

//public static ZCNoSQLSecondaryKeyCondition getInstance(ZCNoSQLAttribute attribute, SECONDARY_KEY_CONDITION_OPERATOR operator, ZCNoSQLValue value) throws Exception
new ZCNoSQLSecondaryKeyCondition(<ZCNoSQLAttribute>, <SECONDARY_KEY_CONDITION_OPERATOR>, <ZCNoSQLValue>)
ZCNoSQLSecondaryKeyCondition.getInstance(<ZCNoSQLAttribute>, <SECONDARY_KEY_CONDITION_OPERATOR>, <ZCNoSQLValue>)
//public ZCNoSQLQueryHelper withSecondaryKeyCondition(ZCNoSQLSecondaryKeyCondition secondaryKeyCondition, Boolean isAdditionalSortKey) throws Exception;
table.getQueryHelper(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>).withSecondaryKeyCondition(<ZCNoSQLSecondaryKeyCondition>, <true/false>).queryTable();


Other methods available in ZCNoSQLQueryHelper

SECONDARY_KEY_CONDITION_OPERATOR
This can have the values begins_with, between, equals, greater_than, less_than, greater_equal, less_equal;
    
Other Conditions
This can be used to filter the data retrieved using partition key and sort key if specified. This will apply only on top on the data retrieved using the keys. So there can be scenarios where data maybe present for the given partition key, sort key and other conditions but to the maximum limit of 100 items, 0 items may be returned after applying the other condition along with the start key.

//public ZCNoSQLQueryHelper withOtherCondition(ZCNoSQLCondition otherCondition) throws Exception;
table.getQueryHelper(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>).withOtherCondition(<ZCNoSQLCondition>).queryTable();


Start Key
This is used for pagination. Upon querying data from the table/index, if more record exists, the start key will be returned. To fetch the next set of data, this value has to be set from the previous request's response.

//public ZCNoSQLQueryHelper withStartKey(ZCNoSQLItem startKey);
table.getQueryHelper(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>).withStartKey(<ZCNoSQLItem>).queryTable();



--------------------------------------------------------------------------------
title: "Query NoSQL Index"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch the metadata of a NoSQL table."
last_updated: "2026-06-10T06:04:37.464Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Query NoSQL Index

Catalyst enables you to query a NoSQL index and retrieve data by identifying the items using the primary keys of the index. Indexing allows you to execute alternate queries on the table data without making use of the primary keys of the main table. You can configure indexes from the Catalyst console. You can therefore use just the partition key or a combination of the partition key and sort key of the index to retrieve an 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 can define the key condition that identifies the item by specifying the attributes, their required values, and the supported operator to be used. Refer to the help section on a list of supported operators and help on querying from the Catalyst console. 

To query the data with ZCNoSQLTable Instance, the below can be used.

//public ZCNoSQLResponseBean queryIndex(Long indexID, ZCNoSQLPartitionKeyCondition partitionKeyCondition, boolean forwardScan, int limit) throws Exception;
table.queryIndex(<indexID>, <ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>);

To query with ZCNoSQLQueryHelper

ZCNoSQLQueryHelper

This class can be used to query data from the index and also specifiy other conditions, sorting order, limit etc. This can be obtained from ZCNoSQLTable instance.

//public ZCNoSQLQueryHelper getQueryHelper(ZCNoSQLPartitionKeyCondition partitionKeyCondition, boolean forwardScan, int limit) throws Exception;
//public ZCNoSQLResponseBean queryTable() throws Exception;
table.getQueryHelper(<ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>).queryIndex(<indexID>);

ZCNoSQLPartitionKeyCondition

The same Partition Key Condition described above can be reused here too.
Other methods available in ZCNoSQLQueryHelper

Required Attributes

The same Required Attributes described above can be reused here too.

Consistence 

Catalyst NoSQL also lets you define other elements of the query, such as using consistent_read to indicate if the read operation must be done using the master or a slave cluster, limiting the number of rows to be returned, and specifying the sorting order as ascending. 

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.

Secondary Key Condition

The same Secondary Key Condition described above can be reused here too with the exception that additionalSort key cannot be used for index
    
Other Conditions

The other conditions mentioned for querying tables can be reused here too.
 
Start Key

The same Start Key described above can be used here too.

Index Query with all combinations

table.getQueryHelper(ZCNoSQLPartitionKeyCondition>, <true/false>, <limit>)
    .withSecondaryKSeyCondition(<ZCNoSQLSecondaryKeyCondition>, false)
    .withOtherCondition(<ZCNoSQLCondition>)
    .withRequiredAttributes(<List of ZCNoSQLAttributes>)
    .withConsistency(true/false)
    .withStartKey(<ZCNoSQLItem>)
    .queryIndex(<indexID>);




--------------------------------------------------------------------------------
title: "Delete Items from Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch the metadata of a NoSQL table."
last_updated: "2026-06-10T06:04:37.464Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Delete Items from NoSQL Table

You can delete items from a NoSQL table in Catalyst by identifying them using the primary keys of the table. For instance, you use just the partition key, or a combination of the partition key and sort key of the table, to identify an item.

Note: Catalyst enables you to delete a maximum of 25 items in bulk from a NoSQL table with a single SDK operation.
Data can be deleted without any conditions by using the ZCNoSQLTable instance or it can be deleted with the help of ZCNoSQLDeleteHelper instance which can be used to construct the various parts of the request.

To delete data with ZCNoSQLTable Instance, the below can be used.

//public ZCNoSQLResponseBean delete(ZCNoSQLItem key) throws Exception;
table.delete(<ZCNoSQLItem>);

To delete with ZCNoSQLDeleteHelper

ZCNoSQLDeleteHelper

This class can be used to delete data from the table with conditions. This can be obtained from ZCNoSQLTable instance.

//public ZCNoSQLDeleteHelper getDeleteHelper(ZCNoSQLItem keys) throws Exception;
//public ZCNoSQLResponseBean delete() throws Exception;
table.getDeleteHelper(<ZCNoSQLItem>).delete();

Other methods available in ZCNoSQLDeleteHelper

ZCNoSQLCondition

The Same conditions described above can be reused for delete.
NOSQL_RETURN_VALUE 

The same conditions described above can be reused for delete.

Delete with Condition and Return Value

table.getDeleteHelper(<ZCNoSQLItem>).withCondition(<ZCNoSQLCondition>).withReturnValue(<NOSQL_RETURN_VALUE>).delete();


---

## SDK — Node JS — NoSQL

--------------------------------------------------------------------------------
title: "Get Component Instance"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to create a new NoSQL component instance."
last_updated: "2026-06-10T06:04:37.468Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Java SDK (/en/sdk/java/v1/cloud-scale/nosql/get-table-metadata/)
- NoSQL Python SDK (/en/sdk/python/v1/cloud-scale/nosql/get-component-instance/)

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


# NoSQL

Catalyst NoSQL is a fully managed non-relational, NoSQL data storage feature that enables you to store the semi-structured, unstructured, and disparate data of your applications. Catalyst supports document-type data storage in the key-value pair based JSON format. 

The Catalyst NoSQL Node.js SDK package enables you to perform CRUD data operations on your NoSQL tables in your project. You can fetch the metadata of your NoSQL tables, create NoSQL items of various supported data types, and insert, update, fetch, or delete items in a specific table. You can also query tables or indexes of tables by specifying query conditions.

### Create a NoSQL Instance

A component instance is an object that can be used to access the pre-defined configurations specific to a particular component. 

You can create a NoSQL object to perform SDK operations in Node.js as shown below. This will not fire a server-side call. We will refer to this nosql instance in various code snippets of working with NoSQL.

The app reference used to create the NoSQL instance is the Node.js object returned as the response during the SDK initialization. 

// Create a NoSQL instance
const nosql = app.nosql(); 


--------------------------------------------------------------------------------
title: "Get Table Metadata"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch NoSQL table metadata. "
last_updated: "2026-06-10T06:04:37.469Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/en/cloud-scale/help/nosql/create-manage-tables/)

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


# Get NoSQL Table Metadata

You can get the metadata of a single Catalyst NoSQL table or of all tables in your project as described below.

### Get Metadata of Single Table

The metadata of a single table in Catalyst NoSQL can be obtained in two ways as mentioned in this page. The response will contain details of the table configuration, such as the partition key and sort key, TTL attribute, and more.

The nosql reference used in the code snippets below is the component instance created to perform these operations.

#### Get Table Metadata with Table ID 

You can fetch the metadata of a NoSQL table in your project by referring to its unique Table ID using the method getTable() as given below.

// Create a NoSQL instance
const nosql = app.nosql();
// Get table metadata using the Table ID
const tableA = await nosql.getTable('124567890');  

#### Get Table Metadata with Table Name

You can fetch the metadata of a NoSQL table in your project by referring the table name using the method getTable() as given below.

// Create a NoSQL instance
const nosql = app.nosql();
// Get table metadata using the table name
const tableB = await nosql.getTable('EmpTable');  

Note: If you rename the table, you will need to update the changes in your code.

<br>
 
### Get Metadata of All Tables

Catalyst enables you to fetch the metadata of all the tables in your project using the getAllTable() method as shown below.

// Get metadata of all tables
const allTables = await nosql.getAllTable(); 


--------------------------------------------------------------------------------
title: "Get Table Instance"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to create a NoSQL table instance."
last_updated: "2026-06-10T06:04:37.469Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/get-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/en/cloud-scale/help/nosql/create-manage-tables/)

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


# Get NoSQL Table Instance

Catalyst NoSQL enables you to fetch an empty table instance of an existing NoSQL table. You can then use this instance to refer to that table and perform all supported table operations. This process will not fire a server-side call. 

You can get an instance of your NoSQL table in three ways as described in this section. The nosql reference used in the code snippets below is the component instance created earlier. 

### Get Instance with Table ID

Get a table instance with the unique ID of the table as shown below.

const tableInstanceA = nosql.table('1234567890'); // Create a table instance with Table ID 

<br>

### Get Instance with Table Name

Get a table instance with the table's name as shown below.

const tableInstanceB = nosql.table('Emptable'); // Create a table instance with the table name 

<br>

### Get Instance with Table Details

Get a table instance by specifying the details of the table and resolving it to toJSON() as shown below. 

This method provides flexibility by allowing you to duplicate a table object whose instance you already fetched using the Table ID or table name. You can then configure additional details of the table to the instance and use this to refer to the table instead. 

const tableInstanceC = nosql.table(tableA.toJSON()); // Create a table instance with table details 




--------------------------------------------------------------------------------
title: "Construct NoSQL Item"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the methods to construct a NoSQL items of various data types."
last_updated: "2026-06-10T06:04:37.469Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- Supported Data Types in NoSQL (/en/cloud-scale/help/nosql/working-with-data/introduction/)

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


# Construct NoSQL Item


Catalyst NoSQL items represent a collection of attributes that hold the data of a single data point, like records. You can insert or update items into an existing NoSQL table in your project in a Custom JSON format. However, before you insert or update an item in Catalyst, you will need to construct the item. 

You can construct a NoSQL item of attributes containing different data types supported by Catalyst as described in the section below. Catalyst supports several data types such as String, Number, Set of Strings, Set of Numbers, List, and Map. Refer to the full list of supported data types to learn more.

You must mandatorily provide the values for the partition key attribute that you configured for a table in every data item. Refer to the Table Keys help section to learn about the table keys, TTL attribute, and other details.

<br>

### Create a New NoSQL Item

You can create a new NoSQL item using the NoSQLItem() method after requiring the no-sql library which is a part of the zcatalyst-sdk-node package, as shown below.

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
const item = new NoSQLItem() // Create a new NoSQL item 

<br>

### Construct a NoSQL Item of String

In the example below, we construct an item that includes string values and a nested JSON attribute color as a Map.

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
const item = new NoSQLItem() // Create a new NoSQL item
// Add a string value
.addString('fruit', 'mango')
// Add a map
.addMap('properties', {
color: 'yellow'
}); 

 <br>

### Construct a NoSQL Byte

You can create a NoSQL byte to store values of the *Binary* data type, by creating a buffer object that is used to represent a sequence of bytes. You can then create a byte in two ways as shown below: using the ArrayBuffers object that represents a raw binary data buffer, or from a Base64 string that represents binary data in the ASCII format.

const { NoSQLByte } = require('zcatalyst-sdk-node/lib/no-sql');
// Create a NoSQL Byte
const buff = Buffer.from('Hello world !!!'); // Create a buffer object
const byte = new NoSQLByte(buff); // Create a NoSQL byte using the ArrayBuffers object
const byteA = new NoSQLByte(buff.toString('base64')); // Create a NoSQL byte from a Base64 string 

<br>


### Construct a NoSQL Byte Set

Catalyst enables you to create a NoSQL byte set to store a collection of binary values of the *Set of Binary* data type, by creating a buffer object that is used to represent a sequence of bytes. You can then create a byte set by using the ArrayBuffers object that represents a raw binary data buffer, or from a Base64 string that represents binary data in the ASCII format.

You can also create a byte set from passing constructed bytes as a byte array.

const { NoSQLByte, NoSQLByteSet } = require('zcatalyst-sdk-node/lib/no-sql');
// Create a NoSQL Byte Set
const buff = Buffer.from('Hello world !!!'); // Create a buffer object
const byte = new NoSQLByte(buff); // Create a NoSQL byte using the ArrayBuffers object
const byteA = new NoSQLByte(buff.toString('base64')); // Create a NoSQL byte from a Base64 string
const byteSet = new NoSQLByteSet([byte, byteA]); // Create a NoSQL byte set from a NoSQL byte array
const byteSetA = new NoSQLByteSet([buff.toString('base64')]); // Create a NoSQL Byte set from a Base64 string array
const byteSetB = new NoSQLByteSet([buff]); // Create a NoSQL Byte set using the ArrayBuffers object 

<br>

### Construct a NoSQL String Set

You can create a NoSQL string set of the *Set of String* data type from a string array as shown below.

const { NoSQLStringSet } = require('zcatalyst-sdk-node/lib/no-sql');
// Create a NoSQL string set
const stringSet = new NoSQLStringSet(['hello', 'world']); // Create a NoSQL string set from a string array 

<br>

### Construct a NoSQL Number Set

You can create NoSQL number set of the *Set of Numbers* data type from an array of numbers or BigInt values as shown below.

const { NoSQLNumberSet } = require('zcatalyst-sdk-node/lib/no-sql');
// Create a NoSQL number set
const numberSet = new NoSQLNumberSet([123, 1234n]); // Create a NoSQL Number set from an array of numbers or BigInt values 

<br>

### Manipulate NoSQL Items

Catalyst enables you to perform manipulations on a NoSQL items, such as creating a NoSQL item from a plain JavaScript object, or vice versa. You can create a NoSQL item by constructing a plain JavaScript object that contains the item's data in it, in the standard JSON format. You can then construct the NoSQL item from the JS object using NoSQLItem.from() as shown in the sample code below.

You can also convert a NoSQL item back into a plain JavaScript object using itemFromObj.to(), as depicted in the code.

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
// Define an object
const obj = {
fruit: 'apple', // Partition key
properties: {
color: 'red'
}
};
const itemFromObj = NoSQLItem.from(obj); // Construct a NoSQL item from the plain JS object
const plainJsObject = itemFromObj.to(); // Convert the item to a plain JS object 



--------------------------------------------------------------------------------
title: "Insert Items in Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK methods to insert items in a NoSQL table in various ways."
last_updated: "2026-06-10T06:04:37.469Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Insert Items in NoSQL Table

Catalyst enables you to insert items in a specific NoSQL table after you construct them. The items can be inserted in different ways as described in this section. 

You can refer to the help sections on adding and working with data, the Catalyst custom JSON format, and the supported data types to learn these topics in detail.

Note: Catalyst enables you to insert a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.

<br>

### Insert Items without Conditions

You can insert new items into a NoSQL table without any conditions by constructing the items in the Catalyst custom JSON format. This will require you to mandatorily pass the values for the partition key and sort key attributes configured for the table. 

In the example given below, an item containing the value of the partition key attribute fruitName is provided as "Banana". Other attributes of the string data type such as fruitColor and fruitType are also added as a map called fruitProperties. The item is inserted using the insertItems() method.

// Insert a NoSQL item without conditions
const plainInsert = await table.insertItems({
// Define the item to be inserted with the partition key fruitName
item: NoSQLItem.from({
fruitName: 'Banana',
//Provide values for the other attributes of the item
fruitProperties: {
fruitColor: 'Yellow', 
fruitType: 'Berries'  
}
}),
// Set the return value in the response. Other supported values are "OLD" and "NULL"
return: NoSQLReturnValue.NEW
}); 

<br>

### Insert Items with Conditional Functions

You can insert attributes in existing items in a NoSQL table using specific conditions that you define in the Catalyst custom JSON format. In this type, the existing data of the table is retrieved and evaluated against the specified condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted. 

Catalyst supports multiple operators to evaluate conditions. The supported operators are represented as shown below.

<table class="content-table nosql-components-table">

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

<br>

The example below illustrates this by defining a condition for the data type of the attribute fruitName to be String in the existing data. If the condition is satisfied, the attribute taste with the value "Sweet" is added to these items.

// Insert a NoSQL item with the "attribute_type" function
const attrTypeInsert = await table.insertItems({
// Define the item to be inserted
item: NoSQLItem.from({ taste: 'Sweet' }),
// Define the condition for insert
condition: {
// The condition specifies that the item should be added if the attribute type is String ("S")
function: {
// Set the function type
function_name: 'attribute_type',
// Supply the arguments to the function
args: [
{
// Set the attribute path
attribute_path: ['fruitName']
},
// Set the attribute type
NoSQLMarshall.makeString('S') // => { "S": "S" }
]
}
}
}); 

<br>

Here are some more sample snippets for inserting items with conditional functions.

//Insert a NoSQL Item with the "equals" operator, attribute "name" value equals "apple"
const operatorEqInsert = await table.insertItems({
// Define the item to be inserted
item: NoSQLItem.from({ taste: 'Sweet' }),
// Define the condition for insert
condition: {
// Set the attribute path
attribute: ['name'],
// Set the operator based on the operation
operator: NoSQLOperator.EQUALS,
// Set the value for comparison
value: NoSQLMarshall.makeString('apple') // => { "S": "apple" }
}
});
//Insert a NoSQL Item with "group_operator", attribute "name" is "apple" AND attribute "variety" is "gala"
const groupOpInsert = await table.insertItems({
// Define the item to be inserted
item: NoSQLItem.from({ taste: 'Sweet' }),
// Define the condition for insert
condition: {
// Set the group operator
group_operator: NoSQLConditionGroupOperator.AND,
// Supply the group conditions
group: [
{
// Set the attribute path
attribute: 'name',
// Set operator based on the operation
operator: NoSQLOperator.EQUALS,
// Set the value for comparison
value: NoSQLMarshall.makeString('apple') // => { "S": "apple" }
},
{
// Set the attribute path
attribute: 'variety',
// Set the operator based on the operation
operator: NoSQLOperator.EQUALS,
// Set the value for comparison
value: NoSQLMarshall.makeString('gala') // => { "S": "gala" }
}
]
}
});
//Insert a NoSQL Item with the "begins_with" operator, attribute "name" value begins with "app"
const beginsWithInsert = await table.insertItems({
// Define the item to be inserted
item: NoSQLItem.from({ taste: 'Sweet' }),
// Define the condition for insert
condition: {
// Set the attribute path
attribute: ['name'],
// Set the operator based on the operation
operator: NoSQLOperator.BEGINS_WITH,
// set the value for comparison
value: NoSQLMarshall.makeString('app') // => { "S": "app" }
}
}); 


--------------------------------------------------------------------------------
title: "Update Items in Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to update items in a NoSQL table."
last_updated: "2026-06-10T06:04:37.473Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/update-item/#UpdateItem)

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


# Update Items in Table

Catalyst enables you to update items in a specific NoSQL table after you construct them. An item can be updated by identifying it using its primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to identify the item. 

You can then define the update operation type with the appropriate HTTP request method and provide the attributes and values to be updated in the item. 

Note: Catalyst enables you to update a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.

The example below illustrates this by identifying an item with the partition key fruitName and value "Apple". The values for the attributes of this item to be updated, color and taste are provided, along with the path to these attributes.

The no-sql library from  the zcatalyst-sdk-node package is required to define and construct the NoSQL item.

const { NoSQLItem, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = NoSQLEnum;
// Update a NoSQL Item identified with the partition key "apple" with its properties attribute updated
const updatedItems = await table.updateItems({
// Define the partition key value of the item to be updated
keys: [new NoSQLItem().addString('fruit', 'apple')],
// Define the attributes to be updated
update_attributes: [
{
// Specify the type of the update operation
operation_type: NoSQLUpdateOperationType.PUT,
// Provide the values for the attribute to be updated
update_value: NoSQLMarshall.makeMap({ color: 'Green', taste: 'Sour' }),
// Specify the path to the attributes
attribute_path: ['fruitProperties']
}
]
}); 


--------------------------------------------------------------------------------
title: "Fetch Items from Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch items from a NoSQL table."
last_updated: "2026-06-10T06:04:37.473Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/fetch-item/#FetchItem)

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



# Fetch Items from NoSQL Table

Catalyst enables you to fetch items from a NoSQL table by identifying them with their primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to fetch the item. You can also optionally filter the attributes to be fetched by specifying the required attributes. 

Note: Catalyst enables you to fetch a maximum of 100 items from a NoSQL table in a single SDK read operation. 

The example below illustrates fetching an item identified by its partition key fruit with the value "apple" using fetchItem(). Specific attributes such as properties and taste are filtered to be fetched using required_attributes. 

The code snippet also uses consistent_read to indicate if the read operation must be done using the master or a slave cluster. When set to true, it is queried from the master. If 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.

The no-sql library from  the zcatalyst-sdk-node package is required to define the NoSQL item.

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
//Fetch properties of a NoSQLItem identified with the partition key value "apple"
const fetchedItem = await table.fetchItem({
// Define the partition key and value of the item to be fetched
keys: [new NoSQLItem().addString('fruit', 'apple')],
// Set consistent_read to true to query from master. If set to false, it is queried from slave.
consistent_read: true,
// Specify the attributes to be fetched
required_attributes: [['properties', 'taste']]
}); 



--------------------------------------------------------------------------------
title: "Query Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to query a NoSQL table."
last_updated: "2026-06-10T06:04:37.473Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Table Keys (/en/cloud-scale/help/nosql/components/#table-keys)
- Query Table (/en/sdk/nodejs/v2/cloud-scale/nosql/query-table/)

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


# Query NoSQL Table

Catalyst enables you to query a NoSQL table and retrieve data by identifying the items using the primary 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 class="content-table nosql-components-table">

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

In the example below, the query is executed using the queryTable() method by identifying the items using the partition key fruitType and specifying the condition value as "Citrus". 

Catalyst NoSQL also lets you define other elements of the query, such as using consistent_read to indicate if the read operation must be done using the master or a slave cluster, limiting the number of rows to be returned, and specifying the sorting order as ascending. 

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.

The no-sql library from  the zcatalyst-sdk-node package is required to define the NoSQL item.

const { NoSQLMarshall, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = 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 the descending order.
forward_scan: true
}); 


--------------------------------------------------------------------------------
title: "Query Index"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to query a NoSQL index."
last_updated: "2026-06-10T06:04:37.473Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Table Keys (/en/cloud-scale/help/nosql/components/#table-keys)
- Query Index (/en/sdk/nodejs/v2/cloud-scale/nosql/query-index/)

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


# Query Index in NoSQL

Catalyst enables you to query a NoSQL index and retrieve data by identifying the items using the primary keys of the index. Indexing allows you to execute alternate queries on the table data without making use of the primary keys of the main table. You can configure indexes from the Catalyst console. You can use just the partition key or a combination of the partition key and sort key of the index to retrieve an 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 class="content-table nosql-components-table">

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

 
In the example below, the query is executed by identifying the items using the index FruitIdentifier 's partition key fruitColor and specifying the condition value as "yellow". The query is done using the queryIndex() method.

Catalyst NoSQL also lets you define other elements of the query, such as using consistent_read to indicate if the read operation must be done using the master or a slave cluster, limiting the number of rows to be returned, and specifying the sorting order as ascending. 

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.

The no-sql library from  the zcatalyst-sdk-node package is required to define the NoSQL item.

const { NoSQLMarshall, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = NoSQLEnum;
//Query a NoSQL table index to fetch the items identified by the partition key fruitColour with the value "yellow"
const queriedIndexItems = await table.queryIndex('FruitIdentifier', {
//Define the key condition to query the items with
key_condition: {
attribute: 'fruitColor',
//Define the supported operator to be used
operator: NoSQLOperator.EQUALS,
value: NoSQLMarshall.makeString('yellow')
},
// 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: 15,
// Set forward_scan to true to sort the results in ascending order. Otherwise, it is sorted in the descending order.
forward_scan: true
}); 


--------------------------------------------------------------------------------
title: "Delete Items from Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to delete items from a NoSQL table."
last_updated: "2026-06-10T06:04:37.474Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/delete-item/#DeleteItem)

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


# Delete Items from NoSQL Table

You can delete items from a NoSQL table in Catalyst by identifying them using the primary keys of the table. For instance, you use just the partition key, or a combination of the partition key and sort key of the table, to identify an item.

Note: Catalyst enables you to delete a maximum of 25 items in bulk from a NoSQL table with a single SDK operation.

The delete operation is performed using the deleteItems() method as shown in the example below. The item with the partition key fruit matching "apple" is deleted. The no-sql library from  the zcatalyst-sdk-node package is required to define NoSQL items.

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
//Delete a NoSQL item from the table with partition key "fruit" and the value matching "apple"
const deletedItems = await table.deleteItems({
//Specify the partition key value of the item to be deleted
keys: NoSQLItem.from({ fruit: 'apple' })
}); 


---

## SDK — Python — NoSQL

--------------------------------------------------------------------------------
title: "Get Component Instance"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to create a new NoSQL component instance."
last_updated: "2026-06-10T06:04:37.480Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/get-component-instance/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Java SDK (/en/sdk/java/v1/cloud-scale/nosql/get-table-metadata/)
- NoSQL Node.js SDK (/en/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/)

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


# Get Component Instance

Catalyst NoSQL is a fully managed non-relational, NoSQL data storage feature that enables you to store the semi-structured, unstructured, and disparate data of your applications. Catalyst supports document-type data storage in the key-value pair based JSON format. 

The Catalyst NoSQL Python SDK package enables you to perform CRUD data operations on your NoSQL tables in your project. You can fetch the metadata of your NoSQL tables, create NoSQL items of various supported data types, and insert, update, fetch, or delete items in a specific table. You can also query tables or indexes of tables by specifying query conditions.

### Create a NoSQL Instance

A component instance is an object that can be used to access the pre-defined configurations specific to a particular component. 

You can create a NoSQL object to perform SDK operations in Python as shown below. This will not fire a server-side call. We will refer to this nosql instance in various code snippets of working with NoSQL.

The app reference used to create the NoSQL instance is the Python object returned as the response during the SDK initialization. 

 #Create a NoSQL instance
nosql = app.nosql()



--------------------------------------------------------------------------------
title: "Get Table Metadata"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch NoSQL table metadata. "
last_updated: "2026-06-10T06:04:37.480Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/en/cloud-scale/help/nosql/create-manage-tables/)

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


# Get NoSQL Table Metadata

You can get the metadata of a single Catalyst NoSQL table or of all tables in your project as described below.

### Get Metadata of Single Table

The metadata of a single table in Catalyst NoSQL can be obtained by referring the table name using the method getTable() as given below. The response will contain details of the table configuration, such as the partition key and sort key, TTL attribute, and more.

The nosql reference used in the code snippets below is the component instance created to perform these operations.

# Create a NoSQL instance
nosql = app.nosql()
#Get table metadata using the table name
table_details = nosql.get_table_resources("EmpTable")
print(table_details)

Note: If you rename the table, you will need to update the changes in your code.

<br>
 
### Get Metadata of All Tables

Catalyst enables you to fetch the metadata of all the tables in your project using the get_all_tables() method as shown below.

table_res = nosql.get_all_tables()
print(table_res)




--------------------------------------------------------------------------------
title: "Get Table Instance"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to create a NoSQL table instance."
last_updated: "2026-06-10T06:04:37.480Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/get-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/en/cloud-scale/help/nosql/create-manage-tables/)

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


# Get NoSQL Table Instance

Catalyst NoSQL enables you to fetch an empty table instance of a NoSQL table. You can then use this instance to refer to that table and perform all supported table operations. This process will not fire a server-side call. 

You can get an instance of your NoSQL table by referring to the table's name as shown in this section. The nosql reference used in the code snippets below is the component instance created earlier. 

table = nosql.get_table('employees')
# Create a table instance with the table name


--------------------------------------------------------------------------------
title: "Construct Item"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the methods to construct a NoSQL items of various data types.""
last_updated: "2026-06-10T06:04:37.480Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- Supported Data Types in NoSQL (/en/cloud-scale/help/nosql/working-with-data/introduction/)

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


# Construct NoSQL Item

Catalyst NoSQL items represent a collection of attributes that hold the data of a single data point, like records. You can insert or update items into an existing NoSQL table in your project in a Custom JSON format. However, before you insert or update an item in Catalyst, you will need to construct the item. 

You can construct a NoSQL item of attributes containing different data types supported by Catalyst as described in the section below. Catalyst supports several data types such as String, Number, Set of Strings, Set of Numbers, List, and Map. Refer to the full list of supported data types to learn more.

You must mandatorily provide the values for the partition key attribute that you configured for a table in every data item. Refer to the Table Keys help section to learn about the table keys, TTL attribute, and other details.

The code snippet below shows the formats for constructing an item with attributes of different data types:

# Construct a NoSQL item of different data types
attributes = {	
		# string
		"custom_attrib_string": {
 			"S": "John Doe"
 		},
		# Number
 		"custom_attrib_num": {
 			"N": "234521"
 		},
		# Binary encoded value
		 "custom_attrib_bin": {
 			"B": "SGVsbG9Xb3JsZA=="
 		},
		# Set of string
		 "custom_attrib_set_string": {
 			"SS": ["John Doe", "New York", "USA"]
 		},
		# set of numbers
 		"custom_attrib_set_num": {
 			"SN": ["23423", "821n", "11"]
 		},
		# set of binary values
		 "custom_attrib_set_bin": {
			 "SB": ["SGVsbG8=", "V29ybGQ="]
 		},
		# boolean attribute
 		"custom_attrib_bool": {
			 "BOOL": True
		 },
		# list attribute
 		"custom_attrib_list": {
			 "L": [{"name": "banana"}, {"quantity": 4}]
 		},
		# map attribute
 		"custom_attrib_map": {
 			"M": {
 				"name": {
					 "S": "John Doe"
 				},
 				"age": {
 					"N": "23"
				 }
 			}
 		}
}




--------------------------------------------------------------------------------
title: "Insert Items"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK methods to insert items in a NoSQL table in various ways."
last_updated: "2026-06-10T06:04:37.480Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# Insert Items in NoSQL Tables

Catalyst enables you to insert items in a specific NoSQL table after you construct them. The items can be inserted in different ways as described in this section.

You can refer to the help sections on adding and working with data, the Catalyst custom JSON format, and the supported data types to learn these topics in detail.

Note: Catalyst enables you to insert a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.

<br>

### Insert Items without Conditions

You can insert new items into a NoSQL table without any conditions by constructing the items in the Catalyst custom JSON format. This will require you to mandatorily pass the values for the partition key and sort key attributes configured for the table. 

For example, in the code snippet below, the values for the partition key and sort key attributes of the item, fruitName and Location respectively, are provided. Other attributes of the string data type such as fruitType and availability are provided as a list fruitProperties. The item is then inserted using the insert_items() method.

# Insert a NoSQL item without conditions
item = {
	 "fruitName": {
		 "S": "Banana"
 	},
	"Location": {
    "S": "Indonesia"
    },
	 "fruitProperties": {
 		"L": [
			{ 
			"fruitType": "Berries"
			},
 			{ 
    		"availability": "abundant"
  			 }
		}
		]
 	}
 } # Insert the item based on the defined condition and set the item to be returned in the response. Other supported values are "OLD" and "NULL"
res = table.insert_items({ 
	 'item': item,
	'return': 'NEW' 
})

<br>

### Insert Items with Conditional Functions

You can insert attributes in existing items in a NoSQL table using specific conditions that you define in the Catalyst custom JSON format. In this type, the existing data of the table is retrieved and evaluated against the specified condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted.

Catalyst supports multiple operators to evaluate conditions. The supported operators are represented as shown below.

<table class="content-table nosql-components-table">

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

<br>

The example below illustrates this by defining a condition for the nested attribute fruitColour in the existing data to contain the value "Yellow". This attribute is part of the attribute fruitProperties. If the condition is satisfied, the attributes fruitType and availability are added to the items. The item is then inserted using the insert_items() method.

# Insert a NoSQL item with a conditional function
condition_function = {
 	"function": {
		"function_name": "attribute_type",
			"args": [ {
 				"attribute_path": ["fruitProperties", "[0]"]
 					}, 
					{
		"fruitColour": "Yellow"
			}
 		]
 	}
 }
 item = {
 	"Location": {
 		"S": "Indonesia"
 	},
	 "fruitName": {
		"S": "Banana"
 	},
	"fruitProperties": {
 		"L": [
			{ 
			"fruitType": "Berries"
			},
 			{ 
    "availability": "abundant"
    }
		}
		]
	}
 }
    # Insert the item based on the defined condition and set the return value in the response. Other supported values are "OLD" and "NULL"
 res = table.insert_items({ 
	'item': item,
	'condition': condition_function,
	'return': 'NEW' 
})

<br>

### Insert Items with Conditional Operators

Catalyst also enables you to insert items based on conditions defined with operators in the Catalyst custom JSON format. The existing data of the table is retrieved and evaluated against the specified condition. The items are inserted only if the evaluation is true. If there is no existing data, the conditions are ignored and the items are inserted.

Catalyst supports multiple operators to evaluate conditions, as listed in the [previous section](#insert-items-with-conditional-functions).

The example below illustrates inserting an item based on conditions defined with the between operator. The condition states that only when the attribute count has values between 0 and 10 in the existing data, the attributes backupID and count are to be inserted in those items. The item is inserted with the insert_items() method.

# Insert a NoSQL item with a conditional operator
condition_function = {
	"attribute": ["count"],
	"operator": "between",
	"value": {
	"L": [
		{ 
		"N": "0" 
		},
		{ 
		"N": "10"
		}
      	]
     }
    }
item = {
 	"countryCode": {
		"N": 054
			 },
		"backupID": {
			"N": 2379992
 			},
 	"count": {
      "N": "3"
     }
    }
    # Insert the item based on the defined condition and set the return value in the response. Other supported values are "OLD" and "NULL"
res = table.insert_items({ 
'item': item,
'condition': condition_function,
'return': 'NEW' 
})



--------------------------------------------------------------------------------
title: "Update Items"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to update items in a NoSQL table."
last_updated: "2026-06-10T06:04:37.481Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
--------------------------------------------------------------------------------



# Update NoSQL Items in Table

Catalyst enables you to update items in a specific NoSQL table after you construct them. An item can be updated by identifying it using its primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to identify the item. 

You can then define the update operation type with the appropriate HTTP request method and provide the attributes and values to be updated in the item. 

Note: Catalyst enables you to update a maximum of 25 items in bulk in a NoSQL table with a single SDK operation.

The example below illustrates this by retrieving an item with the partition key fruitName and the sort key location. The attributes of this item to be updated are color and taste. The values for all these attributes are provided. 

You can also optionally define a condition for update. The update will occur only if the condition is met. 

# Update a NoSQL item by identifying it with its primary keys
res = table.update_items({
 	"keys": {
 		"fruitName": {
			 "S": "Banana"
 			},
 		"location": {
			 "S": "Indonesia"
 			}
 		},# Define the attributes to be updated in the item
	"update_attributes": [
 		{
 		"operation_type": "PUT",
 		"color": {
 			"S": "Yellow"
 			},
		"taste": {
    "S": "Sweet"
      },
 	"attribute_path": "fruitProperties"
 		}
 	],# Define a condition. The item will be updated only if this is satisfied. (optional)
 	"condition" : {
 		"function": {
 			"function_name": "attribute_exists",
 			"args": [
				 {
 			"attribute_path": "fruitProperties"
 				}
 		]
 	}
}
})
print(res)



--------------------------------------------------------------------------------
title: "Fetch Items"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to fetch items from a NoSQL table."
last_updated: "2026-06-10T06:04:37.481Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/fetch-item/#FetchItem)

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


# Fetch Items from NoSQL Table 

Catalyst enables you to fetch items from a NoSQL table by identifying them with their primary keys. For instance, you can use just the partition key or a combination of the partition key and sort key to fetch the item. You can also optionally filter the attributes to be fetched by specifying the required attributes. 

Note: Catalyst enables you to fetch a maximum of 100 items from a NoSQL table in a single SDK read operation.  

The example below illustrates fetching an item identified by its partition key fruit and the sort key location using fetch_item(). Specific attributes such as properties and taste are filtered to be fetched using required_objects. 

# Fetch properties of a NoSQLItem identified with the partition key and sort key
res = table.fetch_item({
   "keys": [
    {
     "fruit": {
      "S": "apple"
     },
     "location: {
      "S": "USA"
     }
    }
  ],
# Specify the attributes to be fetched
   'required_objects': ["properties", "taste"] 
 })
print(res)



--------------------------------------------------------------------------------
title: "Query Table"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to query a NoSQL table."
last_updated: "2026-06-10T06:04:37.481Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Table Keys (/en/cloud-scale/help/nosql/components/#table-keys)
- Query Table (/en/sdk/nodejs/v2/cloud-scale/nosql/query-table/)

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


# Query NoSQL Table

Catalyst enables you to query a NoSQL table and retrieve data by identifying the items using the primary 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. You can also specify additional conditions with the group operators. 

The supported operators are represented as shown below.

<table class="content-table nosql-components-table">

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

In the example below, the query is executed using the queryTable() method by identifying the items using the partition key fruitType and specifying the condition value as "citrus". We also specify an additional condition with the attribute location matching "USA".

Catalyst NoSQL also lets you define other elements of the query, such using consistent_read to indicate if the read operation must be done using the master or a slave cluster, limiting the number of rows to be returned, and specifying the sorting order as ascending. 

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.

# Query a NoSQL table to fetch the items identified by the partition key fruitType with the value "citrus"
res = table.query_table(
 {
    # Set consistent_read to true to query from master. If set to false, it is queried from slave.
   'consistent_read': 'true',# Set forwardScan to true to sort the results in ascending order. Otherwise, it is sorted in the descending order.
   'forwardScan': 'true',# Limit the number of rows to be returned by specifying a value
   'limit': 10,# Define the key condition to identify items
   'key_condition': {
    'attribute': 'fruitType',
    'operator': 'equals',
    'value': {
     'S': 'citrus'
    }
   },
    # Specify additional conditions to query the table items using group operators
   'other_condition': {
    'group_operator': 'and',
    'group': [
     {
     'attribute': 'location',
     'operator': 'equals',
     'value': {
      'S': 'USA'
     }
     }
    ]
   } 
 })
print(res)


--------------------------------------------------------------------------------
title: "Query Index"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to query a NoSQL index."
last_updated: "2026-06-10T06:04:37.488Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Table Keys (/en/cloud-scale/help/nosql/components/#table-keys)
- Query Index (/en/sdk/nodejs/v2/cloud-scale/nosql/query-index/)

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


# Query Index

Catalyst enables you to query a NoSQL index and retrieve data by identifying the items using the primary keys of the index. Indexing allows you to execute alternate queries on the table data without making use of the primary keys of the main table. You can configure indexes from the Catalyst console. You can use just the partition key or a combination of the partition key and sort key of the index to retrieve an 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. You can also specify additional conditions with the group operators. 

The supported operators are represented as shown below.

<table class="content-table nosql-components-table">

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


In the example below, the query is performed with an index referenced by its unique Index ID. The query identifies the items using the index's partition key fruitColor and specifying the condition value as "yellow". We also specify an additional condition with the attribute fruitType matching "citrus". The query is done using the query_index() method.

Catalyst NoSQL also lets you define other elements of the query, such using consistent_read to indicate if the read operation must be done using the master or a slave cluster, limiting the number of rows to be returned, and specifying the sorting order as ascending. 

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.


# Query a NoSQL table index to fetch the items identified by the partition key fruitColour with the value "yellow"# Pass the index's unique ID
cres = table.query_index('6759000000740017', {
  # Set consistent_read to true to query from master. If set to false, it is queried from slave.
   'consistent_read': 'true',# Set forward_scan to true to sort the results in ascending order. Otherwise, it is sorted in the descending order.
   'forwardScan': 'true',# Limit the number of rows to be returned by specifying a value
   'limit': 10,# Define the key condition to query the items with
   'key_condition': {
    'attribute': 'fruitColor',
    'operator': 'equals',
   'value': {
     'S': 'yellow'
    }
   },
   # Define additional conditions to query the data with, using group operators
   'other_condition': {
    'group_operator': 'AND',
    'group': [
     {
      'attribute': 'fruitType',
      'operator': 'equals',
      'value': {
       'S': 'citrus'
      }
     }
    ]
   } 
 })
print(res)


--------------------------------------------------------------------------------
title: "Delete Items"
description: "Catalyst NoSQL is a fully-managed, powerful database that provides you with a non-relational, non-SQL means of data storage. This page describes the SDK method to delete items from a NoSQL table."
last_updated: "2026-06-10T06:04:37.489Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/en/cloud-scale/help/nosql/introduction)
- Working with Data (/en/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/en/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/en/api/code-reference/cloud-scale/nosql/delete-item/#DeleteItem)

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


# Delete Items from NoSQL Table

You can delete items from a NoSQL table in Catalyst by identifying them using the primary keys of the table. For instance, you use just the partition key, or a combination of the partition key and sort key of the table, to identify an item.

Note: Catalyst enables you to delete a maximum of 25 items in bulk from a NoSQL table with a single SDK operation.

The delete operation is performed using thedelete_items() method as shown in the example below. The item with the partition key fruit matching "apple" and the sort key location matching "USA" is deleted. You can also specify additional conditions for delete. Only if the item matches the condition, it will be deleted.


# Delete a NoSQL item from the table by identifying it with the partition key and sort key
res = table.delete_items( {
   "keys": {
    "fruit": {
     "S": "apple"
    },
    "location": {
     "S": "USA"
    }
   }
 }),
 # Specify a condition for delete (optional)
		 "condition": {
			 "function": {
 			"function_name": "attribute_exists",
 			"args": [
 				{
 					"attribute_path": ["properties"]
 				}
 				]
		 	}
 		}
 })
print(res)