# NoSQL



--------------------------------------------------------------------------------
title: "はじめに"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.650Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# Catalyst NoSQL

### はじめに

Catalyst Cloud Scale NoSQLは、非リレーショナルなデータストレージアプローチを提供するフルマネージドで強力なデータベースです。従来のSQLモデルに依存することなく、非構造化、半構造化、異種混合のデータを扱うことができます。Catalystを基盤とした高度にスケーラブルな独自インフラストラクチャにより、プロビジョニング、設定、スケーリングなどのバックエンドタスクを気にすることなく、データベースの作成と管理を簡単に行えます。この柔軟性により、現代のデータ駆動型アプリケーションに最適です。

Catalystは、CloudScaleサービスの従来のリレーショナルデータベースであるData Storeに加えて、NoSQLを提供しています。ビジネス要件やデータベースの固定スキーマの可能性、読み取り集中型システムの必要性などの各種要因に応じて、ユースケースに最適なデータストレージオプションを決定できます。詳しくは、Data StoreとNoSQLの[比較セクション](#catalyst-data-store-vs-nosql)を参照してください。

Catalystは、NoSQLで**キーバリューペアベース**のドキュメント型データストレージをサポートしており、多数のデータ型をサポートするカスタムJSON形式でデータを格納する機能を備えています。クラスター全体にデータをパーティショニングする機能により、NoSQLは大容量のストレージオプションを提供し、マルチレベルのスケーラビリティも実現します。

Catalyst NoSQLでアプリケーションを構築する場合、Catalystコンソールからプロジェクトにテーブルを簡単に作成し、設定し、データを追加し、データをクエリできます。また、既存のNoSQLデータベースをサードパーティソースからCatalystに数回の簡単な手順で移行することもできます。

Catalystは、データの追加やクエリなど、さまざまなNoSQL CRUD操作を実行するためのサーバーサイドSDKを以下のプログラミング環境で提供しています:

* Java
* Node.js
* Python

利用可能なSDKメソッドについては、リンクされたSDKドキュメントを参照してください。これらの操作にはCatalystのNoSQL APIも利用できます。詳細については、APIドキュメントを参照してください。

<br>

### Catalyst Data Store vs NoSQL

Catalystは、Data StoreとCatalyst NoSQLの2つの異なるデータストレージオプションを提供しています。前者はSQLおよびリレーショナルデータベースであり、後者は非リレーショナルデータベースです。ビジネスロジック、アプリケーションのデータ構造、使用状況などのさまざまな要因に基づいて、ニーズに適したデータベースを選択できます。

非構造化データをリレーショナルデータベースに格納すると、スキーマの整理に問題が生じ、データの冗長性につながることがよくあります。そのため、ユースケースに適したストレージプラットフォームを選択する必要があります。

以下は、要件に最適なデータベースオプションを決定するのに役立つガイドです。

#### Catalyst Data Store

以下の条件を満たす場合、Catalyst Data Storeを選択してください:

* アーキテクチャ: データベースのアーキテクチャがリレーショナルである、つまりデータポイントが互いに関連している場合。

* データ構造: データが適切に構造化されており、行と列に整然と整理してテーブルを形成できる場合。

* スキーマ: データベースのスキーマが統一されており、事前に判明しており、データ操作の前に静的に設計・確定できる場合。

* クエリ言語: データベースのクエリ、更新、メンテナンスにSQLの使用が必要な場合。SQLはリレーショナルで構造化されたデータベースに適しています。

* 優先事項: データベースの優先事項が水平スケーラビリティではなく、ACIDコンプライアンス（原子性、一貫性、分離性、耐久性）である場合。

* 読み取り/書き込みスループット: 読み取り集中型データベースに対して、最小限のラグとオーバーヘッドで高速、エラーフリー、効率的なクエリが必要な場合。


#### Catalyst NoSQL

以下の条件を満たす場合、Catalyst NoSQLを選択してください:

* アーキテクチャ: データベース内のデータポイント間に相互依存関係やリレーションシップがなく、独立したエンティティとして存在する場合。

* データ構造: データベースに半構造化または非構造化の異種データが含まれており、従来の表形式で格納できず、緩やかに整理されている場合。

* スキーマ: データベースのスキーマが非常に柔軟で、すべてのアイテムが同じ構造に準拠する必要がなく、セットアップが容易であるか、事前に設計できない場合。

* データ形式: データが主にJSON形式であり、複数のデータ型のサポートが必要な場合。

* 優先事項: 垂直および水平の両方の高いスケーラビリティが優先事項であり、動的リソース割り当てを伴う複数のデータベースノードにまたがるストレージが必要な場合。

* 読み取り/書き込みスループット: ピアツーピアレプリケーションを伴う分散クラスター全体にストレージをパーティショニングすることが有益な、書き込み集中型システムを構築する場合。


--------------------------------------------------------------------------------
title: "メリット"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.650Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/benefits/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# メリット


1. 高速な水平・垂直オートスケーリング

CatalystはNoSQLで低レイテンシ・高スループットのデータベースソリューションを提供しており、堅牢なサーバーが負荷に応じてシームレスにオートスケールアップまたはスケールダウンできます。NoSQLのアーキテクチャは、水平スケーリングと垂直スケーリングの両方を容易にします。既存のシステムに新しいリソースが追加され（垂直スケーリング）、需要に応じて新しいサーバーラックがプロビジョニングされます（水平スケーリング）。これらにより、大量のデータを効率的に保存・管理できる、耐久性と信頼性の高いインフラストラクチャが提供されます。

<br>

2. フルマネージドでセキュアなデータベースインフラストラクチャ

自己ホスト型のNoSQLデータベースと比較して、Catalystではすべての管理タスクをオフロードできるフルマネージドデータベースを利用でき、スキーマの構築とデータの操作にのみ集中できます。また、データを保護し、スケーラブルな開発の容易さ、機能性、パフォーマンスを提供する、Zohoの実績あるインフラストラクチャ上に構築されたセキュアで信頼性の高いプラットフォームの恩恵を受けられます。

<br>

3. NoSQLコンポーネントによる高速で強力なクエリ

Catalyst NoSQLは、パーティションキーとソートキーの両方で構成される複合プライマリキーをサポートすることで、動的で柔軟なクエリを提供します。これはクエリ時に有益で、前者の属性はアイテムが格納されているパーティションの決定に使用され、後者はソート順でのその範囲を決定できます。これらに加えて、Catalystではメインのソートキー以外の追加ソートキーを使用したクエリや、テーブルにインデックスを作成してクエリに利用することもできます。これらの機能は有益であり、高性能で信頼性の高いアプリケーションを構築・デプロイできることを保証します。

<br>

4. 簡単でセキュアなサードパーティのメタデータとデータの移行

サードパーティサービスに格納された大量のメタデータとデータを、数回のクリックでCatalystに移行する便利な方法を利用できます。NoSQLは現在、必要なアクセストークンを設定することで、AWS DynamoDBからの移行をサポートしています。この便利な機能により、AWSで設定したNoSQLテーブルのスキーマとメタ情報をCatalystの開発環境に移行でき、また本番環境ではAWS NoSQLテーブルからのデータ移行も可能です。

<br>

5. 最適化された高可用性ストレージ

NoSQLの基盤となるアーキテクチャは、デフォルトで柔軟なデータモデルを使用することにより、高いデータストレージの最適化を実現します。Catalyst NoSQLのキーバリューペアベースのデータストレージのサポートにより、オブジェクト指向ストレージへの依存がなくなり、ストレージの最適化がさらに確保されます。さらに、クラスター全体でストレージをパーティショニングおよびレプリケーションすることで、重要な状況でも高い耐障害性とデータの高可用性が提供されます。

<br>

6. コスト効率の高いストレージソリューション

適切な要件にNoSQLを選択すると、データの運用・管理において非常にコスト効率の高い方法の恩恵を受けられます。Catalystは、コスト効率をさらに向上させる革新的な価格設定戦略を通じて、NoSQLでのCRUD操作に最適な価格を提供しています。NoSQLは、TTL（Time To Live）属性を使用してアイテムの有効期限を設定することで、テーブルからアイテムを自動的に削除する方法も提供しており、手動削除のための不要な書き込み操作を省けます。

<br>

7. コンソール、サーバーサイドSDK、APIによるアクセスの容易さ

CatalystコンソールからプロジェクトのNoSQLテーブルを作成し、テーブルの設定と管理、データの追加とクエリを実行できます。NoSQLのデータ操作はJava、Node.js、Python SDKでも利用可能で、サーバーサイドロジックに簡単に組み込めます。Catalystでは、これらのNoSQL操作のための複数のAPIも利用できます。


--------------------------------------------------------------------------------
title: "NoSQLのコンポーネント"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.650Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/components/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLのコンポーネント

Catalyst NoSQLデータベースのアーキテクチャを理解し、操作方法を学ぶには、まずNoSQLデータベースを構成するコンポーネントを理解する必要があります。

### 基本コンポーネント
Catalyst NoSQLに関わる基本的なコンポーネントを以下に説明します。

#### 用語

<br>

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

<thead>
        <tr>
            <th class="w10p">コンポーネント名</th>
            <th class="w30p">説明</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>テーブル</td>
        <td>テーブルは、NoSQLがデータを格納する基本構造です。リレーショナルデータベースと同様に、テーブルはレコードまたはアイテムで構成されます。<br><br>
        以下に示すサンプルテーブルTravelは、訪問可能な旅行先のデータと、各場所の主要な情報を保持しています。</td>
    </tr>
    <tr>
        <td>属性</td>
        <td>属性は、テーブル内のデータ値の特性を表します。NoSQLの属性は、リレーショナルデータベースのフィールドやカラムに相当し、各属性は特定のデータ型のデータを保持します。<br><br>
        以下のサンプルテーブルTravelには、DestinationName、Distance、BestTimeToVist、Location、EstimatedCostの属性が含まれています。</td>
    </tr>
    <tr>
        <td>アイテム</td>
        <td>アイテムは、単一のデータポイントのデータを保持する属性のコレクションです。NoSQLのアイテムは、リレーショナルデータベースの行やレコードに相当し、異なる属性の値を含むことができます。<br><br>
        サンプルテーブルTravelでは、DestinationNameで一意に識別される各データコレクションがアイテムです。例えば、Distance、BestTimeToVisit、EstimatedCostの値のセットも含む「Honolulu」のレコードはアイテムです。同様に、異なる属性値を持つ「Prague」で識別されるレコードもアイテムです。<br><br>
        注意: Catalyst NoSQLでプロビジョニングされるアイテムの最大合計サイズは400 KBです。</td>
    </tr>
    <tr>
        <td>データ</td>
        <td>Catalyst NoSQLの用語では、テーブルのデータは、CatalystカスタムJSON形式で存在するすべての属性とアイテムで構成されます。<br><br>
        Travelテーブルの以下のJSONコードは、テーブルのデータを表しています。データの操作ヘルプセクションでは、カスタムJSONデータ形式とサポートされるデータ型について詳しく説明しています。</td>
    </tr>
</tbody>
</table>

<br>

#### サンプルテーブルの表現

テーブル名: 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
		}
 }
}



*Travel*テーブルは、CatalystカスタムJSON形式のシンプルなNoSQLテーブルを表しています。この構造にはネストされた属性と配列が含まれています: BestTimeToVistはリストデータ型（"L"）の配列として存在し、Location属性はCountryとContinentのキーを含むマップデータ型（"M"）のネストされた属性です。

注意: ここに示されているテーブルはCatalystカスタムJSON形式の表現です。このJSON形式で各サーバーサイドSDKのデータを構築するフォーマットは異なります。このテーブルに示されているCatalystカスタムJSON形式の一般的な構文、サポートされるデータ型とその表記については、このセクションを参照してください。

<br>

### テーブルキー

一般的なNoSQLアーキテクチャに従い、Catalyst NoSQLはクラスター全体のパーティション（シャードとも呼ばれる）にデータを格納します。これらのシャードは、ミラー内の多くのサーバーにレプリケーションすることもできます。複数のノードにまたがるこの分散ストレージにより、データセットが小さなチャンクに分割され、最適化が促進されます。

NoSQLテーブルでデータをクエリする際、特定のアイテムが格納されているパーティションを特定する必要があります。さらに、パーティション内をソートしてアイテムを見つけるためにも追加の作業が必要です。これらは、以下で説明するように、パーティションを識別またはソートするための固有のキーの助けを借りて実現されます。

#### 用語

<br>

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

<thead>
        <tr>
            <th class="w10p">コンポーネント名</th>
            <th class="w30p">説明</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>パーティションキー</td>
        <td>パーティションキーは、データアイテムが格納されている分散ストレージ内の論理パーティションを識別します。これらの論理パーティションは、ハッシュ関数を通じてバックエンドの物理ストレージノードにマッピングされます。<br><br>
        以下で説明するサンプルテーブルMenuでは、属性Categoryがパーティションキーです。</td>
    </tr>
    <tr>
        <td>ソートキー</td>
        <td>プライマリソートキーは、特定のパーティション内をソートしてデータアイテムを見つけ、データ内のパーティションキーに一致するアイテムが1つ以上ある場合はソート順で返します。これは、キーハッシュの範囲から識別することで行われます。Catalystでは、NoSQLテーブル作成時にオプションでソートキーを追加できます。<br><br>
        以下で説明するサンプルテーブルMenuでは、属性DishNameがソートキーとして使用されます。</td>
    </tr>
    <tr>
        <td>シンプルプライマリキー</td>
        <td>Catalyst NoSQLのシンプルプライマリキーは、パーティションキーのみを示します。<br><br>
        NoSQLテーブルにソートキーなしでパーティションキーのみを設定する場合、パーティションキーがテーブルのプライマリキーとして機能し、アイテムを一意に識別します。これは、リレーショナルデータベースのプライマリキーの概念と同様です。<br><br>
        前のセクションで説明したサンプルテーブルTravelでは、属性DestinationNameがプライマリキーとして使用されます。この属性はすべてのアイテムに存在する必要があり、この属性に同じ値を持つ2つのアイテムは存在できません。<br><br>
        ただし、以下で説明するサンプルテーブルMenuでは、パーティションキーCategoryはアイテムを一意に識別しません。同じ値を持つ複数のアイテムが存在できるためです。これは、Menuテーブルが複合プライマリキーを使用しているためです。
</td>
    </tr>
    <tr>
        <td>複合プライマリキー</td>
        <td>複合プライマリキーは、パーティションキーとソートキーの両方を含み、アイテムを一意に識別します。つまり、両方のキーの組み合わせがプライマリキーとして機能します。複合プライマリキーを使用したテーブルのクエリは、データが複数のパーティションにまたがるため、グローバルです。<br><br>
        パーティションキーが一意である必要があるシンプルプライマリキーとは異なり、ソートキーも定義する限り、パーティションキーに非一意の値を格納できます。<br><br>
        注意: テーブル内で同じパーティションキーを持つすべてのアイテムについて、ソートキーは一意である必要があります。
        以下で説明するサンプルテーブルMenuには、パーティションキーCategoryとソートキーDishNameが一緒にデータアイテム（料理）を一意に識別する複合プライマリキーが含まれています。</td>
    </tr>
    <tr>
        <td>追加ソートキー</td>
        <td>Catalyst NoSQLでは、複合プライマリキーの一部であるメインソートキー以外に、追加のソートキーを設定できます。<br><br>
        追加ソートキーは、メインソートキー以外の異なるキーに基づいてソートを実行する必要がある場合や、特定のアイテムのメインソートキーが不明な場合に使用されます。この場合、パーティションキーと追加ソートキーの組み合わせが複合プライマリキーとして使用されます。<br><br>
        追加ソートキーを使用したテーブルのクエリは、ローカルインデックスに類似しており、すべて同じパーティションキーと共に使用され、その特定のパーティション内のみでソートされます。<br><br>
        注意: Catalystでは、テーブルに対して最大5つの追加ソートキーを設定できます。
        以下で説明するサンプルテーブルMenuでは、属性PreparationTimeとCaloriesが追加ソートキーとして設定されています。</td>
    </tr>
</tbody>
</table>

<br>

#### サンプルテーブルの表現

テーブル名: 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>

Menuテーブルにはさまざまな属性が含まれており、Categoryがパーティションキー、DishNameがソートキー、PreparationTimeとCaloriesが追加ソートキーです。

注意: ここに示されているテーブルはCatalystカスタムJSON形式の表現です。このJSON形式で各サーバーサイドSDKのデータを構築するフォーマットは異なります。このテーブルに示されているCatalystカスタムJSON形式の一般的な構文、サポートされるデータ型とその表記については、このセクションを参照してください。

複合プライマリキーはデータクエリを強化します。このテーブルがシンプルプライマリキーのみ（つまりCategory（例:「Pizza」））で設定されている場合、クエリするとそのCategoryのすべてのアイテム（メニュー内のすべての「ピザ」）が取得されます。ただし、複合プライマリキー（つまりCategoryとDishName）で設定されているため、両方のキーでクエリすると、それらの値の一意のアイテム（例:「Pizza」と「Vegan」）が取得されます。

同様に、追加ソートキーは同じパーティション内でテーブルをクエリする際にさらなる柔軟性を提供します。追加ソートキーPreparationTimeをパーティションキーCategoryと組み合わせてテーブルをクエリできます（例:「Sandwich」と「20」）。

インデックスについて説明する前に、Catalyst NoSQLがすべてのテーブルに提供する特別な属性を理解しましょう。

<br>
 
### Time To Live（TTL）

Time To Live（TTL）は、特定の時点以降にCatalyst NoSQLテーブルのアイテムを自動的に削除する方法を提供します。テーブル作成時に、テーブル内で有効期限のタイムスタンプを保持する属性を設定できます。データ追加時に、テーブル内の各アイテムの有効期限タイムスタンプをUnixエポック時間形式で追加できます。Catalystは、有効期限を過ぎたテーブル内のアイテムを自動的に完全に削除し、手動更新の実行と書き込みスループットの消費を省けます。

TTL属性は、特定の時点以降に不要になるアイテムや、有効期間が短いアイテムの削除に便利です。有効期限を過ぎた後にCatalystが自動的に削除するアイテムは、テーブルおよびインデックスが作成されているすべての場所から削除されます。

Catalystは、TTL属性値が期限切れを示すアイテムを確認するために、24時間ごとに組み込みスケジューラを実行します。このチェックは、すべてのプロジェクトのすべてのNoSQLテーブルで実行され、有効期限を過ぎたアイテムは完全に削除されます。

例を使ってTTLを理解しましょう。前のセクションで示したMenuテーブルに、TTLタイムスタンプを格納するためのExpiryという名前の属性を作成すると仮定します。次に、テーブル内のすべてのアイテムの有効期限タイムスタンプを以下のように定義できます。

#### サンプルテーブルの表現

テーブル名: 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>

注意: ここに示されているテーブルはCatalystカスタムJSON形式の表現です。このJSON形式で各サーバーサイドSDKのデータを構築するフォーマットは異なります。このテーブルに示されているCatalystカスタムJSON形式の一般的な構文、サポートされるデータ型とその表記については、このセクションを参照してください。

注意事項:

* NoSQLテーブルのアイテムのTTL属性値は、必要に応じていつでも更新できます。Catalystの組み込みスケジューラが実行される際、最新のTTL値に基づいてアイテムを識別・処理します。

* 指定された値に基づいて、必要に応じてアイテムのTTL属性を削除することもできます。


--------------------------------------------------------------------------------
title: "テーブルの作成と管理"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.651Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/create-manage-tables/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLでのテーブルの作成と管理

それでは、CatalystコンソールからのNoSQLテーブルの操作について説明します。

注意: テーブルの追加や管理など、このセクションで行う設定は、リモートコンソールからのみ実行でき、SDKやAPIからは実行できません。データ操作は、サーバーサイドSDKおよびAPIから実行できます。

コンソールのCloudScaleサービスから、CatalystプロジェクトのNoSQLにアクセスできます。

### テーブルの作成

プロジェクトでCatalyst NoSQLにテーブルを作成するには:

1. コンソールでCloudScaleサービスに移動し、NoSQLをクリックします。

<br>

2. Create Tableをクリックします。

3. テーブル名を入力します。キー名を入力し、キーのデータ型を選択して、パーティションキーを設定する必要があります。

注意: パーティションキーは、String、Numeric、またはBinaryのデータ型でのみ設定できます。サポートされるデータ型とその表記については、このセクションを参照してください。



注意: テーブルに設定したパーティションキーは、設定後に変更または削除できません。また、データアイテムからパーティションキー属性を削除することもできません。これはプライマリキーであるため、すべてのアイテムにこの値を含める必要があります。<br>

4. テーブルに複合プライマリキーを含めるため、オプションでソートキーを設定できます。「Include Sort Key?」でYesを選択してください。パーティションキーのみ（シンプルプライマリキー）の場合は、Noを選択してください。<br>

    ソートキーを含める場合は、キー名を入力し、キーのデータ型を選択します。

注意:

* テーブルのソートキーは、設定後に変更または削除できません。

* ソートキーは、String、Numeric、またはBinaryのデータ型でのみ設定できます。サポートされるデータ型とその表記については、このセクションを参照してください。

<br>

5. テーブルに追加ソートキーを含める必要がある場合は、キー名を入力しデータ型を選択して追加できます。（+）をクリックして複数のキーを追加できます。



注意:

* テーブルの追加ソートキーは、設定後に変更または削除できません。

* Catalystでは、テーブルに最大5つの追加ソートキーを設定できます。

* 追加ソートキーは、String、Numeric、またはBinaryのデータ型でのみ設定できます。サポートされるデータ型とその表記については、このセクションを参照してください。

<br>

6. テーブルのTTLタイムスタンプを格納する属性を設定します。テーブル内の各アイテムに対してこの属性の値を追加し、有効期限を指定できます。



注意: テーブルのTTL属性は設定後に無効にできます。ただし、属性の名前を変更したり、一度無効にした後に再度有効化/設定することはできません。<br>

7. テーブルの設定が完了したら、Createをクリックします。

NoSQLテーブルが作成され、プロジェクトのTablesの下にリスト表示されます。Catalystはテーブルの一意のテーブルIDを自動的に作成し、SDKおよびAPIアクションの実行時にテーブルを参照するために使用できます。

テーブルには3つのセクションがあります: Overview、Indexes、Data。

<br>

### 概要セクション

Overviewセクションでは、テーブルの設定と詳細の概要を確認できます。一意のテーブルID、作成者の詳細、TTL属性などの重要な情報がすべて表示されます。



Storage Sizeはテーブルのサイズを示します。空のテーブルは0バイトで、データアイテムも0です。Catalystは24時間ごとに組み込みスケジューラを実行し、各テーブルのStorage SizeとNo. of Itemsを計算・更新します。

テーブルに設定されたパーティションキー、ソートキー、追加ソートキーも表示できます。No. of Indexesは、テーブルから作成されたインデックスの数を示します。ここでViewをクリックすると、Indexesセクションに移動します。

<br>

### テーブルの編集

NoSQLのテーブルを編集して、テーブル名の変更やテーブルに設定されたTTL属性の無効化が可能です。ただし、設定済みのパーティションキー、ソートキー、追加ソートキー、およびTTL属性の名前は変更できません。

NoSQLテーブルを編集するには:

1. テーブルのOverviewセクションから省略記号アイコンをクリックし、Editをクリックします。

<br>

2. テーブルの必要な詳細を変更し、Updateをクリックします。



注意: TTL属性を無効にすると、テーブルに対して再度有効化または設定することはできません。TTL属性を無効にすると、Catalystはテーブルから有効期限切れのデータアイテムを自動的に削除しなくなります。

<br>

### テーブルの削除

NoSQLでテーブルとそのすべてのデータを完全に削除するには、以下の手順で行います:

1. テーブルのOverviewセクションから省略記号アイコンをクリックし、Deleteをクリックします。

<br>

2. 確認ポップアップでDeleteをクリックします。




--------------------------------------------------------------------------------
title: "クエリ検索"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.651Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/query-search/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLでのクエリ検索

### 概要

Catalystでは、コンソール、Java、Node.js、PythonのサーバーサイドSDK、またはAPIを通じて、NoSQLのテーブルデータを読み取るクエリ検索を実行できます。コンソールのDataセクションには、データを検索し結果を表示するクエリセクションが含まれています。

NoSQLのクエリ操作は、データストレージのパーティションにスコープされます。つまり、テーブルがシンプルプライマリキーで設定されている場合、パーティションキーのみに基づいてパーティション内のアイテムを検索できます。テーブルが複合プライマリキーで設定されている場合、プライマリキーとソートキーの組み合わせを使用して検索が行われます。また、テーブルに設定した追加ソートキーをパーティションキーの組み合わせで利用してクエリ検索を実行することもできます。テーブルキーについてはこのページを参照してください。

クエリ検索は、テーブルまたはテーブルのインデックスをベースに実行できます。これにより、Catalystに適切なパーティションを検索し、検索に適切なプライマリキーをプロビジョニングするよう指示されます。

<br>

### サポートされる演算子

Catalystは、クエリ実行に使用できるいくつかの演算子をサポートしています。これらの演算子は、プライマリソートキーおよび追加ソートキーでのみ使用できます。ソートキーのデータ型に応じて、サポートされる演算子は異なります。

注意: パーティションキーには「EQUALS」演算子のみ使用できます。以下にリストされている演算子は、インデックスのソートキー、またはテーブルのソートキーと追加ソートキーでのみ使用できます。

<br>

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

<thead>
        <tr>
            <th class="w10p">ソートキーのデータ型</th>
            <th class="w10p">サポートされる演算子</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>

注意: サポートされるすべての演算子はSDKおよびAPI操作で利用可能ですが、これらのサポートされる演算子の一部はコンソール検索では利用できません。詳細については、各SDKおよびAPIヘルプドキュメントを参照してください。

<br>

### クエリ検索の実行

CatalystコンソールからNoSQLテーブルのデータを読み取るクエリ検索を以下の方法で実行できます:

1. NoSQLのテーブルのDataセクションに移動します。


<br>

2. 上部のドロップダウンから、検索を実行するテーブル名またはいずれかのインデックスを選択できます。Catalystはテーブルとすべてのインデックスをリスト表示します。


<br>

3. テーブルがシンプルプライマリキーで設定されている場合、パーティションキーの値を入力して検索します。パーティションキーに設定されたデータ型が自動的に表示されます。

    テーブルが複合プライマリキーで設定されている場合、パーティションキーの値を入力し、次にソートキーのリストから必要な演算子を選択して検索する値を入力します。メインのソートキーまたは設定されている追加ソートキーのいずれかを選択できます。ソートキーに設定されたデータ型が自動的に表示されます。



注意: パーティションキーには[「EQUALS」演算子](#supported-operators)のみ使用できます。プライマリまたは追加ソートキーのデータ型に応じて、適切な演算子が選択可能になります。<br>

4. 「Enable this to search using ascending sort」チェックボックスをオンにして、検索結果を昇順で表示することもできます。デフォルトでは降順ソートが使用されます。選択したテーブルまたはインデックスにソートキーが設定されていない場合、取得されるデータのソート順はテーブルのパーティションキーに基づきます。

5. クエリパラメータを設定した後、Searchをクリックします。

<br>

クエリ結果がこのセクションに表示されます。結果が見つからない場合、Catalystは適切なメッセージを表示します。



前のセクションで説明したように、フィルターオプションを使用して表示する列を選択したり、データをJSONとして表示したりできます。


--------------------------------------------------------------------------------
title: "サードパーティからの移行"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.651Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/third-party-migration/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# サードパーティからの移行

### はじめに

Catalystは、サードパーティソースからNoSQLデータベースを移行する機能を提供しています。この移行はNoSQLタイプのデータベースのみサポートされており、リレーショナルやその他のデータベースはサポートされていません。

外部ソースからデータベースを移行する機能により、NoSQLのニーズに合わせてCatalystに簡単に切り替えることができます。外部環境でCatalystアプリケーションやマイクロサービス用のNoSQLデータベースを維持していた場合、Catalystエコシステム内に統合し、すべてのセットアップをここで管理できるメリットがあります。

Catalystコンソールから数回のクリックで移行を実行できます。データベースの移行に必要なのは、サードパーティデータベースにアクセスするための必要な認証情報の提供と、移行するテーブルの選択だけです。Catalystは移行プロセス中にダウンタイムやレイテンシの問題がゼロであることを保証します。データベースの移行後、プロジェクト内のコンソールのNoSQLセクションでテーブルにアクセスできます。

注意: NoSQLのストレージおよびCRUD操作の料金情報については、料金ページを参照してください。

<br>

Catalystは現在、以下のサードパーティソースからの移行をサポートしています: AWS DynamoDB


利用できる移行オプションは2つあります:

* メタデータの移行: このオプションは、サードパーティソースからテーブルのスキーマとメタデータのみを移行します。これはCatalystの開発環境でのみ利用可能です。

* データの移行: このオプションは、サードパーティソースからテーブルのデータと設定を一緒に移行します。これはCatalystの本番環境でのみ利用可能です。

必要な適切なオプションを選択し、適切な環境から移行を実行できます。

<br>

## AWS DynamoDBからの移行

AWSからの移行を実行するには、CatalystにAWSアクセスキー認証情報を設定する必要があります。AWSアクセスキー認証情報により、CLIまたはAPIを通じてAWSリソースにアクセスできます。

AWSアクセスキーは2つの部分で構成されています: Access Key IDとSecret Access Key。両方をCatalystに設定し、AWSアカウントが属するAWSリージョンの情報も提供する必要があります。

注意: AWSアカウントのアクセスキー認証情報の作成・取得方法、およびアカウントのリージョンの確認方法については、上記のリンクを参照してください。

<br>

### DynamoDBからのメタデータの移行

Catalystの開発環境で作業中に、AWS DynamoDBのテーブルのメタデータを移行できます。これはCatalystのデフォルト環境であるため、この移行オプションにはデフォルトでアクセスできます。データベースに新しいデータを作成し、テーブル設定のみが必要な場合に、このオプションを使用できます。

メタデータの移行では、選択したテーブルのテーブル設定とインデックス設定（設定済みのパーティションキーとソートキーなど）、およびCatalyst NoSQLがサポートするその他のメタ情報や設定が移行されます。

プロジェクトでAWS DynamoDBからCatalyst NoSQLにメタデータを移行するには:

1. コンソールの開発環境でCloudScaleセクションからNoSQLに移動し、Third-Party Meta Migrationをクリックします。



<br>

2. ポップアップが開きます。AWSアカウントのAccess Key ID、Secret Access Key、およびリージョンを入力します。次に、Nextをクリックします。


<br>

3. DynamoDBからメタデータを移行するテーブルを選択します。次に、Importをクリックします。
	


<br>

Catalystが移行プロセスをスケジュールします。移行完了までの時間は、テーブル数とそのサイズによって異なります。



<br>

テーブルの移行後、通知が届きます。



<br>

コンソールを更新すると、プロジェクト内のインポートされたテーブルにアクセスできます。設定付きのインポートされたテーブルがNoSQLに表示され、データの追加に進むことができます。



<br>

### DynamoDBからのデータの移行

AWS DynamoDBのテーブルのデータを移行するには、まずCatalystの本番環境にアクセスする必要があります。Catalystプロジェクトを本番環境にデプロイしたことがない場合は、まずデプロイして本番環境を有効にする必要があります。本番環境へのプロジェクトのデプロイについては、このヘルプページを参照してください。

プロジェクトの本番環境にアクセスできるようになったら、コンソールのヘッダーから本番環境に切り替えることができます。



データベース全体を移行する必要がある場合は、スキーマと一緒にデータを移行するオプションを使用できます。
これにより、選択したテーブルのデータと、選択したテーブルの設定およびメタデータがインポートされます。これには、選択したテーブルのテーブル設定とインデックス設定（設定済みのパーティションキーとソートキーなど）、およびCatalyst NoSQLがサポートするその他のメタ情報や設定が含まれます。

<br>

プロジェクトでAWS DynamoDBからCatalyst NoSQLにデータを移行するには:

1. コンソールの本番環境でCloudScaleセクションからNoSQLに移動し、Third-Party Data Migrationをクリックします。



<br>

2. ポップアップが開きます。AWSアカウントのAccess Key ID、Secret Access Key、およびリージョンを入力します。次に、Nextをクリックします。



<br>

3. DynamoDBからデータを移行するテーブルを選択します。次に、Importをクリックします。


	
Catalystが移行プロセスをスケジュールします。移行完了までの時間は、テーブル数とデータ量に基づくサイズによって異なります。



<br>

テーブルの移行後、通知が届きます。



<br>

プロジェクト内でデータ付きのインポートされたテーブルにアクセスできます。アイテムの更新や削除、必要に応じてデータの処理ができます。




## インデックス



--------------------------------------------------------------------------------
title: "はじめに"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.652Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/indexing/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLでのインデックス

Catalyst NoSQLは、NoSQLテーブルにインデックスを作成する機能を提供しており、プライマリキーを使用せずにテーブルデータに対して代替クエリを実行できます。つまり、パーティションキーとソートキー以外の属性でセカンダリインデックスを作成・利用してデータアイテムを検索できます。

インデックスは、テーブル内の従来とは異なる属性を優先する必要があるシナリオで役立ち、データ取得操作に利便性と柔軟性を追加します。インデックスを使用したクエリは、データ読み取りプロセスを高速化し、効率を促進します。また、メインテーブルに影響を与えることなく、要件に基づいてテーブルのインデックスを変更または削除することもできます。

### インデックスのアーキテクチャ

Catalyst NoSQLのインデックスは、テーブル全体とテーブルデータが格納されているすべてのパーティションにまたがります。このクロスパーティションまたはグローバルインデックス機能は、テーブルのすべてのパーティションキーに対してクエリを実行できるため、非常に有益です。

Catalystでは、テーブルに最大20のインデックスを作成できます。作成する各インデックスに個別のパーティションキーとソートキーを設定できます。インデックスがグローバルであるため、メインテーブルで設定されたものとは異なるパーティションキーとソートキーを設定できます。

本質的に、インデックスはデータクエリのさまざまな要件に対応するために、異なるパーティションキーとソートキーで作成されたメインテーブルのコピーと見なすことができます。アーキテクチャの観点では、テーブルにインデックスが作成されると、メインテーブルと同じパーティショニングルールが適用された異なるストレージノードにそのコピーが格納されます。そのため、セカンダリインデックスに基づいてクエリを実行しても、テーブルのすべての属性とデータにアクセスできます。

注意: ベーステーブルのデータを追加、更新、または削除すると、Catalystは自動的にインデックスを更新します。

<br>

### インデックスの種類

Catalystは、NoSQLでテーブルをインデックスする3つの方法を提供しています:

* すべての属性のインデックス: テーブル内のすべての属性のインデックスを作成します。このオプションを選択すると、Catalystは基本的にすべてのテーブル属性を複製し、インデックスに設定したパーティションキーに基づいて格納します。

* キーのみのインデックス: テーブル内のパーティションキー、ソートキー、および追加ソートキー属性（存在する場合）のみをインデックスします。これらのキー属性は、インデックスに設定したパーティションキーに基づいて格納されます。

* 特定の属性のインデックス: 選択したテーブルの特定の属性をインデックスします。選択された属性は複製され、インデックスに設定したパーティションキーに基づいて格納されます。

インデックスに基づいてクエリを実行すると、テーブルとインデックスのパーティションキーおよびソートキー属性が、設定した種類に基づく他の属性とともに返されます。

例を使ってインデックスをよりよく理解しましょう。前のセクションで説明したMenuテーブルを更新して以下に示します。

#### サンプルテーブルの表現

テーブル名- 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
 	}
}
}



注意: ここに示されているテーブルはCatalystカスタムJSON形式の表現です。このJSON形式で各サーバーサイドSDKのデータを構築するフォーマットは異なります。このテーブルに示されているCatalystカスタムJSON形式の一般的な構文、サポートされるデータ型とその表記については、このセクションを参照してください。

このテーブルに以下の設定でPricingというインデックスを作成すると仮定します:

* パーティションキー: Cost
* ソートキー: DiscountPercentage
* インデックスの種類: 特定の属性（CaloriesとPreparationTime）

以下は作成されたインデックスの表現です。

#### サンプルインデックスの表現

インデックス名- 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
 }
	}
}


注意: インデックスのパーティションキーを含まないデータアイテムは、インデックスの対象から除外されます。この例では、メインテーブルの「Pizza」と「Vegan」で識別されるアイテムは、インデックスのパーティションキーであるCostの値を含んでいないため、インデックスされていません。

インデックスPricingに基づいてクエリを実行すると、Catalystは属性Costに対してアイテムを検索し、一致する結果が複数ある場合は属性DiscountPercentageに基づいて結果をソートします。選択された属性（CaloriesとPreparationTime）は、テーブルとインデックスのプライマリキーとともに、一致するアイテムのクエリで返されます。


--------------------------------------------------------------------------------
title: "インデックスの作成と管理"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.652Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/indexing/create-manage-indexes/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# インデックスの作成と管理

CatalystコンソールでNoSQLテーブルのインデックスの作成と操作方法を見ていきましょう。

注意: インデックスの作成や管理など、このセクションで行う設定は、リモートコンソールからのみ実行でき、SDKやAPIからは実行できません。データ操作は、サーバーサイドSDKおよびAPIから実行できます。

### インデックスの作成

プロジェクトでNoSQLテーブルのインデックスを作成するには:

1. NoSQLコンポーネントからテーブルのIndexesセクションに移動し、Add Indexをクリックします。



2. インデックスの名前を入力します。キー名を入力し、キーのデータ型を選択して、インデックスのパーティションキーを設定する必要があります。



注意: インデックスのパーティションキーは、設定後に変更または削除できません。

3. インデックスにソートキーが必要な場合は、「Include Sort Key?」でYesを選択してオプションで設定できます。パーティションキーのみの場合は、Noを選択してください。ソートキーを含める場合は、キー名を入力し、キーのデータ型を選択します。

注意: インデックスのソートキーは、設定後に変更または削除できません。

4. インデックスの属性タイプを選択します。



Include Columnsを選択した場合、インデックスする属性を指定します。Catalystでは、ウィンドウ内で複数の属性を追加できます。（-）をクリックして属性を削除できます。



5. インデックスの設定が完了したら、Createをクリックします。

NoSQLテーブルのインデックスが作成され、Indexesセクションにリスト表示されます。Catalystはインデックスの一意のインデックスIDを自動的に作成し、SDKおよびAPIアクションの実行時にインデックスを参照するために使用できます。

<br>

### インデックスセクション

Indexセクションでは、特定のテーブルに設定されたすべてのインデックスとその詳細の概要を確認できます。一意のインデックスID、設定されたパーティションキーとソートキー、インデックスのサイズとアイテム数などの重要な情報が表示されます。



空のテーブルは0バイトで、データアイテムも0です。Catalystは24時間ごとに組み込みスケジューラを実行し、各インデックスのStorage SizeとNo. of Itemsを計算・更新します。

特定の属性で作成されたインデックスの場合、インデックスセクションにインデックスされたすべての属性を表示するViewボタンが表示されます。


 
クリックして属性を表示できます。



<br>

### インデックスの編集

NoSQLのテーブルに作成されたインデックスを編集して、インデックス名を変更できます。ただし、設定済みのパーティションキー、ソートキー、属性タイプは変更できません。

テーブルのインデックスを編集するには:

1. Indexesセクションでインデックスの省略記号アイコンをクリックし、Editをクリックします。

<br>

2. インデックス名を変更し、Updateをクリックします。



<br>

### インデックスの削除

NoSQLのテーブルのインデックスを完全に削除できます。これにより、ストレージから削除され、インデックスに基づくクエリを実行できなくなります。

NoSQLテーブルのインデックスを完全に削除するには:

1. Indexesセクションでインデックスの省略記号アイコンをクリックし、Deleteをクリックします。

<br>

2. 確認ポップアップでDeleteをクリックします。




## データの操作



--------------------------------------------------------------------------------
title: "はじめに"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供するフルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.652Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/working-with-data/introduction/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLでのデータ操作


NoSQLのデータ単位は*アイテム*と呼ばれ、各データアイテムはリレーショナルデータベースのレコードや行に相当します（この用語で説明しています）。Catalystでは、Java、Node.js、PythonのサーバーサイドSDKおよびAPIを使用して、NoSQLテーブルでCRUD操作を実行できます。

注意: CatalystコンソールからもCRUD操作を実行して、NoSQLでのデータ操作をテストできます。ただし、コンソールからはテーブルに1つのアイテムのみ追加できます。

Catalystは、次のセクションで説明するCatalystカスタムJSON形式でデータを追加する機能を備えた、キーバリューペアベースのドキュメント型データストレージをサポートしています。

注意: テスト用として、Catalystコンソールからのみ国際標準構文に従った通常のJSON形式でデータを追加できます。ただし、SDKおよびAPIで作業する場合は、カスタムJSON形式でのみデータを追加できます。

Catalystでは、JSONデータで複数のデータ型を使用でき、NoSQL属性をそれらで設定できます。テーブルにデータを追加または更新する際に、属性に適切なデータ型を宣言できます。

<br>

### サポートされるデータ型

Catalyst NoSQLの属性でサポートされるデータ型を以下に示します。

<br>

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

<thead>
        <tr>
            <th class="w10p">データ型</th>
            <th class="w10p">表記</th>
            <th class="w30p">説明</th>
        </tr>
</thead>
<tbody>
    <tr>
        <td>String</td>
        <td>S</td>
        <td>文字のシーケンスを格納</td>
    </tr>
    <tr>
        <td>Number</td>
        <td>N</td>
        <td>数値を格納</td>
    </tr>
    <tr>
        <td>Binary</td>
        <td>B</td>
        <td>バイトのシーケンスを表すバイナリ数値を格納</td>
    </tr>
    <tr>
       <td>Boolean</td>
        <td>BOOL</td>
        <td>trueまたはfalseのブール値を格納</td>
    </tr>
    <tr>
        <td>Set of String</td>
        <td>SS</td>
        <td>1つ以上の一意の文字列を格納するセット</td>
    </tr>
    <tr>
        <td>Set of Numbers</td>
        <td>SN</td>
        <td>数値のコレクションを格納するセット</td>
    </tr>
    <tr>
        <td>Set of Binary</td>
        <td>SB</td>
        <td>バイナリ数値のコレクションをバイトセットとして格納するセット</td>
    </tr>
    <tr>
        <td>List</td>
        <td>L</td>
        <td>同じデータ型の順序付き要素を格納</td>
    </tr>
    <tr>
        <td>Map</td>
        <td>M</td>
        <td>キーバリューペア要素の順序なしコレクションを格納</td>
    </tr>
    <tr>
        <td>Null</td>
        <td>NULL</td>
        <td>NULLという値のみを格納</td>
    </tr>
</tbody>
</table>

NoSQLでデータを追加する際のこれらのデータ型の表記と使用方法については、[CatalystカスタムJSON形式セクション](#the-catalyst-custom-json-format)を参照してください。

注意: 

* コンソールからNoSQLのテーブルまたはインデックスを設定する場合、CatalystではテーブルのプライマリキーにStringまたはNumberの2つのデータ型のうちの1つのみを選択できます。これにはパーティションキー、ソートキー、追加ソートキーが含まれます。

* NoSQLテーブルにデータを追加または更新する際は、宣言したデータ型に一致する適切な値を属性に常に追加するようにしてください。データ型と値の不一致はエラーをスローします。

<br>

### CatalystカスタムJSON形式

CatalystカスタムJSONは、CatalystがNoSQLで処理できるJSONデータの形式です。構文は標準JSON形式に似ていますが、各属性に設定された[データ型](#supported-data-types)の指定が追加されています。

CatalystカスタムJSON形式を理解するために、サンプルテーブルを見てみましょう。

#### サンプルテーブルの表現

テーブル名- 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"
 			}
 		]
  	}
  } 
}


*Employees*テーブルには、Location属性の下にネストされたJSONプロパティと、配列値を持つ属性Clubsが含まれています。このテーブルでは、各属性は設定されたデータ型で表記されています。例えば、EmpIDとYearOfJoiningにはN（Number）、FirstNameとLastNameにはSが使用されています。ブール属性PriorExperienceはBOOLとして表記されています。

使用可能なすべてのデータ型とその表記については、[サポートされるデータ型セクション](#supported-data-types)を参照してください。

#### 重要な注意事項:

* テーブルのプライマリキー（パーティションキーとソートキー）は、テーブルにデータを追加または更新するためのアイテムを構築する際にルートに存在する必要があります。ここに示されている形式は表現のみです。このJSON形式で各サーバーサイドSDKのデータを構築するフォーマットは異なります。

* テスト用として、CatalystコンソールからNoSQLテーブルのデータを標準JSON形式またはCatalystカスタムJSON形式のいずれかで追加または更新できます。

* Java、Node.js、Pythonのサーバー固有のSDK、またはAPIを通じてNoSQLテーブルにデータを追加または更新する場合は、CatalystカスタムJSON形式でのみ行えます。SDKヘルプリソースには、そのプログラミング環境でのデータアイテムの構築と挿入のフォーマットと例が含まれています。

* コンソールからデータを追加または更新する際に標準JSON形式を使用する場合、テーブルまたはインデックスの作成時にプライマリキー属性に関連付けられたデータ型が自動的に処理されます。その他のすべての属性については、提供された値に基づいてCatalystがデータ型を自動的に認識します。


--------------------------------------------------------------------------------
title: "データの追加と管理"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。NoSQLテーブルでのデータの作成、管理、クエリを簡単に行い、Java、Node.js、PythonでCRUD操作を実行できます。"
last_updated: "2026-08-17T13:08:49.652Z"
source: "https://docs.catalyst.zoho.com/ja/cloud-scale/help/nosql/working-with-data/add-manage-data/"
service: "Cloud Scale"
--------------------------------------------------------------------------------


# NoSQLテーブルでのデータの追加と管理

### 概要

このセクションでは、Catalyst NoSQLでのCRUD操作の実行、およびCatalystコンソールからのデータ管理について説明します。コードまたはAPIを通じてデータ操作を行う場合は、Java、Node.js、Python SDKおよびAPIドキュメントを参照してください。

Catalyst NoSQLテーブルでデータを追加または更新する際に覚えておくべきポイントをいくつか示します：

* シンプルプライマリキーで設定されている場合、テーブルの設定済みパーティションキーの値が各データ項目に存在する必要があります。複合プライマリキーの場合、パーティションキーとソートキーの両方の値が各データ項目に存在する必要があります。

* テーブルのパーティションキーとソートキーに設定されたデータ型は、それらの属性の値に指定するデータ型と一致する必要があります。

* テーブルでデータを追加または更新する際に、テーブルのパーティションキーとソートキーのデータ型やそれらに関連付けられた属性を変更することはできません。

* Catalyst NoSQLでプロビジョニングされるアイテムの最大合計サイズは400 KBです。

<br>

### テーブルへのデータ追加

テストのためにCatalystコンソールからNoSQLテーブルにデータを追加するには：

1. NoSQLコンポーネントからテーブルのDataセクションに移動し、Add Dataをクリックします。



<br>

2. テーブルにデータを追加できるポップアップが表示されます。Catalystはデータのテンプレートを表示し、カスタムおよび標準JSON形式の両方で、テーブルに設定されたパーティションキーとソートキーが含まれます。

注意: コンソールからテーブルに追加できるのは1つのアイテムのみです。これは、コンソールで提供されるデータ操作がテスト目的のみであるためです。


<br>

トグルボタンを使用して標準JSONビューとカスタムJSONビューを切り替えることができます。ただし、カスタム形式に切り替えるには、標準形式のデータが特定の条件を満たす必要があります。これについては以下で説明します。



<br>

3. いずれかの形式でテーブルのデータを追加し、Createをクリックします。
	
Custom JSON Format:



Standard JSON Format:


<br>

#### JSONビュートグルボタンが無効になる条件

特定のケースでは、コンソールでデータを追加または更新する際に標準JSONとカスタムJSON形式を切り替えることができません。これには以下が含まれます：

1. 属性のデータ型が無効であるか、Catalystでサポートされていない場合

2. JSONのキーに指定された値が無効な場合

3. 追加されたJSONコードが無効であるか、構文エラーまたは論理エラーが含まれている場合

4. データは有効だが、標準JSONビューでレンダリングできない特定のサポートされているデータ型が含まれている場合。例えば、SS（文字列セット）やSN（数値セット）はレンダリングできませんが、指定したデータはテーブルに追加されます。

NoSQLテーブルにデータを追加すると、簡単に閲覧できるようにDataセクションに表形式で表示されます。



注意: テーブルデータはDataセクションに永続的に表示されません。このセクションでクエリを実行することでのみテーブルデータを表示できます。

クエリ実行時またはコンソールからデータを追加した直後に、右下隅のFilter iconを使用して表示する列をフィルタリングできます。必要な列を選択し、Applyをクリックします。



これにより、選択した列が表示されます。



<br>

#### テーブルデータをJSONで表示

1. テーブルに対する省略記号アイコンをクリックすると、テーブルデータをJSON形式で表示できます。



<br>

2. オプションからView JSONをクリックします。



これにより、テーブルデータがCatalystカスタムJSON形式で表示されます。



<br>

### テーブルのデータ更新

テストのためにコンソールからNoSQLテーブルデータを簡単に更新できます。データ追加で説明したすべての仕様と制約は、データ更新操作にも適用されます。

注意: コンソールからテーブルのデータを更新すると、テスト目的であるため、既存のデータが実質的に上書きされます。ただし、SDKを通じてコードから、またはAPIを通じてデータを更新する場合は、CRUD操作の標準的な更新プロセスが適用されます。

プロジェクトのNoSQLテーブルのデータを更新するには：

1. テーブルに対する省略記号アイコンをクリックし、Editをクリックします。



<br>

2. 標準またはカスタムJSON形式でデータを更新し、Updateをクリックします。



<br>

### テーブルのデータ削除

テスト目的でNoSQLテーブルに追加したデータを完全に削除するには：

1. テーブルに対する省略記号アイコンをクリックし、Deleteをクリックします。



2. 確認ポップアップでDeleteをクリックします。




---

## API Reference — NoSQL

--------------------------------------------------------------------------------
title: "新規アイテムの挿入"
description: "このAPIを使用すると、NoSQLテーブルに新しいアイテムを挿入できます。"
last_updated: "2026-08-17T13:08:49.655Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/insert-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# NoSQL

Catalyst NoSQLは、アプリケーションの半構造化、非構造化、および異種データを保存できるフルマネージドの非リレーショナルNoSQLデータストレージ機能です。Catalystは、キーバリューペアベースのJSON形式でのドキュメントタイプのデータストレージをサポートしています。

Catalyst NoSQL APIを使用すると、NoSQLテーブルでCRUD操作を実行できます。アイテムの挿入、更新、削除、取得、およびテーブルやテーブルのインデックスに対するクエリの実行が可能です。


# アイテムの挿入

### 説明

このAPIを使用すると、プロジェクト内のNoSQLテーブルに新しいアイテムを挿入できます。テーブルは一意のIDまたは名前で参照されます。

カスタムJSON形式でデータを渡すことで、条件を指定してもしなくてもアイテムを挿入できます。

注意: テーブルは既に作成されている必要があります。コンソールからNoSQLテーブルを作成できます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.item.INSERT



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

 テーブルに挿入するメインデータを含みます。アイテムはカスタムJSON形式で挿入する必要があります。テーブルがシンプルなプライマリキーで構成されている場合は、パーティションキーを指定します。テーブルが複合プライマリキーで構成されている場合は、パーティションキーとソートキーの両方を指定します。  

 テーブルの既存データが取得され、この条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。条件を初期化するには3つの方法があります：


 2つの組み込み関数があります：属性の存在を確認するために使用できるattribute_existと、指定された属性名が指定された型に属するかどうかを確認するために使用できるattribute_typeです。 

 直接比較操作を実行するために使用します。サポートされる演算子：contains、not_contains、begins_with、ends_with、in、not_in、between、not_between、equals、not_equals、greater_than、less_than、greater_equal、less_equal。  

2つ以上の条件を組み合わせるために使用します。サポートされるグループ演算子：and、or。   

条件の結果を否定するために使用します。    

### レスポンス詳細

レスポンスには、挿入操作のステータスと、設定されている場合はtable_name、partition_key、sort_keyなど挿入されたアイテムの詳細が返されます。







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: "アイテムの更新"
description: "このAPIを使用すると、NoSQLテーブル内のアイテムを更新できます。"
last_updated: "2026-08-17T13:08:49.656Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/update-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# アイテムの更新

### 説明

このAPIを使用すると、プロジェクト内のNoSQLテーブルの既存データからアイテムを更新できます。テーブルは一意のIDまたは名前で参照されます。

カスタムJSON形式で、条件を指定してもしなくても更新する属性を渡すことができます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.item.UPDATE



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

テーブルのパーティションキーとソートキーを示します。  

 更新する属性とその値を示します。更新にはPUT（アイテム内に新しい属性を追加）とDELETE（アイテムから属性を削除）の2種類があります。attribute_pathは、実際の操作が行われるアイテム内のパスを示します。更新する値には2種類があります：


更新する実際の値。 

 使用できる4つの関数があります：<br> if_not_exists - 属性の存在を確認し、存在しない場合に値を宣言します。
append_list - リストにデータを追加します。
add - 既存の値に値を追加するか、セットに要素を追加します。
reduction - 既存の値から値を減算するか、セットから要素を削除します。 

 
 テーブルの既存データが取得され、この条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。条件を初期化するには3つの方法があります：


 2つの組み込み関数があります：属性の存在を確認するために使用できるattribute_existと、指定された属性名が指定された型に属するかどうかを確認するために使用できるattribute_typeです。 

 直接比較操作を実行するために使用します。サポートされる演算子：contains、not_contains、begins_with、ends_with、in、not_in、between、not_between、equals、not_equals、greater_than、less_than、greater_equal、less_equal。  

2つ以上の条件を組み合わせるために使用します。サポートされるグループ演算子：and、or。   

条件の結果を否定するために使用します。    


### レスポンス詳細

レスポンスには、挿入操作のステータスと、設定されている場合はtable_name、partition_key、sort_keyなど更新されたアイテムの詳細が返されます。







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: "アイテムの取得"
description: "このAPIを使用すると、NoSQLテーブルから既存のアイテムを取得できます。"
last_updated: "2026-08-17T13:08:49.656Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/fetch-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# アイテムの取得

### 説明

このAPIを使用すると、プロジェクト内のNoSQLテーブルからアイテムを取得できます。テーブルは一意のIDまたは名前で参照されます。

取得するアイテムの属性を指定でき、マスターまたはスレーブクラスターから取得する必要があるかどうかも指定できます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.item.READ



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

テーブルのパーティションキーとソートキーを示します。  

返される属性のリスト。  

読み取りをマスターまたはスレーブから行うかを宣言します。falseに設定すると、スレーブからクエリされます。許容される値：true、false。  


### レスポンス詳細

レスポンスには、取得操作のステータスと取得されたアイテムが返されます。アイテムのすべての属性または指定された属性が取得されます。







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: "アイテムの削除"
description: "このAPIを使用すると、NoSQLテーブルからアイテムを削除できます。"
last_updated: "2026-08-17T13:08:49.656Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/delete-item/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# アイテムの削除

### 説明

このAPIを使用すると、プロジェクト内のNoSQLテーブルからアイテムを削除できます。テーブルは一意のIDまたは名前で参照されます。

カスタムJSON形式でデータを渡すことで、条件を指定してもしなくてもアイテムを削除できます。

注意: テーブルは既に作成されている必要があります。コンソールからNoSQLテーブルを作成できます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.item.INSERT



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

 テーブルに挿入するメインデータを含みます。アイテムはカスタムJSON形式で挿入する必要があります。テーブルがシンプルなプライマリキーで構成されている場合は、パーティションキーを指定します。テーブルが複合プライマリキーで構成されている場合は、パーティションキーとソートキーの両方を指定します。  

 テーブルの既存データが取得され、この条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。条件を初期化するには3つの方法があります：


 2つの組み込み関数があります：属性の存在を確認するために使用できるattribute_existと、指定された属性名が指定された型に属するかどうかを確認するために使用できるattribute_typeです。 

 直接比較操作を実行するために使用します。サポートされる演算子：contains、not_contains、begins_with、ends_with、in、not_in、between、not_between、equals、not_equals、greater_than、less_than、greater_equal、less_equal。  

2つ以上の条件を組み合わせるために使用します。サポートされるグループ演算子：and、or。   

条件の結果を否定するために使用します。    

### レスポンス詳細

レスポンスには、挿入操作のステータスと、設定されている場合はtable_name、partition_key、sort_keyなど挿入されたアイテムの詳細が返されます。







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: "テーブルのクエリ"
description: "このAPIを使用すると、NoSQLテーブルをクエリしてデータを取得できます。"
last_updated: "2026-08-17T13:08:49.657Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# テーブルのクエリ

### 説明

このAPIを使用すると、プロジェクト内のNoSQLテーブルをクエリしてデータを取得できます。テーブルは一意のIDで参照されます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.POST



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

アイテムのCRUD操作と同様の形式で条件を含みます。パーティションキーとソートキーの条件のみ指定できます。パーティションキーには「equals」演算子のみ使用できます。条件はパーティションキー = 値、またはパーティションキーのequals条件とソートキー条件を含むグループにできます。サポートされる演算子の完全なリストを参照してください。 

返される属性のリスト。  

読み取りをマスターまたはスレーブから行うかを宣言します。falseに設定すると、スレーブからクエリされます。許容される値：true、false。  

取得されたデータに適用される条件です。これらの条件が適用された後にレスポンスが送信されます。   

クエリを昇順または降順で実行するかを示すために使用します。 

ページネーション目的で次のデータアイテムセットを取得するために使用します。  

追加のソートキーを持つテーブルに対してクエリが行われるかどうかを示すために使用します。追加のソートキー属性名を含みます。  

返されるアイテムの最大件数を示します。   


### レスポンス詳細

レスポンスには、クエリ操作のステータスと、クエリで設定された条件に従って取得されたアイテムが返されます。







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: "インデックスのクエリ"
description: "このAPIを使用すると、NoSQLインデックスをクエリしてデータを取得できます。"
last_updated: "2026-08-17T13:08:49.657Z"
source: "https://docs.catalyst.zoho.com/ja/api/code-reference/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
--------------------------------------------------------------------------------






# インデックスのクエリ

### 説明

このAPIを使用すると、プロジェクト内のNoSQLインデックスをクエリしてデータを取得できます。インデックスは一意のIDで参照されます。

### リクエスト詳細

#### リクエストURL

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

Catalyst APIにアクセスするためのDC固有のドメイン

プロジェクトの一意のID

テーブルの一意のIDまたはテーブル名

インデックスの一意のID


#### リクエストヘッダー
 **Authorization:** Zoho-oauthtoken {oauth_token} <br>
 Content-Type: application/json <br>


**オプションヘッダー** <br>
 **CATALYST-ORG:** {org_id}

 **Environment:** Development


#### スコープ

ZohoCatalyst.nosql.POST



 注意: この操作は、Catalyst SDKを使用してCatalystユーザー認証権限でも実行できます。詳細については、[Catalyst API前提条件セクション](/ja/api/introduction/overview-and-prerequisites/#prerequisites)を参照してください。

### リクエストJSONプロパティ

アイテムのCRUD操作と同様の形式で条件を含みます。パーティションキーとソートキーの条件のみ指定できます。パーティションキーには「equals」演算子のみ使用できます。条件はパーティションキー = 値、またはパーティションキーのequals条件とソートキー条件を含むグループにできます。サポートされる演算子の完全なリストを参照してください。 

返される属性のリスト。  

読み取りをマスターまたはスレーブから行うかを宣言します。falseに設定すると、スレーブからクエリされます。許容される値：true、false。  

取得されたデータに適用される条件です。これらの条件が適用された後にレスポンスが送信されます。   

クエリを昇順または降順で実行するかを示すために使用します。 

ページネーション目的で次のデータアイテムセットを取得するために使用します。  

追加のソートキーを持つテーブルに対してクエリが行われるかどうかを示すために使用します。追加のソートキー属性名を含みます。  

返されるアイテムの最大件数を示します。   


### レスポンス詳細

レスポンスには、クエリ操作のステータスと、クエリで設定された条件に従って取得されたアイテムが返されます。







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: "テーブルメタデータの取得"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.692Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Node.js SDK (/ja/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/)
- NoSQL Python SDK (/ja/sdk/python/v1/cloud-scale/nosql/get-component-instance/)

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


# NoSQL

Catalyst NoSQLは、アプリケーションの半構造化データ、非構造化データ、および異種データを保存できる完全マネージドの非リレーショナルNoSQLデータストレージ機能です。Catalystは、キーバリューペアベースのJSON形式でドキュメント型のデータストレージをサポートしています。

Catalyst NoSQL Java SDKパッケージを使用すると、プロジェクト内のNoSQLテーブルでCRUDデータ操作を実行できます。NoSQLテーブルのメタデータを取得し、さまざまなサポートされるデータ型のNoSQLアイテムを作成し、特定のテーブルでアイテムの挿入、更新、取得、または削除が行えます。また、クエリ条件を指定してテーブルまたはテーブルのインデックスをクエリすることもできます。

## テーブルメタデータの取得

Catalystでは、getInstance()メソッドを使用してJava SDKのインスタンスを取得し、NoSQLテーブルのメタデータを取得できます。プロジェクト内の単一テーブルまたはすべてのテーブルのメタデータを取得できます。

### 単一テーブルのメタデータを取得

Catalyst NoSQLの単一テーブルのメタデータは、このページで説明する2つの方法で取得できます。レスポンスには、パーティションキーとソートキー、TTL属性などのテーブル構成の詳細が含まれます。

#### テーブルIDによるテーブルメタデータの取得

以下に示すように、getTable()メソッドを使用して、プロジェクト内のNoSQLテーブルの一意のテーブルIDを参照してメタデータを取得できます。

//public ZCNoSQLTable getTable(String tableName) throws Exception;
//public ZCNoSQLTable getTable(Long tableId) throws Exception;
// テーブルIDを使用してテーブルメタデータを取得する
ZCNoSQL.getInstance().getTable(2144568989001);

<br>

#### テーブル名によるテーブルメタデータの取得

以下に示すように、getTable()メソッドを使用して、テーブル名を参照してプロジェクト内のNoSQLテーブルのメタデータを取得できます。

//public ZCNoSQLTable getTable(String tableName) throws Exception;
//public ZCNoSQLTable getTable(Long tableId) throws Exception;
// テーブル名を使用してテーブルメタデータを取得する
ZCNoSQL.getInstance().getTable('Employees');

注意: テーブル名を変更した場合、コード内の変更を更新する必要があります。

<br>

### すべてのテーブルのメタデータを取得

以下に示すように、getAllTables()メソッドを使用して、プロジェクト内のすべてのテーブルのメタデータを取得できます。

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


--------------------------------------------------------------------------------
title: "テーブルインスタンスの作成"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのインスタンスを作成するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.692Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/create-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/ja/cloud-scale/help/nosql/create-manage-tables/)

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


# テーブルインスタンスの作成

Catalyst NoSQLでは、NoSQLテーブルの空のテーブルインスタンスを取得できます。このインスタンスを使用してそのテーブルを参照し、サポートされているすべてのテーブル操作を実行できます。このプロセスはサーバー側の呼び出しを発生させません。

このセクションで説明する2つの方法で、NoSQLテーブルのインスタンスを取得できます。


### テーブルIDによるインスタンスの取得

以下に示すように、テーブルの一意のIDをgetTableInstance()に渡してテーブルインスタンスを取得します。

//public ZCNoSQLTable getTableInstance(Long tableId);
//public ZCNoSQLTable getTableInstance(String tableName);
// テーブルIDでテーブルインスタンスを作成する
ZCNoSQL.getInstance().getTableInstance(37898901211);

<br>

### テーブル名によるインスタンスの取得

以下に示すように、テーブル名をgetTableInstance()に渡してテーブルインスタンスを取得します。

//public ZCNoSQLTable getTableInstance(Long tableId);
//public ZCNoSQLTable getTableInstance(String tableName);
// テーブルIDでテーブルインスタンスを作成する
ZCNoSQL.getInstance().getTableInstance('Employees');


--------------------------------------------------------------------------------
title: "NoSQLアイテムの構築"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLアイテムを構築するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.692Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLアイテムの構築

Catalyst NoSQLのアイテムは、レコードのような単一のデータポイントのデータを保持する属性のコレクションを表します。プロジェクト内の既存のNoSQLテーブルにカスタムJSON形式でアイテムを挿入または更新できます。ただし、Catalystでアイテムを挿入または更新する前に、アイテムを構築する必要があります。

以下のセクションで説明するように、Catalystがサポートする異なるデータ型の属性を含むNoSQLアイテムを構築できます。CatalystはString、Number、Set of Strings、Set of Numbers、List、Mapなど、いくつかのデータ型をサポートしています。詳細については、共有リソースのサポートされるデータ型の完全なリストを参照してください。

テーブルに対して構成したパーティションキー属性の値を、すべてのデータアイテムで必ず提供する必要があります。テーブルキー、TTL属性、およびその他の詳細については、テーブルキーのヘルプセクションを参照してください。

<br>

### 新しいNoSQLアイテムの作成

以下に示すように、ZCNoSQLItem()メソッドを使用して新しいNoSQLアイテムを作成できます。

ZCNoSQLItem item = new ZCNoSQLItem();

#### JSONまたはMapからの新しいNoSQLアイテムの作成

以下に示すように、プレーンJSONデータまたはMapを定義した後、そこから新しいNoSQLアイテムを作成できます。

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

<br>


### 異なるデータ型のNoSQLアイテムの構築

以下のコードスニペットは、異なるデータ型の属性を持つアイテムを構築する形式を示しています:

//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アイテム操作"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、さまざまなNoSQLアイテム操作を実行するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.692Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/item-operations/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLアイテム操作


Catalyst NoSQLのアイテムは、レコードのような単一のデータポイントのデータを保持する属性のコレクションを表します。以下は、アイテムで使用してさまざまな操作を実行できるメソッドです。

#### 構築済みアイテムから属性を削除


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

#### 構築中のアイテムからすべてのキーを取得

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

#### 構築済みアイテムに特定の属性が含まれているか確認

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

#### アイテムをMapとして取得

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

#### アイテムをJSONとして取得

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

#### 構築済みアイテムの属性数を取得

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

<br>

### ZCNoSQLAttribute

ZCNoSQLAttributeクラスを使用して、操作を実行する属性を示すことができます。Mapのネストされた要素にアクセスするには、ZCNoSQLAttributeを使用する際に属性を','で区切ることができます。リストの特定のインデックスにアクセスするには、"[<index>]"のように表記できます。これは以下の例で示されています。

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

NoSQLでサポートされるデータ型は、ZCNoSQLAttributeで以下のように表記できます:

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

<thead>
        <tr>
            <th class="w10p">サポートされるデータ型</th>
            <th class="w10p">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

このクラスのオブジェクトは、以下に示すように属性の値とそのデータ型を示すために使用されます。

// 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

このクラスには、サーバーに対して行われたSDK呼び出しのレスポンスが含まれます。以下のメソッドが含まれています。

* getSize - サーバーから読み取りまたは書き込みされたデータのサイズを返すために使用されます。


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

* getStartKey - より多くのデータが存在する場合、ページネーション用の次のデータセットの開始キーを返すために使用されます。

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

* getResponseDataList - 実際のデータを返します。NOSQL_RETURN_VALUEに基づいて、古いデータまたは新しいデータがgetNew_item()またはgetOld_Item()メソッドで返されます。

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


--------------------------------------------------------------------------------
title: "テーブルにアイテムを挿入"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルにアイテムを挿入するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.692Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルにアイテムを挿入

Catalystでは、アイテムを構築した後、特定のNoSQLテーブルにアイテムを挿入できます。このセクションで説明するように、アイテムはさまざまな方法で挿入できます。

データの追加と操作、CatalystカスタムJSON形式、およびサポートされるデータ型に関するヘルプセクションを参照して、これらのトピックの詳細を学ぶことができます。

注意: Catalystでは、1回のSDK操作でNoSQLテーブルに最大25個のアイテムを一括で挿入できます。

### 条件なしでアイテムを挿入

ZCNoSQLTableインスタンス、またはリクエストの各部分を構築するために使用できるZCNoSQLInsertHelperインスタンスを使用して、条件なしでNoSQLテーブルに新しいアイテムを挿入できます。

以下に示すように、ZCNoSQLTableインスタンスでデータを挿入できます。

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

以下に示すように、ZCNoSQLInsertHelperインスタンスでデータを挿入できます。

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

このクラスは、条件付きでテーブルにデータを挿入するために使用できます。ZCNoSQLTableインスタンスから取得できます。

<br>

### 条件付きでアイテムを挿入

定義した特定の条件を使用して、NoSQLテーブルの既存アイテムに属性を挿入できます。このタイプでは、テーブルの既存データが取得され、指定された条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。

以下のスニペットは、ZCNoSQLConditionを使用した条件付きアイテムの挿入を示しています。

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

条件は、コンストラクタまたはgetInstance()メソッドを呼び出して取得できるZCNoSQLConditionインスタンスを使用して渡すことができます。条件は3つの方法で初期化できます。

#### 1. 関数を使用する方法

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

2つの組み込み関数が利用可能です。

i. ZCNoSQLAttributeTypeFunction

指定した属性のデータ型が指定したデータ型と一致するかどうかを確認します。

//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 

取得したアイテムに属性が既に存在するかどうかを評価するために使用されます。

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

<br>
            
#### 2. 演算子、オペランド、値を使用する方法

//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

許可されるNOSQL_OPERATORの値は、contains、not_contains、begins_with、ends_with、in、not_in、between、not_between、equals、not_equals、greater_than、less_than、greater_equal、less_equalです。

#### 条件のグループを使用する方法

//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

許可されるNOSQL_CONDITION_GROUP_OPERATORの値は、AND、ORです。

#### NOSQL_RETURN_VALUE 

条件の評価後の戻り値を示します。

//public ZCNoSQLInsertHelper withReturnValue(NOSQL_RETURN_VALUE returnValue) throws Exception
table.getInsertHelper(<ZCNoSQLItem>).withReturnValue(<NOSQL_RETURN_VALUE>).insert();
       
許可されるNOSQL_RETURN_VALUEの値は、NEW、OLD、NULLです。

#### 条件と戻り値を指定した挿入

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


--------------------------------------------------------------------------------
title: "アイテムの更新"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのアイテムを更新するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.740Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルのアイテムを更新

Catalystでは、アイテムを構築した後、特定のNoSQLテーブルのアイテムを更新できます。アイテムはプライマリキーを使用して識別されます。例えば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを識別できます。その後、適切なHTTPリクエストメソッドで更新操作の種類を定義し、アイテムで更新する属性と値を指定します。

注意: Catalystでは、1回のSDK操作でNoSQLテーブル内の最大25個のアイテムを一括で更新できます。


データを更新する方法は2つあります。ZCNoSQLTableインスタンスを使用して条件なしでデータを更新するか、リクエストの各部分を構築するために使用できるZCNoSQLUpdateHelperインスタンスを使用して更新できます。

以下に示すように、ZCNoSQLTableインスタンスでデータを更新できます。


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


ZCNoSQLUpdateHelperで更新する場合

#### ZCNoSQLUpdateHelper


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



#### ZCNoSQLUpdateAttributeOperation

このクラスは、既存の属性を追加/更新するか、既存の属性を削除してアイテムを更新するために使用されます。上記のインスタンスは以下のメソッドを使用して取得できます。

属性の挿入または更新の場合


//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>)



属性の削除の場合

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


更新には、値を更新するために使用できる特定のビルトイン関数もあります。これらの関数はNoSQLUpdateAttributeFunction型の下にグループ化でき、ZCNoSQLUpdateAttributeOperationインスタンスの取得時に使用できます。

### NoSQLUpdateAttributeFunction

4つのビルトイン関数があります。

#### ZCNoSQLIfNotExistFunction

この関数は、別の既存の属性の値で属性を更新するために使用されます。属性が存在しない場合、指定された値で更新されます。


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


#### ZCNoSQLAppendListFunction
  
この関数は、既存または新しいリスト属性に要素を追加するために使用されます。


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



#### ZCNoSQLAdditionFunction
 
この関数は、セットに要素を追加するか、既存の属性に数値を加算するために使用されます。操作の種類は対象の属性タイプによって異なります。

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


#### ZCNoSQLReductionFunction

この関数は、セットから要素を削除するか、既存の属性から数値を減算するために使用されます。操作の種類は対象の属性タイプによって異なります。


//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>)


ZCNoSQLUpdateHelperで利用可能なその他のメソッド

#### ZCNoSQLCondition

上記で説明した同じ条件を更新にも再利用できます。

NOSQL_RETURN_VALUE 

上記で説明した同じ戻り値を更新にも再利用できます。

条件と戻り値を指定した更新


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



--------------------------------------------------------------------------------
title: "NoSQLテーブルからアイテムを取得"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルからアイテムを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.741Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルからアイテムを取得

Catalystでは、プライマリキーを使用してアイテムを識別し、NoSQLテーブルからアイテムを取得できます。例えば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。また、必要な属性を指定して、取得する属性をオプションでフィルタリングすることもできます。

注意: Catalystでは、1回のSDK読み取り操作でNoSQLテーブルから最大100個のアイテムを取得できます。

ZCNoSQLTableインスタンスを使用して特定の属性をフィルタリングせずにデータを取得するか、リクエストの各部分を構築するために使用できるZCNoSQLFetchHelperインスタンスを使用して取得できます。

ZCNoSQLTableインスタンスでデータを取得するには、以下を使用します。

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

ZCNoSQLFetchHelperで取得する場合

#### ZCNoSQLFetchHelper

このクラスは、テーブルからデータを取得し、特定の属性をフィルタリングするために使用できます。ZCNoSQLTableインスタンスから取得できます。

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

ZCNoSQLFetchHelperで利用可能なその他のメソッド

#### 必要な属性

このメソッドを使用して、特定の必要な属性のみをフィルタリングして取得できます。


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


また、consistencyを使用して、読み取り操作をマスターまたはスレーブクラスターのどちらで実行するかを指定できます。trueに設定すると、マスターからクエリされます。falseの場合、スレーブからクエリされます。

注意: マスター・スレーブレプリケーションでは、マスターにデータベースのすべてのデータが含まれ、スレーブにマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、全体的なコストを削減できますが、更新されたデータの反映にわずかな遅延が生じるトレードオフがあります。


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

必要な属性とconsistencyを指定した取得

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


--------------------------------------------------------------------------------
title: "NoSQLテーブルのクエリ"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.741Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルのクエリ

Catalystでは、テーブルのプライマリキーを使用してアイテムを識別し、NoSQLテーブルをクエリしてデータを取得できます。例えば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

注意: Catalystでは、1回のSDK操作でNoSQLテーブルからページネーション付きで最大100個のアイテムを一括で取得できます。

属性、必要な値、および使用するサポートされている演算子を指定して、アイテムを識別するキー条件を定義できます。サポートされる演算子のリストおよびCatalystコンソールからのクエリに関するヘルプセクションを参照してください。

ZCNoSQLTableインスタンスでデータをクエリするには、以下のスニペットを使用します。

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


ZCNoSQLQueryHelperでクエリする場合
ZCNoSQLQueryHelper
このクラスは、テーブルからデータをクエリし、その他の条件、ソート順、制限などを指定するために使用できます。ZCNoSQLTableインスタンスから取得できます。

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


ZCNoSQLPartitionKeyCondition

パーティションキーの条件を構築するために使用されます。テーブルまたはインデックスからデータをクエリするために必要です。

//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>)


セカンダリキー条件
ソートキーの条件を構築するために使用されます。テーブルのクエリ時にソートキーを使用するか、追加のソートキーを使用するかを示すために使用されます。

//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();


ZCNoSQLQueryHelperで利用可能なその他のメソッド

SECONDARY_KEY_CONDITION_OPERATOR
使用できる値は、begins_with、between、equals、greater_than、less_than、greater_equal、less_equalです。
    
その他の条件
パーティションキーとソートキー（指定した場合）を使用して取得したデータをフィルタリングするために使用できます。これはキーを使用して取得したデータの上にのみ適用されます。そのため、指定したパーティションキー、ソートキー、およびその他の条件のデータが存在しても、最大100アイテムの制限に対して、その他の条件と開始キーを適用した後に0アイテムが返されるシナリオが発生する場合があります。

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


開始キー
ページネーションに使用されます。テーブル/インデックスからデータをクエリした際、さらにレコードが存在する場合、開始キーが返されます。次のデータセットを取得するには、前のリクエストのレスポンスからこの値を設定する必要があります。

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



--------------------------------------------------------------------------------
title: "NoSQLインデックスのクエリ"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.741Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLインデックスのクエリ

Catalystでは、インデックスのプライマリキーを使用してアイテムを識別し、NoSQLインデックスをクエリしてデータを取得できます。インデックスを使用すると、メインテーブルのプライマリキーを使用せずにテーブルデータに対して代替クエリを実行できます。Catalystコンソールからインデックスを構成できます。そのため、インデックスのパーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

注意: Catalystでは、1回のSDK操作でNoSQLテーブルからページネーション付きで最大100個のアイテムを一括で取得できます。

属性、必要な値、および使用するサポートされている演算子を指定して、アイテムを識別するキー条件を定義できます。サポートされる演算子のリストおよびCatalystコンソールからのクエリに関するヘルプセクションを参照してください。

ZCNoSQLTableインスタンスでデータをクエリするには、以下を使用します。

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

ZCNoSQLQueryHelperでクエリする場合

ZCNoSQLQueryHelper

このクラスは、インデックスからデータをクエリし、その他の条件、ソート順、制限などを指定するために使用できます。ZCNoSQLTableインスタンスから取得できます。

//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

上記で説明した同じパーティションキー条件をここでも再利用できます。
ZCNoSQLQueryHelperで利用可能なその他のメソッド

必要な属性

上記で説明した同じ必要な属性をここでも再利用できます。

Consistency

Catalyst NoSQLでは、consistent_readを使用して読み取り操作をマスターまたはスレーブクラスターのどちらで実行するかを指定する、返される行数を制限する、昇順でソート順を指定するなど、クエリの他の要素も定義できます。

注意: マスター・スレーブレプリケーションでは、マスターにデータベースのすべてのデータが含まれ、スレーブにマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、全体的なコストを削減できますが、更新されたデータの反映にわずかな遅延が生じるトレードオフがあります。

セカンダリキー条件

上記で説明した同じセカンダリキー条件をここでも再利用できますが、インデックスではadditionalSortキーは使用できない点が異なります。
    
その他の条件

テーブルのクエリで説明したその他の条件もここで再利用できます。
 
開始キー

上記で説明した同じ開始キーをここでも使用できます。

すべての組み合わせを使用したインデックスクエリ

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


--------------------------------------------------------------------------------
title: "テーブルからアイテムを削除"
description: "Catalyst NoSQLは、非リレーショナル、非SQLのデータストレージ手段を提供する完全マネージドの強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.741Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/java/v1/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルからアイテムを削除

テーブルのプライマリキーを使用してアイテムを識別し、CatalystのNoSQLテーブルからアイテムを削除できます。例えば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを識別します。

注意: Catalystでは、1回のSDK操作でNoSQLテーブルから最大25個のアイテムを一括で削除できます。
ZCNoSQLTableインスタンスを使用して条件なしでデータを削除するか、リクエストの各部分を構築するために使用できるZCNoSQLDeleteHelperインスタンスを使用して条件付きで削除できます。

ZCNoSQLTableインスタンスでデータを削除するには、以下を使用します。

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

ZCNoSQLDeleteHelperで削除する場合

ZCNoSQLDeleteHelper

このクラスは、条件付きでテーブルからデータを削除するために使用できます。ZCNoSQLTableインスタンスから取得できます。

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

ZCNoSQLDeleteHelperで利用可能なその他のメソッド

ZCNoSQLCondition

上記で説明した同じ条件を削除に再利用できます。
NOSQL_RETURN_VALUE 

上記で説明した同じ条件を削除に再利用できます。

条件と戻り値を指定した削除

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


---

## SDK — Node JS — NoSQL

--------------------------------------------------------------------------------
title: "コンポーネントインスタンスの取得"
description: "Catalyst NoSQLは、非リレーショナルでNoSQLのデータストレージを提供する、完全マネージドで強力なデータベースです。このページでは、新しいNoSQLコンポーネントインスタンスを作成するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.742Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Java SDK (/ja/sdk/java/v1/cloud-scale/nosql/get-table-metadata/)
- NoSQL Python SDK (/ja/sdk/python/v1/cloud-scale/nosql/get-component-instance/)

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


# NoSQL

Catalyst NoSQLは、アプリケーションの半構造化データ、非構造化データ、および異種データを保存できる、完全マネージドの非リレーショナルNoSQLデータストレージ機能です。Catalystは、キーバリューペアベースのJSON形式でのドキュメント型データストレージをサポートしています。

Catalyst NoSQL Node.js SDKパッケージを使用すると、プロジェクト内のNoSQLテーブルに対してCRUDデータ操作を実行できます。NoSQLテーブルのメタデータを取得し、さまざまなサポートされているデータ型のNoSQLアイテムを作成し、特定のテーブルにアイテムを挿入、更新、取得、または削除できます。また、クエリ条件を指定してテーブルやテーブルのインデックスをクエリすることもできます。

### NoSQLインスタンスの作成

コンポーネントインスタンスは、特定のコンポーネントに固有の事前定義された設定にアクセスするために使用できるオブジェクトです。

以下に示すように、Node.jsでSDK操作を実行するためのNoSQLオブジェクトを作成できます。これはサーバーサイドの呼び出しを発生させません。このnosqlインスタンスは、NoSQLを操作するさまざまなコードスニペットで参照します。

NoSQLインスタンスの作成に使用されるappの参照は、SDKの初期化時にレスポンスとして返されるNode.jsオブジェクトです。

// NoSQLインスタンスを作成
const nosql = app.nosql();


--------------------------------------------------------------------------------
title: "テーブルメタデータの取得"
description: "Catalyst NoSQLは、非リレーショナルでNoSQLのデータストレージを提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.742Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/ja/cloud-scale/help/nosql/create-manage-tables/)

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


# NoSQLテーブルメタデータの取得

以下に説明するように、プロジェクト内の単一のCatalyst NoSQLテーブルまたはすべてのテーブルのメタデータを取得できます。

### 単一テーブルのメタデータの取得

Catalyst NoSQL内の単一テーブルのメタデータは、このページで説明する2つの方法で取得できます。レスポンスには、パーティションキーとソートキー、TTL属性などのテーブル設定の詳細が含まれます。

以下のコードスニペットで使用されているnosqlの参照は、これらの操作を実行するために作成されたコンポーネントインスタンスです。

#### テーブルIDによるテーブルメタデータの取得

以下に示すように、getTable()メソッドを使用して、一意のテーブルIDでプロジェクト内のNoSQLテーブルのメタデータを取得できます。

// NoSQLインスタンスを作成
const nosql = app.nosql();
// テーブルIDを使用してテーブルメタデータを取得する
const tableA = await nosql.getTable('124567890');  

#### テーブル名によるテーブルメタデータの取得

以下に示すように、getTable()メソッドを使用して、テーブル名でプロジェクト内のNoSQLテーブルのメタデータを取得できます。

// NoSQLインスタンスを作成
const nosql = app.nosql();
// テーブル名を使用してテーブルメタデータを取得する
const tableB = await nosql.getTable('EmpTable');  

Note: テーブル名を変更した場合、コード内の変更を更新する必要があります。

<br>
 
### すべてのテーブルのメタデータの取得

Catalystでは、以下に示すようにgetAllTable()メソッドを使用して、プロジェクト内のすべてのテーブルのメタデータを取得できます。

// すべてのテーブルのメタデータを取得
const allTables = await nosql.getAllTable();


--------------------------------------------------------------------------------
title: "テーブルインスタンスの取得"
description: "Catalyst NoSQLは、非リレーショナルでNoSQLのデータストレージを提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルインスタンスを作成するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.742Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/get-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/ja/cloud-scale/help/nosql/create-manage-tables/)

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


# NoSQLテーブルインスタンスの取得

Catalyst NoSQLを使用すると、既存のNoSQLテーブルの空のテーブルインスタンスを取得できます。このインスタンスを使用してそのテーブルを参照し、サポートされているすべてのテーブル操作を実行できます。このプロセスはサーバーサイドの呼び出しを発生させません。

このセクションで説明する3つの方法でNoSQLテーブルのインスタンスを取得できます。以下のコードスニペットで使用されているnosqlの参照は、先に作成したコンポーネントインスタンスです。

### テーブルIDによるインスタンスの取得

以下に示すように、テーブルの一意のIDでテーブルインスタンスを取得します。

const tableInstanceA = nosql.table('1234567890'); // テーブルIDでテーブルインスタンスを作成する 

<br>

### テーブル名によるインスタンスの取得

以下に示すように、テーブル名でテーブルインスタンスを取得します。

const tableInstanceB = nosql.table('Emptable'); // テーブル名でテーブルインスタンスを作成 

<br>

### テーブル詳細によるインスタンスの取得

以下に示すように、テーブルの詳細を指定し、toJSON()に解決してテーブルインスタンスを取得します。

このメソッドは、テーブルIDまたはテーブル名を使用して既にインスタンスを取得したテーブルオブジェクトを複製する柔軟性を提供します。その後、インスタンスにテーブルの追加の詳細を設定し、代わりにこれを使用してテーブルを参照できます。

const tableInstanceC = nosql.table(tableA.toJSON()); // テーブル詳細でテーブルインスタンスを作成


--------------------------------------------------------------------------------
title: "NoSQL アイテムの構築"
description: "Catalyst NoSQLは、非リレーショナルでNoSQLのデータストレージを提供する、完全マネージドで強力なデータベースです。このページでは、さまざまなデータ型のNoSQLアイテムを構築するメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.743Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- Supported Data Types in NoSQL (/ja/cloud-scale/help/nosql/working-with-data/introduction/)

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


# NoSQLアイテムの構築


Catalyst NoSQLのアイテムは、単一のデータポイント（レコードのようなもの）のデータを保持する属性のコレクションを表します。プロジェクト内の既存のNoSQLテーブルに、カスタムJSON形式でアイテムを挿入または更新できます。ただし、Catalystでアイテムを挿入または更新する前に、アイテムを構築する必要があります。

以下のセクションで説明するように、Catalystがサポートするさまざまなデータ型の属性を含むNoSQLアイテムを構築できます。Catalystは、String、Number、Set of Strings、Set of Numbers、List、Mapなど、いくつかのデータ型をサポートしています。サポートされているデータ型の完全なリストを参照してください。

テーブルに設定したパーティションキー属性の値は、すべてのデータアイテムで必ず提供する必要があります。テーブルキー、TTL属性、その他の詳細については、テーブルキーのヘルプセクションを参照してください。

<br>

### 新しいNoSQLアイテムの作成

以下に示すように、zcatalyst-sdk-nodeパッケージの一部であるno-sqlライブラリをrequireした後、NoSQLItem()メソッドを使用して新しいNoSQLアイテムを作成できます。

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
const item = new NoSQLItem() // 新しいNoSQLアイテムを作成 

<br>

### 文字列のNoSQLアイテムの構築

以下の例では、文字列値とネストされたJSON属性colorをMapとして含むアイテムを構築します。

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
const item = new NoSQLItem() // 新しいNoSQLアイテムを作成
// 文字列値を追加する
.addString('fruit', 'mango')
// マップを追加する
.addMap('properties', {
color: 'yellow'
}); 

 <br>

### NoSQLバイトの構築

バイトのシーケンスを表すために使用されるバッファオブジェクトを作成し、*Binary*データ型の値を格納するNoSQLバイトを作成できます。以下に示すように、生のバイナリデータバッファを表すArrayBuffersオブジェクトを使用するか、ASCII形式でバイナリデータを表すBase64文字列から、2つの方法でバイトを作成できます。

const { NoSQLByte } = require('zcatalyst-sdk-node/lib/no-sql');
// NoSQL Byteを作成する
const buff = Buffer.from('Hello world !!!'); // バッファオブジェクトを作成
const byte = new NoSQLByte(buff); // ArrayBuffersオブジェクトを使用してNoSQLバイトを作成
const byteA = new NoSQLByte(buff.toString('base64')); // Base64文字列からNoSQLバイトを作成 

<br>


### NoSQLバイトセットの構築

Catalystでは、バイトのシーケンスを表すために使用されるバッファオブジェクトを作成し、*Set of Binary*データ型のバイナリ値のコレクションを格納するNoSQLバイトセットを作成できます。生のバイナリデータバッファを表すArrayBuffersオブジェクトを使用するか、ASCII形式でバイナリデータを表すBase64文字列からバイトセットを作成できます。

また、構築済みのバイトをバイト配列として渡すことで、バイトセットを作成することもできます。

const { NoSQLByte, NoSQLByteSet } = require('zcatalyst-sdk-node/lib/no-sql');
// NoSQL Byte Setを作成する
const buff = Buffer.from('Hello world !!!'); // バッファオブジェクトを作成
const byte = new NoSQLByte(buff); // ArrayBuffersオブジェクトを使用してNoSQLバイトを作成
const byteA = new NoSQLByte(buff.toString('base64')); // Base64文字列からNoSQLバイトを作成
const byteSet = new NoSQLByteSet([byte, byteA]); // NoSQLバイト配列からNoSQLバイトセットを作成
const byteSetA = new NoSQLByteSet([buff.toString('base64')]); // NoSQL Byteを作成する set from a Base64 string array
const byteSetB = new NoSQLByteSet([buff]); // NoSQL Byteを作成する set using the ArrayBuffers object 

<br>

### NoSQL文字列セットの構築

以下に示すように、文字列配列から*Set of String*データ型のNoSQL文字列セットを作成できます。

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

<br>

### NoSQL数値セットの構築

以下に示すように、数値またはBigInt値の配列から*Set of Numbers*データ型のNoSQL数値セットを作成できます。

const { NoSQLNumberSet } = require('zcatalyst-sdk-node/lib/no-sql');
// NoSQL number setを作成する
const numberSet = new NoSQLNumberSet([123, 1234n]); // 数値またはBigInt値の配列からNoSQL数値セットを作成 

<br>

### NoSQLアイテムの操作

Catalystでは、NoSQLアイテムに対して、プレーンJavaScriptオブジェクトからNoSQLアイテムを作成する、またはその逆の操作などの操作を実行できます。アイテムのデータを標準JSON形式で含むプレーンJavaScriptオブジェクトを構築して、NoSQLアイテムを作成できます。以下のサンプルコードに示すように、NoSQLItem.from()を使用してJSオブジェクトからNoSQLアイテムを構築できます。

また、コードに示すように、itemFromObj.to()を使用してNoSQLアイテムをプレーンJavaScriptオブジェクトに戻すこともできます。

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
// オブジェクトを定義する
const obj = {
fruit: 'apple', // パーティションキー
properties: {
color: 'red'
}
};
const itemFromObj = NoSQLItem.from(obj); // プレーンJSオブジェクトからNoSQLアイテムを構築
const plainJsObject = itemFromObj.to(); // アイテムをプレーンJSオブジェクトに変換


--------------------------------------------------------------------------------
title: "テーブルへのアイテムの挿入"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLテーブルにさまざまな方法でアイテムを挿入するためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.743Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルへのアイテムの挿入

Catalystでは、アイテムを構築した後、特定のNoSQLテーブルにアイテムを挿入できます。このセクションで説明するさまざまな方法でアイテムを挿入できます。

データの追加と操作に関するヘルプセクション、CatalystカスタムJSON形式、およびサポートされるデータ型を参照して、これらのトピックの詳細を確認できます。

Note: Catalystでは、1回のSDK操作でNoSQLテーブルに最大25件のアイテムを一括挿入できます。

<br>

### 条件なしでのアイテムの挿入

CatalystカスタムJSON形式でアイテムを構築することで、条件なしでNoSQLテーブルに新しいアイテムを挿入できます。この場合、テーブルに設定されたパーティションキーとソートキー属性の値を必須で渡す必要があります。

以下の例では、パーティションキー属性fruitNameの値を「Banana」として含むアイテムが提供されています。文字列データ型の他の属性（fruitColorやfruitTypeなど）も、fruitPropertiesというマップとして追加されています。アイテムはinsertItems()メソッドを使用して挿入されます。

// 条件なしでNoSQLアイテムを挿入
const plainInsert = await table.insertItems({
// 挿入するアイテムを定義する with the partition key fruitName
item: NoSQLItem.from({
fruitName: 'Banana',
//アイテムの他の属性の値を指定する
fruitProperties: {
fruitColor: 'Yellow', 
fruitType: 'Berries'  
}
}),
// レスポンスの戻り値を設定する。その他のサポート値は"OLD"と"NULL"
return: NoSQLReturnValue.NEW
}); 

<br>

### 条件付き関数でのアイテムの挿入

CatalystカスタムJSON形式で定義した特定の条件を使用して、NoSQLテーブルの既存アイテムに属性を挿入できます。この方法では、テーブルの既存データが取得され、指定された条件に対して評価されます。評価が真の場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。

Catalystでは、条件を評価するための複数の演算子がサポートされています。サポートされる演算子は以下のとおりです。

<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>

以下の例では、既存データ内の属性fruitNameのデータ型がStringであることを条件として定義しています。条件が満たされた場合、これらのアイテムに値「Sweet」を持つ属性tasteが追加されます。

// "attribute_type"関数でNoSQLアイテムを挿入
const attrTypeInsert = await table.insertItems({
// 挿入するアイテムを定義する
item: NoSQLItem.from({ taste: 'Sweet' }),
// 挿入の条件を定義する
condition: {
// 条件は属性タイプがString（"S"）の場合にアイテムを追加することを指定する
function: {
// 関数タイプを設定する
function_name: 'attribute_type',
// 関数に引数を渡す
args: [
{
// 属性パスを設定する
attribute_path: ['fruitName']
},
// 属性タイプを設定する
NoSQLMarshall.makeString('S') // => { "S": "S" }
]
}
}
}); 

<br>

以下は、条件付き関数を使用してアイテムを挿入するその他のサンプルスニペットです。

//"equals"演算子を使用し、属性"name"の値が"apple"のNoSQLアイテムを挿入する
const operatorEqInsert = await table.insertItems({
// 挿入するアイテムを定義する
item: NoSQLItem.from({ taste: 'Sweet' }),
// 挿入の条件を定義する
condition: {
// 属性パスを設定する
attribute: ['name'],
// 操作に基づいて演算子を設定する
operator: NoSQLOperator.EQUALS,
// 比較する値を設定する
value: NoSQLMarshall.makeString('apple') // => { "S": "apple" }
}
});
//「group_operator」でNoSQLアイテムを挿入する。属性「name」が「apple」かつ属性「variety」が「gala」
const groupOpInsert = await table.insertItems({
// 挿入するアイテムを定義する
item: NoSQLItem.from({ taste: 'Sweet' }),
// 挿入の条件を定義する
condition: {
// グループ演算子を設定する
group_operator: NoSQLConditionGroupOperator.AND,
// グループ条件を指定する
group: [
{
// 属性パスを設定する
attribute: 'name',
// 操作に基づいて演算子を設定する
operator: NoSQLOperator.EQUALS,
// 比較する値を設定する
value: NoSQLMarshall.makeString('apple') // => { "S": "apple" }
},
{
// 属性パスを設定する
attribute: 'variety',
// 操作に基づいて演算子を設定する
operator: NoSQLOperator.EQUALS,
// 比較する値を設定する
value: NoSQLMarshall.makeString('gala') // => { "S": "gala" }
}
]
}
});
//「begins_with」演算子でNoSQLアイテムを挿入する。属性「name」の値が「app」で始まる
const beginsWithInsert = await table.insertItems({
// 挿入するアイテムを定義する
item: NoSQLItem.from({ taste: 'Sweet' }),
// 挿入の条件を定義する
condition: {
// 属性パスを設定する
attribute: ['name'],
// 操作に基づいて演算子を設定する
operator: NoSQLOperator.BEGINS_WITH,
// 比較する値を設定する
value: NoSQLMarshall.makeString('app') // => { "S": "app" }
}
});


--------------------------------------------------------------------------------
title: "テーブル内のアイテムの更新"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLテーブル内のアイテムを更新するためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.743Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/update-item/#UpdateItem)

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


# テーブル内のアイテムの更新

Catalystでは、アイテムを構築した後、特定のNoSQLテーブル内のアイテムを更新できます。アイテムは、そのプライマリキーを使用して識別することで更新できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを識別できます。

次に、適切なHTTPリクエストメソッドで更新操作の種類を定義し、アイテム内で更新する属性と値を指定します。

Note: Catalystでは、1回のSDK操作でNoSQLテーブル内の最大25件のアイテムを一括更新できます。

以下の例では、パーティションキーfruitNameと値「Apple」でアイテムを識別しています。更新対象のアイテムの属性colorとtasteの値が、これらの属性へのパスとともに提供されています。

zcatalyst-sdk-node packageのno-sqlライブラリは、NoSQLアイテムの定義と構築に必要です。

const { NoSQLItem, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = NoSQLEnum;
// パーティションキー「apple」で識別されるNoSQLアイテムのプロパティ属性を更新する
const updatedItems = await table.updateItems({
// 更新するアイテムのパーティションキー値を定義する
keys: [new NoSQLItem().addString('fruit', 'apple')],
// 更新する属性を定義する
update_attributes: [
{
// 更新操作のタイプを指定する
operation_type: NoSQLUpdateOperationType.PUT,
// 更新する属性の値を指定する
update_value: NoSQLMarshall.makeMap({ color: 'Green', taste: 'Sour' }),
// 属性へのパスを指定する
attribute_path: ['fruitProperties']
}
]
});


--------------------------------------------------------------------------------
title: "テーブルからのアイテムの取得"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLテーブルからアイテムを取得するためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.743Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/fetch-item/#FetchItem)

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



# NoSQLテーブルからのアイテムの取得

Catalystでは、NoSQLテーブルから、プライマリキーを使用してアイテムを識別し、取得できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。また、必要な属性を指定して、取得する属性をオプションでフィルタリングすることもできます。

Note: Catalystでは、1回のSDK読み取り操作でNoSQLテーブルから最大100件のアイテムを取得できます。

以下の例では、fetchItem()を使用して、パーティションキーfruitの値が「apple」であるアイテムを取得しています。required_attributesを使用して、propertiesやtasteなどの特定の属性がフィルタリングされて取得されます。

このコードスニペットでは、consistent_readを使用して、読み取り操作をマスタークラスターまたはスレーブクラスターのどちらで実行するかを指定しています。trueに設定すると、マスターからクエリされます。falseの場合、スレーブからクエリされます。
 
Note: マスター・スレーブレプリケーションでは、マスターにはデータベースのすべてのデータが含まれ、スレーブにはマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、更新されたデータの反映にわずかな遅延が生じるというトレードオフがありますが、全体的なコストを削減できます。

zcatalyst-sdk-nodeパッケージのno-sqlライブラリは、NoSQLアイテムの定義に必要です。

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
//パーティションキー値「apple」で識別されるNoSQLItemのプロパティを取得する
const fetchedItem = await table.fetchItem({
// 取得するアイテムのパーティションキーと値を定義する
keys: [new NoSQLItem().addString('fruit', 'apple')],
// consistent_readをtrueに設定してマスターからクエリする。falseに設定するとスレーブからクエリされる。
consistent_read: true,
// 取得する属性を指定する
required_attributes: [['properties', 'taste']]
});


--------------------------------------------------------------------------------
title: "テーブルのクエリ"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLテーブルをクエリするためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.744Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Table Keys (/ja/cloud-scale/help/nosql/components/#table-keys)
- Query Table (/ja/sdk/nodejs/v2/cloud-scale/nosql/query-table/)

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


# NoSQLテーブルのクエリ

Catalystでは、NoSQLテーブルをクエリし、テーブルのプライマリキーを使用してアイテムを識別することでデータを取得できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

Note: Catalystでは、1回のSDK操作でNoSQLテーブルからページネーション付きで最大100件のアイテムを一括取得できます。SDKレスポンスで受信したstart_keyトークンを使用して、ページネーションのロジックを構築する必要があります。

属性、必要な値、および使用するサポートされる演算子を指定して、アイテムを識別するキー条件を定義できます。サポートされる演算子は以下のとおりです。

<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>

以下の例では、パーティションキーfruitTypeを使用してアイテムを識別し、条件値を「Citrus」として指定して、queryTable()メソッドでクエリを実行しています。

Catalyst NoSQLでは、consistent_readを使用して読み取り操作をマスタークラスターまたはスレーブクラスターのどちらで実行するかを指定したり、返される行数を制限したり、昇順のソート順序を指定するなど、クエリの他の要素も定義できます。

Note: マスター・スレーブレプリケーションでは、マスターにはデータベースのすべてのデータが含まれ、スレーブにはマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、更新されたデータの反映にわずかな遅延が生じるというトレードオフがありますが、全体的なコストを削減できます。

zcatalyst-sdk-nodeパッケージのno-sqlライブラリは、NoSQLアイテムの定義に必要です。

const { NoSQLMarshall, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = NoSQLEnum;
// パーティションキーfruitTypeの値「citrus」で識別されるアイテムを取得するためにNoSQLテーブルをクエリする
const queriedItem = await table.queryTable({
// アイテムをクエリするためのキー条件を定義する
key_condition: {
// テーブルのパーティションキー属性名を指定する
attribute: 'fruitType',
// 使用するサポートされた演算子を定義する。BETWEEN、GREATERTHAN、LESSERTHAN、GREATERTHANOREQUALTO、LESSERTHANOREQUALTOも使用可能
operator: NoSQLOperator.EQUALS,
// 比較する値を指定する
value: NoSQLMarshall.makeString('Citrus')
},
// consistent_readをtrueに設定してマスターからクエリする。falseに設定するとスレーブからクエリされる。
consistent_read: true,
// 値を指定して返される行数を制限する
limit: 10,
// forward_scanをtrueに設定して結果を昇順にソートする。それ以外の場合は降順にソートされる。
forward_scan: true
});


--------------------------------------------------------------------------------
title: "インデックスのクエリ"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLインデックスをクエリするためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.744Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Table Keys (/ja/cloud-scale/help/nosql/components/#table-keys)
- Query Index (/ja/sdk/nodejs/v2/cloud-scale/nosql/query-index/)

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


# NoSQLでのインデックスのクエリ

Catalystでは、NoSQLインデックスをクエリし、インデックスのプライマリキーを使用してアイテムを識別することでデータを取得できます。インデックスを使用すると、メインテーブルのプライマリキーを使用せずにテーブルデータに対して代替クエリを実行できます。インデックスはCatalystコンソールから設定できます。インデックスのパーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

Note: Catalystでは、1回のSDK操作でNoSQLテーブルからページネーション付きで最大100件のアイテムを一括取得できます。SDKレスポンスで受信したstart_keyトークンを使用して、ページネーションのロジックを構築する必要があります。

属性、必要な値、および使用するサポートされる演算子を指定して、アイテムを識別するキー条件を定義できます。サポートされる演算子は以下のとおりです。

<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>

 
以下の例では、インデックスFruitIdentifierのパーティションキーfruitColorを使用してアイテムを識別し、条件値を「yellow」として指定してクエリを実行しています。クエリはqueryIndex()メソッドを使用して実行されます。

Catalyst NoSQLでは、consistent_readを使用して読み取り操作をマスタークラスターまたはスレーブクラスターのどちらで実行するかを指定したり、返される行数を制限したり、昇順のソート順序を指定するなど、クエリの他の要素も定義できます。

Note: マスター・スレーブレプリケーションでは、マスターにはデータベースのすべてのデータが含まれ、スレーブにはマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、更新されたデータの反映にわずかな遅延が生じるというトレードオフがありますが、全体的なコストを削減できます。

zcatalyst-sdk-nodeパッケージのno-sqlライブラリは、NoSQLアイテムの定義に必要です。

const { NoSQLMarshall, NoSQLEnum } = require('zcatalyst-sdk-node/lib/no-sql');
const { NoSQLOperator } = NoSQLEnum;
//パーティションキーfruitColourの値「yellow」で識別されるアイテムを取得するためにNoSQLテーブルインデックスをクエリする
const queriedIndexItems = await table.queryIndex('FruitIdentifier', {
//アイテムをクエリするためのキー条件を定義する
key_condition: {
attribute: 'fruitColor',
//使用するサポートされた演算子を定義する
operator: NoSQLOperator.EQUALS,
value: NoSQLMarshall.makeString('yellow')
},
// consistent_readをtrueに設定してマスターからクエリする。falseに設定するとスレーブからクエリされる。
consistent_read: true,
//値を指定して返される行数を制限する
limit: 15,
// forward_scanをtrueに設定して結果を昇順にソートする。それ以外の場合は降順にソートされる。
forward_scan: true
});


--------------------------------------------------------------------------------
title: "テーブルからのアイテムの削除"
description: "Catalyst NoSQLは、非リレーショナルかつ非SQLのデータストレージ手段を提供する、フルマネージドで強力なデータベースです。このページでは、NoSQLテーブルからアイテムを削除するためのSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.744Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/nodejs/v2/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/delete-item/#DeleteItem)

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


# NoSQLテーブルからのアイテムの削除

Catalystでは、テーブルのプライマリキーを使用してアイテムを識別することで、NoSQLテーブルからアイテムを削除できます。たとえば、パーティションキーのみ、またはテーブルのパーティションキーとソートキーの組み合わせを使用してアイテムを識別します。

Note: Catalystでは、1回のSDK操作でNoSQLテーブルから最大25件のアイテムを一括削除できます。

削除操作は、以下の例に示すようにdeleteItems()メソッドを使用して実行されます。パーティションキーfruitが「apple」に一致するアイテムが削除されます。zcatalyst-sdk-node packageのno-sql libraryは、NoSQLアイテムの定義に必要です。

const { NoSQLItem } = require('zcatalyst-sdk-node/lib/no-sql');
//パーティションキー「fruit」で値が「apple」に一致するNoSQLアイテムをテーブルから削除する
const deletedItems = await table.deleteItems({
//削除するアイテムのパーティションキー値を指定する
keys: NoSQLItem.from({ fruit: 'apple' })
});


---

## SDK — Python — NoSQL

--------------------------------------------------------------------------------
title: "コンポーネントインスタンスの取得"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、新しいNoSQLコンポーネントインスタンスを作成するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.745Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/get-component-instance/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)
- NoSQL Java SDK (/ja/sdk/java/v1/cloud-scale/nosql/get-table-metadata/)
- NoSQL Node.js SDK (/ja/sdk/nodejs/v2/cloud-scale/nosql/get-component-instance/)

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


# コンポーネントインスタンスの取得

Catalyst NoSQLは、アプリケーションの半構造化データ、非構造化データ、および異種データを格納できる、完全マネージドの非リレーショナルNoSQLデータストレージ機能です。Catalystは、キーと値のペアベースのJSON形式でのドキュメント型データストレージをサポートしています。

Catalyst NoSQL Python SDKパッケージを使用すると、プロジェクト内のNoSQLテーブルに対してCRUDデータ操作を実行できます。NoSQLテーブルのメタデータを取得したり、さまざまなサポートされるデータ型のNoSQLアイテムを作成したり、特定のテーブルでアイテムの挿入、更新、取得、または削除を行うことができます。クエリ条件を指定して、テーブルやテーブルのインデックスをクエリすることもできます。

### NoSQLインスタンスの作成

コンポーネントインスタンスは、特定のコンポーネントに固有の事前定義された設定にアクセスするために使用できるオブジェクトです。

以下に示すように、PythonでSDK操作を実行するためのNoSQLオブジェクトを作成できます。これはサーバーサイドの呼び出しを発行しません。このnosqlインスタンスは、NoSQLを操作するさまざまなコードスニペットで参照します。

NoSQLインスタンスの作成に使用されるapp参照は、SDK初期化時にレスポンスとして返されるPythonオブジェクトです。

 #NoSQLインスタンスを作成する
nosql = app.nosql()


--------------------------------------------------------------------------------
title: "テーブルメタデータの取得"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルのメタデータを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.745Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/get-table-metadata/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/ja/cloud-scale/help/nosql/create-manage-tables/)

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


# NoSQLテーブルメタデータの取得

以下に説明するように、単一のCatalyst NoSQLテーブル、またはプロジェクト内のすべてのテーブルのメタデータを取得できます。

### 単一テーブルのメタデータ取得

Catalyst NoSQLの単一テーブルのメタデータは、以下に示すようにgetTable()メソッドを使用してテーブル名を参照することで取得できます。レスポンスには、パーティションキーとソートキー、TTL属性などのテーブル設定の詳細が含まれます。

以下のコードスニペットで使用されているnosql参照は、これらの操作を実行するために作成されたコンポーネントインスタンスです。

# NoSQLインスタンスを作成する
nosql = app.nosql()
#テーブル名を使用してテーブルメタデータを取得する
table_details = nosql.get_table_resources("EmpTable")
print(table_details)

注意： テーブル名を変更した場合は、コード内の変更を更新する必要があります。

<br>
 
### すべてのテーブルのメタデータ取得

Catalystでは、以下に示すようにget_all_tables()メソッドを使用して、プロジェクト内のすべてのテーブルのメタデータを取得できます。

table_res = nosql.get_all_tables()
print(table_res)


--------------------------------------------------------------------------------
title: "テーブルインスタンスの取得"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルインスタンスを作成するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.746Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/get-table-instance/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Create and Manage Tables (/ja/cloud-scale/help/nosql/create-manage-tables/)

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


# NoSQLテーブルインスタンスの取得

Catalyst NoSQLでは、NoSQLテーブルの空のテーブルインスタンスを取得できます。このインスタンスを使用して、そのテーブルを参照し、サポートされているすべてのテーブル操作を実行できます。この処理はサーバーサイドの呼び出しを発行しません。

このセクションに示すように、テーブルの名前を参照してNoSQLテーブルのインスタンスを取得できます。以下のコードスニペットで使用されているnosql参照は、以前に作成されたコンポーネントインスタンスです。

table = nosql.get_table('employees')
# テーブル名でテーブルインスタンスを作成する


--------------------------------------------------------------------------------
title: "アイテムの構築"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、さまざまなデータ型のNoSQLアイテムを構築するメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.746Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/construct-item/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- Supported Data Types in NoSQL (/ja/cloud-scale/help/nosql/working-with-data/introduction/)

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


# NoSQLアイテムの構築

Catalyst NoSQLのアイテムは、レコードのような単一のデータポイントのデータを保持する属性のコレクションを表します。プロジェクト内の既存のNoSQLテーブルに、カスタムJSON形式でアイテムを挿入または更新できます。ただし、Catalystでアイテムを挿入または更新する前に、アイテムを構築する必要があります。

以下のセクションで説明するように、Catalystがサポートするさまざまなデータ型の属性を含むNoSQLアイテムを構築できます。CatalystはString、Number、Set of Strings、Set of Numbers、List、Mapなどのさまざまなデータ型をサポートしています。詳細については、サポートされるデータ型の完全なリストを参照してください。

テーブルに設定したパーティションキー属性の値は、すべてのデータアイテムで必ず提供する必要があります。テーブルキー、TTL属性、その他の詳細については、テーブルキーのヘルプセクションを参照してください。

以下のコードスニペットは、さまざまなデータ型の属性を持つアイテムを構築する形式を示しています：

# 異なるデータ型のNoSQLアイテムを構築する
attributes = {	
		# 文字列
		"custom_attrib_string": {
 			"S": "John Doe"
 		},
		# 数値
 		"custom_attrib_num": {
 			"N": "234521"
 		},
		# バイナリエンコード値
		 "custom_attrib_bin": {
 			"B": "SGVsbG9Xb3JsZA=="
 		},
		# 文字列のセット
		 "custom_attrib_set_string": {
 			"SS": ["John Doe", "New York", "USA"]
 		},
		# 数値のセット
 		"custom_attrib_set_num": {
 			"SN": ["23423", "821n", "11"]
 		},
		# バイナリ値のセット
		 "custom_attrib_set_bin": {
			 "SB": ["SGVsbG8=", "V29ybGQ="]
 		},
		# ブール属性
 		"custom_attrib_bool": {
			 "BOOL": True
		 },
		# リスト属性
 		"custom_attrib_list": {
			 "L": [{"name": "banana"}, {"quantity": 4}]
 		},
		# マップ属性
 		"custom_attrib_map": {
 			"M": {
 				"name": {
					 "S": "John Doe"
 				},
 				"age": {
 					"N": "23"
				 }
 			}
 		}
}


--------------------------------------------------------------------------------
title: "アイテムの挿入"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルにさまざまな方法でアイテムを挿入するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.746Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/insert-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/insert-item/#InsertNewItem)

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


# NoSQLテーブルへのアイテム挿入

Catalystでは、アイテムを構築した後、特定のNoSQLテーブルにアイテムを挿入できます。このセクションで説明するように、アイテムはさまざまな方法で挿入できます。

データの追加と操作、CatalystカスタムJSON形式、およびサポートされるデータ型に関するヘルプセクションを参照して、これらのトピックを詳しく学ぶことができます。

注意： Catalystでは、1回のSDK操作でNoSQLテーブルに最大25アイテムを一括挿入できます。

<br>

### 条件なしのアイテム挿入

CatalystカスタムJSON形式でアイテムを構築することにより、条件なしでNoSQLテーブルに新しいアイテムを挿入できます。これには、テーブルに設定されたパーティションキーとソートキー属性の値を必ず渡す必要があります。

たとえば、以下のコードスニペットでは、アイテムのパーティションキーとソートキー属性であるfruitNameとLocationの値がそれぞれ提供されています。fruitTypeやavailabilityなどのString型の他の属性は、リストfruitPropertiesとして提供されています。アイテムはinsert_items()メソッドを使用して挿入されます。

# 条件なしでNoSQLアイテムを挿入する
item = {
	 "fruitName": {
		 "S": "Banana"
 	},
	"Location": {
    "S": "Indonesia"
    },
	 "fruitProperties": {
 		"L": [
			{ 
			"fruitType": "Berries"
			},
 			{ 
    		"availability": "abundant"
  			 }
		}
		]
 	}
 } # 定義された条件に基づいてアイテムを挿入し、レスポンスで返されるアイテムを設定する。その他のサポートされている値は"OLD"と"NULL"です
res = table.insert_items({ 
	 'item': item,
	'return': 'NEW' 
})

<br>

### 条件関数を使用したアイテム挿入

CatalystカスタムJSON形式で定義した特定の条件を使用して、NoSQLテーブルの既存アイテムに属性を挿入できます。このタイプでは、テーブルの既存データが取得され、指定された条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。

Catalystは条件を評価するための複数の演算子をサポートしています。サポートされる演算子は以下のように表されます。

<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>

以下の例では、既存データのネストされた属性fruitColourが値「Yellow」を含むという条件を定義しています。この属性は属性fruitPropertiesの一部です。条件が満たされた場合、属性fruitTypeとavailabilityがアイテムに追加されます。アイテムはinsert_items()メソッドを使用して挿入されます。

# 条件関数を使用してNoSQLアイテムを挿入する
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"
    }
		}
		]
	}
 }
    # 定義された条件に基づいてアイテムを挿入し、レスポンスの戻り値を設定する。その他のサポートされている値は"OLD"と"NULL"です
 res = table.insert_items({ 
	'item': item,
	'condition': condition_function,
	'return': 'NEW' 
})

<br>

### 条件演算子を使用したアイテム挿入

Catalystでは、CatalystカスタムJSON形式で演算子で定義された条件に基づいてアイテムを挿入することもできます。テーブルの既存データが取得され、指定された条件に対して評価されます。評価がtrueの場合にのみアイテムが挿入されます。既存データがない場合、条件は無視されアイテムが挿入されます。

Catalystは条件を評価するための複数の演算子をサポートしています。これらは[前のセクション](#insert-items-with-conditional-functions)に記載されています。

以下の例では、between演算子で定義された条件に基づいてアイテムを挿入しています。条件では、既存データの属性countが0から10の間の値を持つ場合にのみ、属性backupIDとcountがそれらのアイテムに挿入されることを示しています。アイテムはinsert_items()メソッドで挿入されます。

# 条件演算子を使用してNoSQLアイテムを挿入する
condition_function = {
	"attribute": ["count"],
	"operator": "between",
	"value": {
	"L": [
		{ 
		"N": "0" 
		},
		{ 
		"N": "10"
		}
      	]
     }
    }
item = {
 	"countryCode": {
		"N": 054
			 },
		"backupID": {
			"N": 2379992
 			},
 	"count": {
      "N": "3"
     }
    }
    # 定義された条件に基づいてアイテムを挿入し、レスポンスの戻り値を設定する。その他のサポートされている値は"OLD"と"NULL"です
res = table.insert_items({ 
'item': item,
'condition': condition_function,
'return': 'NEW' 
})


--------------------------------------------------------------------------------
title: "アイテムの更新"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルのアイテムを更新するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.746Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/update-items/"
service: "Cloud Scale"
--------------------------------------------------------------------------------



# NoSQLテーブルのアイテム更新

Catalystでは、アイテムを構築した後、特定のNoSQLテーブルのアイテムを更新できます。アイテムはプライマリキーを使用して識別することで更新できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを識別できます。

次に、適切なHTTPリクエストメソッドで更新操作タイプを定義し、アイテムで更新する属性と値を提供します。

注意： Catalystでは、1回のSDK操作でNoSQLテーブルの最大25アイテムを一括更新できます。

以下の例では、パーティションキーfruitNameとソートキーlocationでアイテムを取得しています。このアイテムの更新対象の属性はcolorとtasteです。すべての属性の値が提供されています。

また、オプションで更新の条件を定義することもできます。条件が満たされた場合にのみ更新が実行されます。

# プライマリキーでNoSQLアイテムを識別して更新する
res = table.update_items({
 	"keys": {
 		"fruitName": {
			 "S": "Banana"
 			},
 		"location": {
			 "S": "Indonesia"
 			}
 		},# アイテムで更新する属性を定義する
	"update_attributes": [
 		{
 		"operation_type": "PUT",
 		"color": {
 			"S": "Yellow"
 			},
		"taste": {
    "S": "Sweet"
      },
 	"attribute_path": "fruitProperties"
 		}
 	],# 条件を定義する。この条件が満たされた場合のみアイテムが更新される。（オプション）
 	"condition" : {
 		"function": {
 			"function_name": "attribute_exists",
 			"args": [
				 {
 			"attribute_path": "fruitProperties"
 				}
 		]
 	}
}
})
print(res)


--------------------------------------------------------------------------------
title: "アイテムの取得"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルからアイテムを取得するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.746Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/fetch-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/fetch-item/#FetchItem)

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


# NoSQLテーブルからのアイテム取得

Catalystでは、NoSQLテーブルからプライマリキーでアイテムを識別して取得できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。また、必要な属性を指定して、取得する属性をオプションでフィルタリングすることもできます。

注意： Catalystでは、1回のSDK読み取り操作でNoSQLテーブルから最大100アイテムを取得できます。 

以下の例では、fetch_item()を使用して、パーティションキーfruitとソートキーlocationで識別されるアイテムを取得しています。required_objectsを使用して、propertiesやtasteなどの特定の属性がフィルタリングされて取得されます。

# パーティションキーとソートキーで識別されるNoSQLアイテムのプロパティを取得する
res = table.fetch_item({
   "keys": [
    {
     "fruit": {
      "S": "apple"
     },
     "location: {
      "S": "USA"
     }
    }
  ],
# 取得する属性を指定する
   'required_objects': ["properties", "taste"] 
 })
print(res)


--------------------------------------------------------------------------------
title: "テーブルのクエリ"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルをクエリするSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.747Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/query-table/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Table Keys (/ja/cloud-scale/help/nosql/components/#table-keys)
- Query Table (/ja/sdk/nodejs/v2/cloud-scale/nosql/query-table/)

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


# NoSQLテーブルのクエリ

Catalystでは、テーブルのプライマリキーを使用してアイテムを識別し、NoSQLテーブルをクエリしてデータを取得できます。たとえば、パーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

注意： Catalystでは、1回のSDK操作でページネーションを使用してNoSQLテーブルから最大100アイテムを一括取得できます。SDKレスポンスで受け取ったstart_keyトークンを使用して、ページネーションのロジックを構築する必要があります。

属性、その必要な値、使用するサポートされる演算子を指定して、アイテムを識別するキー条件を定義できます。グループ演算子で追加条件を指定することもできます。

サポートされる演算子は以下のように表されます。

<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>

以下の例では、パーティションキーfruitTypeを使用してアイテムを識別し、条件値を「citrus」として指定してqueryTable()メソッドでクエリを実行しています。また、属性locationが「USA」に一致する追加条件も指定しています。

Catalyst NoSQLでは、consistent_readを使用して読み取り操作をマスターまたはスレーブクラスターのどちらで実行するかを示す、返される行数の制限、昇順でのソート順の指定など、クエリの他の要素も定義できます。

注意： マスター・スレーブレプリケーションでは、マスターにはデータベースのすべてのデータが含まれ、スレーブにはマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、更新されたデータの反映に若干の遅延があるというトレードオフで、全体的なコストを削減できます。

# パーティションキーfruitTypeの値が"citrus"であるアイテムを取得するためにNoSQLテーブルをクエリする
res = table.query_table(
 {
    # consistent_readをtrueに設定してマスターからクエリする。falseの場合、スレーブからクエリされる。
   'consistent_read': 'true',# forwardScanをtrueに設定して結果を昇順でソートする。それ以外の場合は降順でソートされる。
   'forwardScan': 'true',# 値を指定して返される行数を制限する
   'limit': 10,# アイテムを識別するためのキー条件を定義する
   'key_condition': {
    'attribute': 'fruitType',
    'operator': 'equals',
    'value': {
     'S': 'citrus'
    }
   },
    # グループ演算子を使用してテーブルアイテムをクエリするための追加条件を指定する
   'other_condition': {
    'group_operator': 'and',
    'group': [
     {
     'attribute': 'location',
     'operator': 'equals',
     'value': {
      'S': 'USA'
     }
     }
    ]
   } 
 })
print(res)


--------------------------------------------------------------------------------
title: "インデックスのクエリ"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLインデックスをクエリするSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.747Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/query-index/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Table Keys (/ja/cloud-scale/help/nosql/components/#table-keys)
- Query Index (/ja/sdk/nodejs/v2/cloud-scale/nosql/query-index/)

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


# インデックスのクエリ

Catalystでは、インデックスのプライマリキーを使用してアイテムを識別し、NoSQLインデックスをクエリしてデータを取得できます。インデックスを使用すると、メインテーブルのプライマリキーを使用せずに、テーブルデータに対して代替クエリを実行できます。Catalystコンソールからインデックスを設定できます。インデックスのパーティションキーのみ、またはパーティションキーとソートキーの組み合わせを使用してアイテムを取得できます。

注意： Catalystでは、1回のSDK操作でページネーションを使用してNoSQLテーブルから最大100アイテムを一括取得できます。SDKレスポンスで受け取ったstart_keyトークンを使用して、ページネーションのロジックを構築する必要があります。

属性、その必要な値、使用するサポートされる演算子を指定して、アイテムを識別するキー条件を定義できます。グループ演算子で追加条件を指定することもできます。

サポートされる演算子は以下のように表されます。

<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>


以下の例では、一意のインデックスIDで参照されるインデックスを使用してクエリを実行しています。クエリはインデックスのパーティションキーfruitColorを使用してアイテムを識別し、条件値を「yellow」として指定しています。また、属性fruitTypeが「citrus」に一致する追加条件も指定しています。クエリはquery_index()メソッドを使用して実行されます。

Catalyst NoSQLでは、consistent_readを使用して読み取り操作をマスターまたはスレーブクラスターのどちらで実行するかを示す、返される行数の制限、昇順でのソート順の指定など、クエリの他の要素も定義できます。

注意： マスター・スレーブレプリケーションでは、マスターにはデータベースのすべてのデータが含まれ、スレーブにはマスターからのコピーが含まれます。スレーブから読み取り操作を実行すると、更新されたデータの反映に若干の遅延があるというトレードオフで、全体的なコストを削減できます。


# パーティションキーfruitColourの値が"yellow"であるアイテムを取得するためにNoSQLテーブルインデックスをクエリする# インデックスの一意のIDを渡す
cres = table.query_index('6759000000740017', {
  # consistent_readをtrueに設定してマスターからクエリする。falseの場合、スレーブからクエリされる。
   'consistent_read': 'true',# forward_scanをtrueに設定して結果を昇順でソートする。それ以外の場合は降順でソートされる。
   'forwardScan': 'true',# 値を指定して返される行数を制限する
   'limit': 10,# アイテムをクエリするためのキー条件を定義する
   'key_condition': {
    'attribute': 'fruitColor',
    'operator': 'equals',
   'value': {
     'S': 'yellow'
    }
   },
   # グループ演算子を使用してデータをクエリするための追加条件を定義する
   'other_condition': {
    'group_operator': 'AND',
    'group': [
     {
      'attribute': 'fruitType',
      'operator': 'equals',
      'value': {
       'S': 'citrus'
      }
     }
    ]
   } 
 })
print(res)


--------------------------------------------------------------------------------
title: "アイテムの削除"
description: "Catalyst NoSQLは、非リレーショナル・非SQLのデータストレージ手段を提供する、完全マネージドで強力なデータベースです。このページでは、NoSQLテーブルからアイテムを削除するSDKメソッドについて説明します。"
last_updated: "2026-08-17T13:08:49.747Z"
source: "https://docs.catalyst.zoho.com/ja/sdk/python/v1/cloud-scale/nosql/delete-items/"
service: "Cloud Scale"
related:
- NoSQL (/ja/cloud-scale/help/nosql/introduction)
- Working with Data (/ja/cloud-scale/help/nosql/working-with-data/introduction/)
- Basic Components (/ja/cloud-scale/help/nosql/components/#basic-components)
- NoSQL API (/ja/api/code-reference/cloud-scale/nosql/delete-item/#DeleteItem)

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


# NoSQLテーブルからのアイテム削除

テーブルのプライマリキーを使用してアイテムを識別することで、CatalystのNoSQLテーブルからアイテムを削除できます。たとえば、パーティションキーのみ、またはテーブルのパーティションキーとソートキーの組み合わせを使用してアイテムを識別します。

注意： Catalystでは、1回のSDK操作でNoSQLテーブルから最大25アイテムを一括削除できます。

削除操作は、以下の例に示すようにdelete_items()メソッドを使用して実行されます。パーティションキーfruitが「apple」に一致し、ソートキーlocationが「USA」に一致するアイテムが削除されます。削除の追加条件を指定することもできます。アイテムが条件に一致する場合にのみ削除されます。


# パーティションキーとソートキーで識別してテーブルからNoSQLアイテムを削除する
res = table.delete_items( {
   "keys": {
    "fruit": {
     "S": "apple"
    },
    "location": {
     "S": "USA"
    }
   }
 }),
 # 削除の条件を指定する（オプション）
		 "condition": {
			 "function": {
 			"function_name": "attribute_exists",
 			"args": [
 				{
 					"attribute_path": ["properties"]
 				}
 				]
		 	}
 		}
 })
print(res)