OffNet Newsroom

Daily topic roundup

Database Technology

Thursday, September 03, 2026 · 8 stories, curated & summarized — click any story for the source.

AWS What's New awsdatabase

AWS RDS for SQL Server adds 18 trace flags for fine-tuning

Amazon RDS for SQL Server now supports 18 additional SQL trace flags configurable via database parameter groups. These switches allow DBAs to modify engine behaviors like cardinality estimation, lock escalation, and memory handling. This update provides greater flexibility to optimize workload performance and stability directly within the managed service.

  • 18 new trace flags are now available in RDS SQL Server parameter groups
  • Enables fine-tuning of query optimizer and lock escalation behaviors
  • Improves ability to stabilize workloads without OS-level access
  • Specific flags like 647 and 9481 address plan optimization and DDL
  • No need for external workarounds to apply these engine-level switches
BY THE NUMBERSNew Trace Flags Added18New configurable trace flagsFine-tune optimizer and lock escalation in RDS

Percona introduces Mongorewind to address the latency of restoring full production backups for pre-production testing. This tool allows teams to reset or rewind test data states directly, eliminating the need for expensive and time-consuming full database restores. The approach targets workflows where frequent test data isolation is required without the overhead of traditional backup mechanisms.

  • Eliminates time wasted restoring full production backups for test environments
  • Enables faster test cycle iteration by rewinding data states on demand
  • Reduces storage and I/O overhead associated with large backup operations
  • Simplifies pre-production testing workflows for MongoDB deployments

The text2ql framework replaces traditional LLM-dependent natural language-to-database tools with a language-agnostic Intermediate Representation (QueryIR) and pluggable renderers. It supports both SQL and GraphQL through a unified detection pipeline and offers a deterministic zero-LLM mode that achieves 100% execution accuracy with 3.2 ms median latency. Additionally, every generated query includes a runtime confidence signal to flag potential semantic errors.

  • Uses a language-agnostic QueryIR to unify SQL and GraphQL generation in a single pipeline.
  • Zero-LLM deterministic mode ensures 100% execution accuracy with 3.2 ms latency and no API costs.
  • Runtime confidence signals provide immediate feedback on semantic correctness of generated queries.
  • Open-source Python framework with pluggable renderers for flexible backend integration.
  • Eliminates reliance on large language model inference at query time for structured targets.
BY THE NUMBERSZero-LLM SQL and GraphQL Generation100%Execution accuracy with zero LLMs3.2 ms median latency, no API costs

Christophe Pettus introduces the log_replication_commands GUC, which forces logging of replication protocol commands sent by walsenders. This setting effectively applies the log_statement = all directive specifically to replication sessions, covering commands like IDENTIFY_SYSTEM and CREATE_REPLICATION_SLOT. The author explicitly recommends enabling this parameter to gain visibility into replication traffic that is otherwise silent.

  • Enables logging for replication protocol commands like START_REPLICATION and CREATE_REPLICATION_SLOT.
  • Acts as log_statement=all but scoped strictly to walsender connections.
  • Critical for auditing replication activities and troubleshooting sync issues.
  • Set via GUC to ensure all replication interactions are captured in logs.

Christopher Winslett explains how PostgreSQL treats NULL as an unknown marker rather than a value, allowing queries to succeed where arithmetic or type casts would otherwise fail. This unknown state propagates through comparisons, aggregates, and window functions, often yielding results that silently diverge from developer expectations. The piece argues that enforcing NOT NULL constraints is essential to prevent these ambiguity-driven logic errors in application code.

  • NULL propagates through arithmetic and comparisons, returning unknown rather than erroring.
  • Aggregates and window functions handle NULLs silently, masking data quality issues.
  • Defensive schema design using NOT NULL constraints prevents ambiguous logic paths.
  • Distinguish between legal operations (like NULL division) and illegal ones (like zero division).

Jimmy Angelakos released a recording and slides from a LinkedIn Live session on managing inherited poor-quality databases. The discussion, based on Chapter 11 of his book PostgreSQL Mistakes and How to Avoid Them, addresses common causes like rushed deadlines and lack of DBA oversight. The format was a fireside chat that included a Q&A segment to help practitioners handle these legacy situations.

  • Recording and slides are now available for the LinkedIn Live session on inherited bad databases.
  • Content is derived from Chapter 11 of Jimmy Angelakos's book on PostgreSQL mistakes.
  • Session covers historical reasons for poor database design, such as rushed deadlines and organic growth.
  • Includes a Q&A segment addressing practical scenarios for data professionals.

The Polars team has released a pre-release version of Polars 2.0, signaling significant architectural improvements ahead of the stable launch. This update focuses on enhanced performance characteristics and refined API ergonomics for data engineering workflows. Practitioners are encouraged to test this pre-release to identify potential breaking changes before the final release.

  • Polars 2.0 pre-release is now available for testing and feedback.
  • Expect significant performance optimizations and API refinements.
  • Review documentation for breaking changes prior to adoption.
  • Suitable for early adopters in data engineering pipelines.
CHECKLISTPolars 2.0 Adoption StepsTest the pre-release version nowCheck for API breaking changesReview performance optimization docsIntegrate into data pipelines
AWS Database Blog awsdatabase ↺ since 09-01

Fix circular role dependencies before PostgreSQL 15+ RDS upgrades

Major version upgrades from PostgreSQL 14 or earlier to 15 or later on Amazon RDS and Aurora PostgreSQL may stall or roll back if circular role dependencies exist. AWS provides a specific pre-upgrade query to detect these problematic dependencies. Resolving them beforehand ensures a smooth upgrade process without interruption.

  • Upgrades to PG 15+ can fail due to circular role dependencies
  • Use the provided pre-upgrade query to detect issues early
  • Resolve dependencies before starting the version upgrade process
  • Prevents upgrade stalls and automatic rollback events
  • Applies to both RDS and Aurora PostgreSQL engines

Fleet impact: For RDS/Aurora PostgreSQL fleets, run the pre-upgrade dependency check immediately; circular roles cause upgrade stalls or rollbacks on PG 15+ migrations. Audit role assignments and break cycles before scheduling maintenance windows.

↑