{"@context": "https://schema.org", "@type": "AnalysisNewsArticle", "inLanguage": "en", "identifier": "aurora-data-api-1mb-502-chunked-read", "headline": "Aurora Data API Responses Exceeding 1 MiB Cause Admin 502 Errors: Our Reproduction and Chunked-Read Fix", "description": "Login succeeds, but the list still returns 502? We measured actual byte counts to identify the Data API limit, preserved complete audit records through chunked reads and a consistent snapshot, and provide a reusable testing method.", "abstract": "A real incident exposed the limits of pagination by a fixed record count: even 20 records can exceed the transfer limit. This article presents the measurement methodology, an implementation using 8192-character chunks, a two-part cursor, and a transaction snapshot, plus integrity checks and production validation results.", "datePublished": "2026-09-20", "dateModified": "2026-09-25T14:28:05.996835+00:00", "author": {"@type": "Person", "name": "Aperture Research Editorial Team", "jobTitle": "Engineering Practice"}, "about": ["Aurora Data API", "502", "PostgreSQL", "Chunked reads", "Engineering practice"], "category": "Cloud Computing", "authorityScore": 95, "claims": [{"text": "On September 14, 2026, login to the Aperture admin interface succeeded, but the research list endpoint returned 502, and the page reported that data had failed to load. Of the ten initialization requests, the research list request was the one that failed; the previously fixed statistics endpoint was working normally. This distinction matters: account authentication and research queries follow different paths, and logging in again cannot resolve a query response that exceeds the size limit.[S1]", "section": "Why Does the Research List Still Return 502 After a Successful Login?"}, {"text": "Production logs traced the problem to the research list query and Aurora Data API's response size limit. The query JSON for the 20 most recent complete research records totaled 1,094,895 bytes, with growing audit data for database-wide deduplication increasing the size of individual records. At the time of the failure, the amount of data transferred could continue to grow even without an increase in the number of list entries.[S1]", "section": "Why Does the Research List Still Return 502 After a Successful Login?"}, {"text": "This article reviews that incident, with code and tests pinned to the repository version publicly available on September 14. We do not treat latency measurements from a single fix as a performance guarantee for other environments, nor do we attribute all backend 502 errors to the Data API. Diagnosis should still begin with the specific failed request and its upstream error.", "section": "Why Does the Research List Still Return 502 After a Successful Login?"}, {"text": "AWS documentation specifies a 1 MiB result-set limit for the error Database response exceeded size limit. One MiB equals 1,048,576 bytes, and our query JSON at the time exceeded that amount. This byte count was a measurement of the query result, not the size of the browser page or the length of a single article's body.[S1][S4]", "section": "A Limited Row Count Does Not Mean a Limited Byte Count"}, {"text": "AWS recommends keeping the data returned by each Data API call within the limit, using multiple ExecuteStatement calls with LIMIT to retrieve results when necessary. Ordinary row-based pagination can reduce responses for many lists, but if a row contains a large audit JSON value, even LIMIT 1 cannot guarantee that a single response stays within the limit. AWS also separately documents a 64 KB per-row limit, so both the individual row size and the total response size must be considered.[S4]", "section": "A Limited Row Count Does Not Mean a Limited Byte Count"}, {"text": "We needed to preserve the deduplication evidence in full; simply truncating audit fields would prevent the admin interface from showing the complete basis for a decision. The final approach serializes query rows as JSON, splits them into character-based chunks, reads a small number of chunks at a time, and reconstructs the original records in order at the application layer. The list still returns the 20 most recent complete research records.[S1][S2]", "section": "A Limited Row Count Does Not Mean a Limited Byte Count"}, {"text": "The following SQL is a minimal example for reproducing an oversized logical field and can be run in an isolated PostgreSQL database. The content generated by repeat is only test data; local PostgreSQL can handle this field. The SQL itself does not simulate the cloud Data API gateway or automatically produce a 502 locally. To reproduce the transfer error, an actual Data API call must return this field.[S3][S4]", "section": "Measure the Problem in an Isolated Database, Then Validate the Read Strategy"}, {"text": "The read_research_rows implementation first serializes each row using row_to_json(source)::text, then assigns row_no using a stable sort. Each row is split into 8192-character chunks, with at most 8 chunks fetched per call. The outer cursor stores both row_no and chunk_no, continuing from the chunk after the last one returned. Tracking only the row number would miss subsequent chunks in the same row, while tracking only the chunk number would not distinguish between rows.[S2]", "section": "Combine Record Ordering with a Chunk Cursor"}, {"text": "The caller must supply a trusted query and a unique, stable sort key. The research list uses time and ID to determine the order, avoiding indeterminate record positions when timestamps are identical. The application concatenates the fragments of each row in sequence, then parses the complete JSON. On the final page, it must also add the last row, which has not yet been emitted, to the results.[S1][S2]", "section": "Combine Record Ordering with a Chunk Cursor"}, {"text": "8192 is a character count, not a guarantee that each chunk is only 8192 bytes. Chinese characters, emoji, and escaping affect the actual encoded size. We used a conservative chunk size and number of chunks per page to leave headroom, and included these inputs in the tests. Production use still requires checking serialization overhead, service limits, and future field changes.[S2][S3]", "section": "Combine Record Ordering with a Chunk Cursor"}, {"text": "After a single response is split across multiple queries, new research records written between queries can change the row order, or even cause successive fragments to come from different versions. PostgreSQL's Repeatable Read provides a consistent snapshot for reads within a transaction. We placed the list, detail, and associated evidence reads in the same read-only, repeatable-read transaction.[S1][S5]", "section": "Multiple Reads Require the Same Database Snapshot"}, {"text": "The read function does not start or end transactions itself; the caller is responsible for transaction boundaries. The Psycopg documentation explains that database operations start a transaction by default, and that a connection context commits on normal exit and rolls back on an exception. Transaction isolation must therefore be configured at the correct point: you cannot run a query first and then assume that a later isolation setting can change the snapshot already read.[S2][S6]", "section": "Multiple Reads Require the Same Database Snapshot"}, {"text": "The following example shows the call pattern. conn must be a connection dedicated to this request, with no other queries executed yet. Both order_by and the SQL come from application code; user input must not be interpolated directly into either parameter.[S2]", "section": "Multiple Reads Require the Same Database Snapshot"}, {"text": "Our regression tests cover four groups of boundary cases: the old query result exceeds the size limit; the latest 20 records remain complete and stably ordered; a single oversized audit record and Chinese characters, emoji, quotation marks, and newlines in the evidence are reconstructed accurately; and empty lists, missing detail records, and concurrent writes during reads behave as expected.[S1][S3]", "section": "Verifying Integrity Is More Useful Than Checking Status Codes Alone"}, {"text": "The tests use a real PostgreSQL database and check result sizes through a test connection wrapper. They can detect missing data and inconsistencies in reads, but cannot replace production gateway validation. After deployment, we separately used a browser to verify login, ten initialization requests, seven admin views, three research detail views, recovery after a refresh, and logout.[S1][S3]", "section": "Verifying Integrity Is More Useful Than Checking Status Codes Alone"}, {"text": "Running the repository tests requires installing the project dependencies and preparing an isolated PostgreSQL database in which test schemas can be created and deleted. The tests clean up their own schemas. Do not point the connection variable below at production; users must fill in the connection address according to their local configuration.[S3]", "section": "Verifying Integrity Is More Useful Than Checking Status Codes Alone"}, {"text": "After this fix, the production database read returned 20 complete research records. The complete application-layer list was 1,337,245 bytes, and a direct measurement took approximately 1.65 seconds; all ten initialization endpoints returned 200 in the browser. This application-layer list size and the query JSON size at the time of the failure were measured at different stages and from different snapshots. Dividing one by the other cannot establish a compression ratio or performance improvement.[S1]", "section": "Fix Results and Limits of Applicability"}, {"text": "Chunking addresses the limit on a single transfer; it does not eliminate the network and parsing costs of large fields. As data continues to grow, repeated serialization queries may also increase database load. If list users need only summaries, a separate design could load details on demand. Whether to change the interaction should be determined by product requirements; fields must not be silently discarded when users need audit evidence.", "section": "Fix Results and Limits of Applicability"}, {"text": "For similar failures, the troubleshooting sequence can be standardized: identify the failed endpoint and upstream error, measure the actual response size, distinguish per-row limits from total-response limits, choose pagination or chunking, and then verify integrity, consistency, and production behavior. Apply this approach to another system only when the evidence supports it.", "section": "Fix Results and Limits of Applicability"}], "sections": [{"type": "analysis", "heading": "Why Does the Research List Still Return 502 After a Successful Login?", "paragraphs": ["On September 14, 2026, login to the Aperture admin interface succeeded, but the research list endpoint returned 502, and the page reported that data had failed to load. Of the ten initialization requests, the research list request was the one that failed; the previously fixed statistics endpoint was working normally. This distinction matters: account authentication and research queries follow different paths, and logging in again cannot resolve a query response that exceeds the size limit.[S1]", "Production logs traced the problem to the research list query and Aurora Data API's response size limit. The query JSON for the 20 most recent complete research records totaled 1,094,895 bytes, with growing audit data for database-wide deduplication increasing the size of individual records. At the time of the failure, the amount of data transferred could continue to grow even without an increase in the number of list entries.[S1]", "This article reviews that incident, with code and tests pinned to the repository version publicly available on September 14. We do not treat latency measurements from a single fix as a performance guarantee for other environments, nor do we attribute all backend 502 errors to the Data API. Diagnosis should still begin with the specific failed request and its upstream error."]}, {"type": "analysis", "heading": "A Limited Row Count Does Not Mean a Limited Byte Count", "paragraphs": ["AWS documentation specifies a 1 MiB result-set limit for the error Database response exceeded size limit. One MiB equals 1,048,576 bytes, and our query JSON at the time exceeded that amount. This byte count was a measurement of the query result, not the size of the browser page or the length of a single article's body.[S1][S4]", "AWS recommends keeping the data returned by each Data API call within the limit, using multiple ExecuteStatement calls with LIMIT to retrieve results when necessary. Ordinary row-based pagination can reduce responses for many lists, but if a row contains a large audit JSON value, even LIMIT 1 cannot guarantee that a single response stays within the limit. AWS also separately documents a 64 KB per-row limit, so both the individual row size and the total response size must be considered.[S4]", "We needed to preserve the deduplication evidence in full; simply truncating audit fields would prevent the admin interface from showing the complete basis for a decision. The final approach serializes query rows as JSON, splits them into character-based chunks, reads a small number of chunks at a time, and reconstructs the original records in order at the application layer. The list still returns the 20 most recent complete research records.[S1][S2]"]}, {"type": "analysis", "heading": "Measure the Problem in an Isolated Database, Then Validate the Read Strategy", "paragraphs": ["The following SQL is a minimal example for reproducing an oversized logical field and can be run in an isolated PostgreSQL database. The content generated by repeat is only test data; local PostgreSQL can handle this field. The SQL itself does not simulate the cloud Data API gateway or automatically produce a 502 locally. To reproduce the transfer error, an actual Data API call must return this field.[S3][S4]"], "code": "SELECT octet_length(repeat('x', 1100000)) AS payload_bytes;\nSELECT repeat('x', 1100000) AS oversized_payload;"}, {"type": "analysis", "heading": "Combine Record Ordering with a Chunk Cursor", "paragraphs": ["The read_research_rows implementation first serializes each row using row_to_json(source)::text, then assigns row_no using a stable sort. Each row is split into 8192-character chunks, with at most 8 chunks fetched per call. The outer cursor stores both row_no and chunk_no, continuing from the chunk after the last one returned. Tracking only the row number would miss subsequent chunks in the same row, while tracking only the chunk number would not distinguish between rows.[S2]", "The caller must supply a trusted query and a unique, stable sort key. The research list uses time and ID to determine the order, avoiding indeterminate record positions when timestamps are identical. The application concatenates the fragments of each row in sequence, then parses the complete JSON. On the final page, it must also add the last row, which has not yet been emitted, to the results.[S1][S2]", "8192 is a character count, not a guarantee that each chunk is only 8192 bytes. Chinese characters, emoji, and escaping affect the actual encoded size. We used a conservative chunk size and number of chunks per page to leave headroom, and included these inputs in the tests. Production use still requires checking serialization overhead, service limits, and future field changes.[S2][S3]"]}, {"type": "analysis", "heading": "Multiple Reads Require the Same Database Snapshot", "paragraphs": ["After a single response is split across multiple queries, new research records written between queries can change the row order, or even cause successive fragments to come from different versions. PostgreSQL's Repeatable Read provides a consistent snapshot for reads within a transaction. We placed the list, detail, and associated evidence reads in the same read-only, repeatable-read transaction.[S1][S5]", "The read function does not start or end transactions itself; the caller is responsible for transaction boundaries. The Psycopg documentation explains that database operations start a transaction by default, and that a connection context commits on normal exit and rolls back on an exception. Transaction isolation must therefore be configured at the correct point: you cannot run a query first and then assume that a later isolation setting can change the snapshot already read.[S2][S6]", "The following example shows the call pattern. conn must be a connection dedicated to this request, with no other queries executed yet. Both order_by and the SQL come from application code; user input must not be interpolated directly into either parameter.[S2]"], "code": "from backend.research import read_research_rows\n\nconn.execute('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY')\nrows = read_research_rows(\n    conn,\n    'SELECT id, summary FROM research_runs ORDER BY id DESC LIMIT 20',\n    order_by='id DESC',\n)"}, {"type": "analysis", "heading": "Verifying Integrity Is More Useful Than Checking Status Codes Alone", "paragraphs": ["Our regression tests cover four groups of boundary cases: the old query result exceeds the size limit; the latest 20 records remain complete and stably ordered; a single oversized audit record and Chinese characters, emoji, quotation marks, and newlines in the evidence are reconstructed accurately; and empty lists, missing detail records, and concurrent writes during reads behave as expected.[S1][S3]", "The tests use a real PostgreSQL database and check result sizes through a test connection wrapper. They can detect missing data and inconsistencies in reads, but cannot replace production gateway validation. After deployment, we separately used a browser to verify login, ten initialization requests, seven admin views, three research detail views, recovery after a refresh, and logout.[S1][S3]", "Running the repository tests requires installing the project dependencies and preparing an isolated PostgreSQL database in which test schemas can be created and deleted. The tests clean up their own schemas. Do not point the connection variable below at production; users must fill in the connection address according to their local configuration.[S3]"], "code": "RESEARCH_TEST_DATABASE_URL='postgresql://USER:PASSWORD@127.0.0.1:55432/TEST_DATABASE' \\\n  .venv/bin/python scripts/test_admin_research.py -v"}, {"type": "analysis", "heading": "Fix Results and Limits of Applicability", "paragraphs": ["After this fix, the production database read returned 20 complete research records. The complete application-layer list was 1,337,245 bytes, and a direct measurement took approximately 1.65 seconds; all ten initialization endpoints returned 200 in the browser. This application-layer list size and the query JSON size at the time of the failure were measured at different stages and from different snapshots. Dividing one by the other cannot establish a compression ratio or performance improvement.[S1]", "Chunking addresses the limit on a single transfer; it does not eliminate the network and parsing costs of large fields. As data continues to grow, repeated serialization queries may also increase database load. If list users need only summaries, a separate design could load details on demand. Whether to change the interaction should be determined by product requirements; fields must not be silently discarded when users need audit evidence.", "For similar failures, the troubleshooting sequence can be standardized: identify the failed endpoint and upstream error, measure the actual response size, distinguish per-row limits from total-response limits, choose pagination or chunking, and then verify integrity, consistency, and production behavior. Apply this approach to another system only when the evidence supports it."]}], "citations": [{"publisher": "Aperture Intelligence", "title": "Fix Log for Our Admin Interface Data Loading Failure (2026-09-14)", "url": "https://github.com/milan9527/geo/blob/34b646e1f34d74c740020df4d9f59dd770449646/reports/admin-data-load-2026-09-14.md", "published_at": "2026-09-14", "source_type": "本站代码与复盘"}, {"publisher": "Aperture Intelligence", "title": "Reading Research Records in Chunks: The read_research_rows Implementation", "url": "https://github.com/milan9527/geo/blob/34b646e1f34d74c740020df4d9f59dd770449646/backend/research.py", "published_at": "2026-09-14", "source_type": "本站代码与复盘"}, {"publisher": "Aperture Intelligence", "title": "PostgreSQL Regression Tests for the Research List and Details", "url": "https://github.com/milan9527/geo/blob/34b646e1f34d74c740020df4d9f59dd770449646/scripts/test_admin_research.py", "published_at": "2026-09-14", "source_type": "本站代码与复盘"}, {"publisher": "Amazon Web Services", "title": "Troubleshooting Amazon RDS Data API", "url": "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.troubleshooting.html", "published_at": "", "source_type": "Official documentation"}, {"publisher": "PostgreSQL Global Development Group", "title": "Transaction Isolation", "url": "https://www.postgresql.org/docs/current/transaction-iso.html", "published_at": "", "source_type": "Official documentation"}, {"publisher": "Psycopg", "title": "Transactions management", "url": "https://www.psycopg.org/psycopg3/docs/basic/transactions.html", "published_at": "", "source_type": "Official documentation"}], "knowledge": {"question": {"en": "Why did Aperture’s research list return 502 after successful login, and how can oversized records be read without losing audit evidence or mixing snapshots?", "zh": "为什么 Aperture 登录成功后研究列表仍返回502，如何读取超大记录而不丢失审核证据或混用快照？"}, "audience": {"en": "Backend engineers diagnosing Amazon RDS Data API response-size failures on Amazon Aurora and maintaining PostgreSQL research lists with large audit JSON fields.", "zh": "排查 Amazon Aurora 上 Amazon RDS Data API 返回大小故障、维护含大型审核 JSON 字段的 PostgreSQL 研究列表的后端工程师。"}, "decision": {"en": "Determine whether row pagination is sufficient or serialized-record chunking is needed, based on measured response bytes and upstream errors; then validate reconstruction, snapshot consistency, and deployed behavior.", "zh": "根据实际返回字节数和上游错误，判断按行分页是否足够，还是需要对序列化记录分块；随后验证还原完整性、快照一致性和部署后的行为。"}, "contribution": {"en": "A measured incident review with an implementation using 8,192-character chunks, at most eight chunks per call, a row-and-chunk cursor, and a caller-managed Repeatable Read transaction. It also provides PostgreSQL regression tests and separate production browser verification.", "zh": "提供基于实际测量的故障复盘，以及每块8192字符、每次最多8块、行号与块号双游标、调用方管理可重复读事务的实现，并给出 PostgreSQL 回归测试与独立的生产浏览器验证。"}, "limitation": {"en": "This is one incident, not a general explanation for 502 responses or a performance guarantee. Local PostgreSQL tests do not reproduce the cloud gateway itself. Chunking retains network and parsing costs, and the before-and-after byte measurements cover different stages and snapshots, so they cannot establish compression or performance gains.", "zh": "这是单次故障复盘，不是所有502的通用解释或性能保证。本地 PostgreSQL 测试并不复现云端网关本身。分块仍有网络与解析成本，修复前后的字节测量来自不同阶段和快照，不能据此计算压缩率或性能提升。"}, "nodes": [{"key": "n1", "kind": "concept", "name": {"en": "Amazon RDS Data API response-size limits", "zh": "Amazon RDS Data API 返回大小限制"}, "mention": "Aurora Data API 的返回大小限制", "id": "concept-1f6d59a6782a359d9c51"}, {"key": "n2", "kind": "concept", "name": {"en": "Latest 20 complete research records", "zh": "最近20条完整研究记录"}, "mention": "最近20条完整研究记录", "id": "concept-fe18fa860d137551eb81"}, {"key": "n3", "kind": "entity", "name": {"en": "read_research_rows chunked reader", "zh": "read_research_rows 分块读取函数"}, "mention": "read_research_rows", "id": "entity-c2aa4d2da6254b3d86a2"}, {"key": "n4", "kind": "concept", "name": {"en": "Dual row_no and chunk_no cursor", "zh": "row_no 与 chunk_no 双游标"}, "mention": "外层游标同时保存 row_no和chunk_no", "id": "concept-12a823badcbd1befa520"}, {"key": "n5", "kind": "concept", "name": {"en": "Read-only PostgreSQL Repeatable Read transaction", "zh": "PostgreSQL 只读、可重复读事务"}, "mention": "同一只读、可重复读事务", "id": "concept-0a07adc488c978c1b23e"}, {"key": "n6", "kind": "concept", "name": {"en": "Row-based pagination", "zh": "按行分页"}, "mention": "普通按行分页", "id": "concept-43ebec6c32f40f6aa8b0"}], "edges": [{"source": "n1", "target": "n2", "relation": "constrains", "stance": "reported", "explanation": {"en": "The incident was traced to the research query’s response size: the JSON for just 20 complete records measured 1,094,895 bytes, exceeding the documented 1 MiB result-set limit.", "zh": "本次故障定位到研究查询的返回大小：仅20条完整记录的 JSON 就达到1,094,895字节，超过文档规定的1 MiB结果集限制。"}, "quote": {"en": "Production logs located the problem in the research-list query and the Aurora Data API response-size limit. The query JSON for the latest 20 complete research records totaled 1,094,895 bytes, with the continually growing database-wide deduplication audit material increasing the size of individual records.", "zh": "生产日志把问题定位到研究列表查询与 Aurora Data API 的返回大小限制。最近20条完整研究记录的查询 JSON 合计1,094,895字节，其中不断增长的全库去重审核资料增加了单条记录体积。"}, "citations": [1, 4], "sourceId": "concept-1f6d59a6782a359d9c51", "targetId": "concept-fe18fa860d137551eb81"}, {"source": "n1", "target": "n6", "relation": "constrains", "stance": "analysis", "explanation": {"en": "Row pagination does not guarantee compliance with byte limits when an individual record contains large audit JSON; both the per-row and total-response limits must be considered.", "zh": "单条记录含大型审核 JSON 时，按行分页不能保证满足字节限制；需要同时考虑单行与总响应上限。"}, "quote": {"en": "Ordinary row-based pagination can reduce the response size of many lists, but if a row contains very large audit JSON, even LIMIT 1 cannot guarantee that a single response is safe. AWS also separately describes a 64 KB per-row limit, so both individual rows and the total response should be considered.", "zh": "普通按行分页可以减少很多列表的响应，但如果一行中包含很大的审核 JSON，即使 LIMIT 1，也不能保证单次返回安全。AWS 还分别说明每行64 KB的限制，因此应同时考虑单行与总响应。[S4]"}, "citations": [4], "sourceId": "concept-1f6d59a6782a359d9c51", "targetId": "concept-43ebec6c32f40f6aa8b0"}, {"source": "n3", "target": "n2", "relation": "enables", "stance": "reported", "explanation": {"en": "The implemented chunked-reading approach reconstructs serialized records in the application rather than truncating audit fields, retaining the latest 20 complete records.", "zh": "已实现的分块读取方案在应用层还原序列化记录，而不是截断审核字段，保留最近20条完整记录。"}, "quote": {"en": "This site needs to retain deduplication evidence in full; simply truncating audit fields would prevent the admin interface from showing the complete basis for judgments. The final approach first serializes query rows as JSON, then splits them by character count, reads a small number of chunks each time, and reconstructs the original records in order at the application layer. The list still returns the latest 20 complete research records.", "zh": "本站需要完整保留去重证据，简单截断审核字段会使后台看不到完整判断依据。最终方案先将查询行序列化为 JSON，再按字符切块，每次读取少量块，在应用层按顺序还原原记录。列表仍然返回最近20条完整研究记录。[S1][S2]"}, "citations": [1, 2], "sourceId": "entity-c2aa4d2da6254b3d86a2", "targetId": "concept-fe18fa860d137551eb81"}, {"source": "n3", "target": "n4", "relation": "uses", "stance": "reported", "explanation": {"en": "The reader advances by both row number and chunk number, allowing it to resume within a record while distinguishing chunks belonging to different records.", "zh": "读取函数同时按行号和块号推进，既能从同一记录内部继续读取，也能区分不同记录的分块。"}, "quote": {"en": "The read_research_rows implementation first serializes each row with row_to_json(source)::text, then obtains row_no through stable ordering; each row is split into 8,192-character chunks, with at most eight chunks fetched each time. The outer cursor stores both row_no and chunk_no and continues reading after the last returned chunk. Recording only the row number would omit subsequent chunks of the same row, while recording only the chunk number would not distinguish multiple rows.", "zh": "read_research_rows 的实现先用 row_to_json(source)::text 序列化每一行，再用稳定排序得到 row_no；每行按8192字符切块，每次最多取8块。外层游标同时保存 row_no和chunk_no，从上次返回的块之后继续读取。仅记录行号会遗漏同一行的后续块，仅记录块号则无法区分多行。[S2]"}, "citations": [2], "sourceId": "entity-c2aa4d2da6254b3d86a2", "targetId": "concept-12a823badcbd1befa520"}, {"source": "n3", "target": "n5", "relation": "depends_on", "stance": "reported", "explanation": {"en": "The deployed approach places related reads in one read-only Repeatable Read transaction to maintain a consistent snapshot across multiple queries. The caller, not the reading function, manages the transaction boundary.", "zh": "已部署方案将关联读取放在同一只读、可重复读事务中，保持多次查询的快照一致性。事务边界由调用方而非读取函数管理。"}, "quote": {"en": "PostgreSQL’s Repeatable Read provides a consistent snapshot for reads within a transaction; this site placed list, detail, and associated-evidence reads in the same read-only Repeatable Read transaction.[S1][S5]\nThis reading function does not start or end transactions itself; the caller is responsible for transaction boundaries.", "zh": "PostgreSQL 的 Repeatable Read 为事务内的读取提供一致快照；本站将列表、详情及关联证据读取放在同一只读、可重复读事务中。[S1][S5]\n该读取函数不自行开启或结束事务，调用方负责事务边界。"}, "citations": [1, 2, 5], "sourceId": "entity-c2aa4d2da6254b3d86a2", "targetId": "concept-0a07adc488c978c1b23e"}]}, "knowledgeMap": "/knowledge", "license": {"model": "open", "price": 0.002, "currency": "USDC", "paymentProtocol": "x402", "network": "eip155:84532", "payTo": "0x23a885262A89c32eB582f4439184769dA22c467c", "variants": {"A": "/agent/v1/articles/aurora-data-api-1mb-502-chunked-read?lang=en", "B": "/agent/v1/articles/aurora-data-api-1mb-502-chunked-read/paid?lang=en"}}, "accessVariant": "A", "contentPolicy": {"citationAllowed": true, "attributionRequired": true, "trainingUse": "contact publisher"}}