AWS.RDSData reference

BatchExecuteStatement

Source: src/AWS/RDSData/BatchExecuteStatement.ts

Runtime binding for rds-data:BatchExecuteStatement — run one SQL statement over many parameter sets in a single Data API call (bulk insert/update/delete).

Bind it to a Data-API-enabled DBCluster and its credentials secret, exactly like AWS.RDSData.ExecuteStatement; provide the implementation with Effect.provide(AWS.RDSData.BatchExecuteStatementHttp).

BatchExecuteStatement: Batch Writes

// init — bind alongside your other Data API operations
const batchExecuteStatement = yield* AWS.RDSData.BatchExecuteStatement(
  db.cluster,
  { secret: db.secret, database: "app" },
);

// runtime — one statement, one parameter set per row
const result = yield* batchExecuteStatement({
  sql: "INSERT INTO todos (id, title) VALUES (:id, :title)",
  parameterSets: rows.map((row) => [
    { name: "id", value: { longValue: row.id } },
    { name: "title", value: { stringValue: row.title } },
  ]),
});

BeginTransaction

Source: src/AWS/RDSData/BeginTransaction.ts

Runtime binding for rds-data:BeginTransaction — open a Data API transaction and get back a transactionId to thread through subsequent ExecuteStatement/BatchExecuteStatement calls.

Bind it to a Data-API-enabled DBCluster and its credentials secret; provide the implementation with Effect.provide(AWS.RDSData.BeginTransactionHttp). Pair with AWS.RDSData.CommitTransaction / AWS.RDSData.RollbackTransaction to finish the transaction.

BeginTransaction: Transactions

// init
const beginTransaction = yield* AWS.RDSData.BeginTransaction(db.cluster, {
  secret: db.secret,
  database: "app",
});
const executeStatement = yield* AWS.RDSData.ExecuteStatement(db.cluster, {
  secret: db.secret,
  database: "app",
});
const commitTransaction = yield* AWS.RDSData.CommitTransaction(db.cluster, {
  secret: db.secret,
});

// runtime
const tx = yield* beginTransaction();
yield* executeStatement({
  sql: "INSERT INTO todos (id, title) VALUES (:id, :title)",
  parameters: [
    { name: "id", value: { longValue: 1 } },
    { name: "title", value: { stringValue: "buy milk" } },
  ],
  transactionId: tx.transactionId,
});
yield* commitTransaction({ transactionId: tx.transactionId! });

CommitTransaction

Source: src/AWS/RDSData/CommitTransaction.ts

Runtime binding for rds-data:CommitTransaction — commit a Data API transaction opened with AWS.RDSData.BeginTransaction.

Bind it to the same DBCluster and credentials secret as the rest of the transaction; provide the implementation with Effect.provide(AWS.RDSData.CommitTransactionHttp).

CommitTransaction: Transactions

// init
const commitTransaction = yield* AWS.RDSData.CommitTransaction(db.cluster, {
  secret: db.secret,
});

// runtime — after statements executed with tx.transactionId
const commit = yield* commitTransaction({ transactionId: tx.transactionId! });
// commit.transactionStatus === "Transaction Committed"

ExecuteSql

Source: src/AWS/RDSData/ExecuteSql.ts

Runtime binding for the deprecated rds-data:ExecuteSql API (Aurora Serverless v1 era). Prefer AWS.RDSData.ExecuteStatement, which supports named parameters and transactions.

Bind it to a Data-API-enabled DBCluster and its credentials secret; provide the implementation with Effect.provide(AWS.RDSData.ExecuteSqlHttp).

ExecuteSql: Legacy SQL Execution

// init
const executeSql = yield* AWS.RDSData.ExecuteSql(db.cluster, {
  secret: db.secret,
  database: "app",
});

// runtime — statements are passed as a single string, no parameters
const result = yield* executeSql({ sqlStatements: "SELECT 1" });

ExecuteStatement

Source: src/AWS/RDSData/ExecuteStatement.ts

Runtime binding for rds-data:ExecuteStatement — run a SQL statement against an Aurora cluster over the HTTP Data API (no VPC attachment or database socket required).

Bind it to a DBCluster (with the Data API enabled via enableHttpEndpoint: true) and the Secrets Manager secret holding the database credentials. The cluster ARN, secret ARN, and database name are injected automatically, and the function is granted rds-data:ExecuteStatement plus secretsmanager:GetSecretValue on the secret. Provide the implementation with Effect.provide(AWS.RDSData.ExecuteStatementHttp).

ExecuteStatement: Executing Statements

Query with Named Parameters

export default MyFunction.make(
  { main: import.meta.url, functionUrl: true },
  Effect.gen(function* () {
    const db = yield* AWS.RDS.Aurora("AppDb", {
      subnetIds: [subnetA.subnetId, subnetB.subnetId],
      securityGroupIds: [dbSecurityGroup.groupId],
    });
    // init — bind the operation to the cluster + admin secret
    const executeStatement = yield* AWS.RDSData.ExecuteStatement(db.cluster, {
      secret: db.secret,
      database: "app",
    });

    return {
      fetch: Effect.gen(function* () {
        // runtime — parameterized SQL over the Data API
        const result = yield* executeStatement({
          sql: "SELECT id, title FROM todos WHERE id = :id",
          parameters: [{ name: "id", value: { longValue: 1 } }],
        });
        return yield* HttpServerResponse.json({ records: result.records ?? [] });
      }).pipe(Effect.orDie),
    };
  }).pipe(Effect.provide(AWS.RDSData.ExecuteStatementHttp)),
);

Write Inside a Transaction

// pass a transactionId from AWS.RDSData.BeginTransaction to make the
// statement part of that transaction
yield* executeStatement({
  sql: "INSERT INTO todos (id, title) VALUES (:id, :title)",
  parameters: [
    { name: "id", value: { longValue: 42 } },
    { name: "title", value: { stringValue: "ship it" } },
  ],
  transactionId: tx.transactionId,
});

RollbackTransaction

Source: src/AWS/RDSData/RollbackTransaction.ts

Runtime binding for rds-data:RollbackTransaction — roll back a Data API transaction opened with AWS.RDSData.BeginTransaction, discarding every statement executed under its transactionId.

Bind it to the same DBCluster and credentials secret as the rest of the transaction; provide the implementation with Effect.provide(AWS.RDSData.RollbackTransactionHttp).

RollbackTransaction: Transactions

// init
const rollbackTransaction = yield* AWS.RDSData.RollbackTransaction(
  db.cluster,
  { secret: db.secret },
);

// runtime — abandon the transaction; its inserts never become visible
const rollback = yield* rollbackTransaction({
  transactionId: tx.transactionId!,
});
// rollback.transactionStatus === "Rollback Complete"