I Tested It After Aurora DSQL Was Announced to Improve Write Throughput by Up to 50%

I Tested It After Aurora DSQL Was Announced to Improve Write Throughput by Up to 50%

On a new cluster, I tried a single transaction with 3,000 row INSERTs and UPDATEs. On the existing cluster, CommitLatency had improved by about 25% since late October.
2026.11.20

This page has been translated by machine translation. View original

Introduction

On November 19, 2026, AWS announced higher write throughput for Amazon Aurora DSQL.

https://aws.amazon.com/about-aws/whats-new/2026/11/aurora-dsql-higher-write-throughput/

Thanks to improvements in the storage layer, write throughput is said to increase by up to 50%.

This article presents the results of testing the behavior on a new Aurora DSQL cluster, as well as checking the performance changes on an existing cluster that has been running for about 3 months with Database Insights enabled.

Test Environment

  • Region: ap-northeast-1 (new single-region cluster)
  • Connection: psql (admin role)
  • Time measurement: psql's \timing (client-side time, including communication time). Each condition was run 3 times
  • Version: PostgreSQL 16 (result of select version())

Test Details

INSERT

I created two tables with small row sizes, and INSERTed 3,000 rows and 3,001 rows generated with generate_series, each in a single transaction.

CREATE TABLE t_3000  (id bigint PRIMARY KEY, val text NOT NULL);
CREATE TABLE t_3001  (id bigint PRIMARY KEY, val text NOT NULL);
\timing on
\echo === 3000 rows
BEGIN;
INSERT INTO t_3000 SELECT g, 'x' FROM generate_series(1, 3000) AS g;
COMMIT;
SELECT count(*) AS rows_t_3000 FROM t_3000;

\echo === 3001 rows
BEGIN;
INSERT INTO t_3001 SELECT g, 'x' FROM generate_series(1, 3001) AS g;
COMMIT;
SELECT count(*) AS rows_t_3001 FROM t_3001;
Rows INSERTed per transaction Result Error Rows after COMMIT INSERT statement time (3 runs; for failures, until the error is returned)
3,000 Success (INSERT 0 3000) None 3,000 188 / 98 / 103 ms
3,001 Failure (ROLLBACK) ERROR: transaction row limit exceeded 0 73 / 36 / 60 ms

The quotas documentation states that the number of rows that can be modified in a single transaction is 3,000. The results this time matched that description.

https://docs.aws.amazon.com/aurora-dsql/latest/userguide/CHAP_quotas.html

UPDATE

I created the table t_10000 and loaded 10,000 rows in 4 batches of 2,500 rows.

Creating the table and loading 10,000 rows
CREATE TABLE t_10000 (id bigint PRIMARY KEY, val text NOT NULL);

\echo === populate 10000 rows (2500 x 4)
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(1, 2500) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(2501, 5000) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(5001, 7500) AS g;
COMMIT;
BEGIN;
INSERT INTO t_10000 SELECT g, 'x' FROM generate_series(7501, 10000) AS g;
COMMIT;
SELECT count(*) AS rows_t_10000 FROM t_10000;

The UPDATE SQL is as follows.

\timing on
\echo === UPDATE 3000 rows
BEGIN;
UPDATE t_10000 SET val = 'y' WHERE id <= 3000;
COMMIT;
SELECT count(*) AS updated FROM t_10000 WHERE val = 'y';
Rows UPDATEd per transaction Result Error Rows updated after COMMIT UPDATE statement time (3 runs)
3,000 Success (UPDATE 3000) None 3,000 748 / 736 / 729 ms

Performance Changes on an Existing Cluster

I also checked whether write-related metrics changed on an existing cluster.

The target is a single-region cluster in us-west-2. It has a table that holds 50,000 to 100,000 vectors as JSONB, and there were no changes on the application side.

I looked at about 3 months of data, from August 19 to November 19, 2026, which was the period available, using Database Insights and CloudWatch metrics.

Changes in CommitLatency

The metric that changed was CommitLatency (the P50 of the commit phase of write transactions). The distribution by period, limited to hours with 10 to 200 write transactions per hour, is as follows.

Period Hours 25th percentile Median 75th percentile
Oct 20 – 27 114 10.3 ms 11.2 ms 12.6 ms
Oct 28 – Nov 4 113 8.0 ms 8.6 ms 9.2 ms
Nov 5 – 12 99 7.7 ms 8.4 ms 9.3 ms
Nov 13 – 19 98 7.7 ms 8.4 ms 9.1 ms

Starting from October 28, about 3 weeks before the announcement date (November 19), CommitLatency improved by about 25%.

Summary

It was announced that the write throughput of Amazon Aurora DSQL improves by up to 50%.

On an Aurora DSQL cluster that had been running continuously since before the announcement, CommitLatency improved by about 25% in late October with no changes on the application side. It is reasonable to infer that it is benefiting from the improved write throughput.

On the same day, PL/pgSQL support for Aurora DSQL was also released.

https://dev.classmethod.jp/articles/aurora-dsql-plpgsql-functions-procedures/

If DSQL's I/O or transaction performance was an issue for you, please give it another try.

Share this article

AWSのお困り事はクラスメソッドへ