Apache Cassandra Nodes
Apache Cassandra is a distributed wide-column database built for heavy write loads such as sensor readings and event history. MaestroHub provides six nodes for it: CQL queries, key reads, row writes, deletes, single statements and batches — all against the keyspace the connection profile names.
Rows cross the boundary as plain JSON objects keyed by column name, and a downstream node reads result.rows[0].celsius directly.
For the connection, the function types and their fields, see the Apache Cassandra connection guide.
Configuration Quick Reference
| Field | What you choose | Details |
|---|---|---|
| Parameters | Connection, Function, Function Parameters, Timeout Override | Select the connection profile (which fixes the cluster and keyspace), the function, values for any ((parameter)) the function uses, and optionally a timeout override. |
| Settings | Description, Timeout (seconds), Retry on Timeout, Retry on Fail, On Error | Node description, maximum execution time, retry behavior on timeout or failure, and error handling strategy. All execution settings default to pipeline-level values. |
Cassandra Query Node
Run a CQL SELECT with values bound to ? markers.
The limit is sent to Cassandra as the page size, so it bounds what the cluster reads. When more rows may follow, the result carries a paging state that resumes the next run where this one stopped. Only SELECT runs here — other statements belong in Execute Statement.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Query | Read the rows a CQL SELECT selects | A device's readings in a time window, the latest value per device, paging through a partition |
Cassandra Read Rows Node
Read the rows of one partition by primary key, without writing CQL.
Name the partition key, and optionally leading clustering columns, as a JSON object. A key that matches nothing is not an error: the node succeeds with an empty result.rows, so a pipeline branches on the lookup.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Read Rows | Read one partition, or one row of it | Enrichment lookups, a machine's current record, existence checks |
Cassandra Write Rows Node
Insert or overwrite up to 1,000 rows in one call.
Each JSON field is bound to the column of the same name and converted to its type. A row with the same primary key is overwritten, so a replay writes the same data again. With Insert Only, rows that already exist are left as they were and listed in result.notApplied.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Write Rows | Store one row or a list of rows | Persisting sensor readings, upserting machine records, create-only registration |
Cassandra Delete Rows Node
Delete one row by its full primary key, or a whole partition by its partition key.
Deleting rows that are not there succeeds, so the node is safe to replay. With If Exists, result.applied says whether the row was there.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Delete Rows | Remove rows by key | Retention cleanup, erasure requests, compensating actions |
Cassandra Execute Statement Node
Run one CQL statement: an UPDATE of a counter, a conditional INSERT … IF NOT EXISTS, a CREATE TABLE.
A lightweight transaction reports whether its condition held in result.applied; when it did not, result.rows carries the row as it is.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Execute Statement | Any single CQL statement | Counter updates, conditional writes, schema setup |
Cassandra Execute Batch Node
Run up to 100 INSERT, UPDATE and DELETE statements as one logged, unlogged or counter batch.
A logged batch is atomic: once Cassandra accepts it, every statement is eventually applied. A batch is never buffered and replayed by store-and-forward, because its statements may increment counters.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Execute Batch | Several statements applied together | Writing a reading and updating its device summary, moving a row between partitions |
Paging through a query
When more rows may follow, result.truncated is true and result.pagingState carries the position. Feed it into the next run's Paging State, with the same query and values:
run 1: limit 100 → result.pagingState "…", result.truncated true
run 2: pagingState from run 1 → result.pagingState "…", result.truncated true
run 3: pagingState from run 2 → result.truncated false, no paging state
Output
Rows are plain JSON objects keyed by column name. Text carries UUIDs, IP addresses, decimals and varints too wide for a JSON number; timestamps are RFC 3339 in UTC; dates are YYYY-MM-DD; blobs are base64; lists and sets are arrays; maps and user-defined types are objects; a tuple is an array. A null column is null.
result.warnings carries the cluster's own client warnings for the request — an aggregation without a partition key, a batch over the warn threshold — and is empty when there are none.
Query
| Key | Description |
|---|---|
result.rows | The rows, as JSON objects keyed by column name |
result.count | How many rows came back |
result.columns | The column names in the order the cluster returned them |
result.truncated | Whether more rows may follow — true exactly when result.pagingState is present |
result.pagingState | Feed it back as the next run's Paging State to resume. Absent on the last page |
result.warnings | The cluster's client warnings |
Read Rows
| Key | Description |
|---|---|
result.table | The table read, as keyspace.table when it is not in the connection's keyspace |
result.key | The key the read was made against |
result.rows | The rows the key matched, in clustering order — empty when it matched none |
result.count | How many rows came back |
result.columns | The column names in the order the cluster returned them |
result.truncated | Whether more rows may follow — true exactly when result.pagingState is present |
result.pagingState | Feed it back as the next run's Paging State to resume. Absent on the last page |
result.warnings | The cluster's client warnings |
Write Rows
| Key | Description |
|---|---|
result.table | The table written |
result.count | How many rows the call carried |
result.written | How many rows the cluster wrote |
result.notApplied | With Insert Only, the rows that already existed, each as {index, existing}. Empty otherwise |
Delete Rows
| Key | Description |
|---|---|
result.table | The table the rows were deleted from |
result.key | The key the delete was made against |
result.applied | false only with If Exists, when no row had the key |
Execute Statement
| Key | Description |
|---|---|
result.applied | false only when the statement's condition (IF …) did not hold |
result.rows | Rows the statement returned — a SELECT's rows, or the current row of a condition that did not hold |
result.count | How many rows came back |
result.columns | The column names in the order the cluster returned them |
result.truncated | Whether the statement returned more than the 1,000 rows delivered |
result.warnings | The cluster's client warnings |
Execute Batch
| Key | Description |
|---|---|
result.batchType | logged, unlogged or counter |
result.count | How many statements the batch carried |
result.applied | false only for a conditional batch whose condition did not hold — then nothing was applied |
result.rows | For a conditional batch that did not apply, the rows as they are. Empty otherwise |
result.warnings | The cluster's client warnings |