Yesterday, Thursday, November 19th, was a cold night in Edinburgh, but the wonderful Law School in the University of Edinburgh's Old College was warm and cosy for our November meetup.
We were a speaker short, though. Alastair Turner of Percona was on his way to Edinburgh when his train turned back, because an incident on the line had cancelled all northbound trains for several hours, and there was no other way for him to get here in time. Alastair spoke at our February meetup, and we were very sorry not to see him again, or to discuss his topic with him in person.
So I stepped in with an expanded version of the talk I gave at PGConf.EU last month, Radar + Radar Analyst: Agentless Diagnostic Snapshots for PostgreSQL, and a live demo. In the demo, radar collected a diagnostic snapshot from my personal server (which, slightly embarrassingly, is sub-optimally configured in some places), and radar-analyst turned it into an expert-level analysis as we watched.
If you haven't come across them yet, radar is a single Go binary that you run when something is wrong. In a few seconds, it gathers the configuration, statistics and host details that a support engineer would otherwise ask for one email at a time, writes them into a zipfile and exits. radar-analyst then checks that zipfile against a set of deterministic rules, and each finding comes with the fix for it. It can also ask an LLM to write a brief on top, but whatever the model says, a verdict can never be milder than the worst finding behind it. Both tools are released under the PostgreSQL Licence, and contributions of new rules are welcome.
đ Slides: Radar + Radar Analyst: Agentless Diagnostic Snapshots for PostgreSQL (PDF)
After a short break, and with Alastair's permission, we sat down to watch a recording of an earlier version of his talk, Gravity Wells and Guidebooks: AI Application Architecture by Analogy, from BuildDevCon's Building AI Apps with PostgreSQL ev
[...]
If PostgreSQL 18 was the storage-speed release that brought Asynchronous I/O (io_uring and worker threads) to Postgres, PostgreSQL 19 is the operational release DBAs and backend teams have been asking for since 2018.
Instead of forcing teams to bolt on external extensions for basic online maintenance or pray that a major upgrade wonât flip a critical join plan, PostgreSQL 19 ships native REPACK (CONCURRENTLY), pg_plan_advice, INSERT ... ON CONFLICT DO SELECT, parallel index autovacuum, and auto-scaling Async I/O straight in core â alongside a handful of default changes and pg_upgrade blockers that will break a blind config copy from v18.
The short verdict: should you upgrade from 18 to 19? Yes for high-churn OLTP clusters suffering from table/index bloat (
REPACK (CONCURRENTLY)+ parallel index autovacuum) and write-heavy APIs (ON CONFLICT DO SELECT). Just auditpostgresql.conffirst â leaving v18âsio_workersparameter in place triggers aFATALstartup failure,jitis nowoffby default, and SQL/PGQ graph queries did NOT make the final cut.
Most upgrade decisions come down to whether the delta justifies a pg_upgrade maintenance window. Compared directly against PostgreSQL 18, version 19 shifts the needle across operations, developer SQL, and defaults:
| Area | PostgreSQL 18 | PostgreSQL 19 | Production Impact |
|---|---|---|---|
| Async I/O (AIO) |
Fixed io_workers (io_uring / workers, ~3Ă cold scan boost)
|
Auto-scaling io_min_workers / io_max_workers + EXPLAIN (ANALYZE |
Yesterday, PostgreSQL 19 was finally released after multiple delays. Everyone already knows about the many reverts that happened, but what actually remains? Is it still an interesting release?
This blog post doesnât aim to be a complete list: the release notes are there for that.
It is only a short highlight of some of the more interesting additions.
While I do not want to go into the details about the âlost featuresâ again, the list is long.
PostgreSQL 19 was released today. pgEdge packages for it are available the same day across all of our supported deployments - including Spock, where PG 19 support is already available. I have been testing the release candidates for a few weeks, so here is what I think matters most to DBAs and teams. replaces and , and with the option it rebuilds a bloated table without blocking reads and writes. In my own test, inserts kept running at about 2,000 a second with no failed transactions while a bloated table was rebuilt in under a second. It needs a primary key or replica identity index, and it is not MVCC safe for transactions that started before the swap. Shaun Thomas wrote a blog on the topic - give it a read for more detail. gets the biggest changes for anyone running replicated clusters. Sequences can now be published with and synced with , which removes the manual step from migrations and upgrades. Logical replication can also be turned on without a restart when is replica. Subscriptions get for better conflict detection, and publications can leave tables out with ., autovacuum can now use parallel workers on indexes and ranks tables with a scoring system, so the ones that need it most go first. The and extensions let you steer the planner and keep a plan you trust. The new command gives read-your-writes consistency on standbys. are worth knowing. is faster on text and CSV input, can now write JSON, and lets a load continue past bad values. For monitoring, is now on by default, there is a new view, and the wraparound warning now starts at 100 million transactions instead of 40 million.
dbvr lets you define PostgreSQL connections and run SQL from the command line, with no graphical interface. That makes it a fit for servers, containers, and pipelines where a desktop database tool cannot run.
DBeaver Corporation announced dbvr on March 26, 2026 as a standalone CLI built on the same multi-database engine as the DBeaver desktop products. It can:
The announcement lists the commercial edition as an annual per-machine subscription with a 14-day trial. DBeaver's 26.1 release post also introduced dbvr Community, a free edition under the Apache License 2.0.Â
This post covers three steps: creating a PostgreSQL datasource, running queries, and using dbvr for production queries. Â
You will want to scan the documentation, and the code is available in all the popular package formats.Â
In dbvr, a datasource is a saved, named connection, so later commands can refer to it by name instead of repeating host and credentials. You create one with the datasource create command, using the postgres-jdbc driver.
Below I am using the gold ol' DVD Rental database on a local server
$dbvr datasource create --driver=postgres-jdbc --name=dvdrental --host=localhost --port=5432 --user=stoker --password=Secr3t --database=dvdrental
postgres-jdbc-1a1f47126cc-2a49d7ea462459bf
$dbvr datasource list
ID                      NAME    DRIVER   postgres-jdbc-1a1f47126cc-2a49d7ea462459bf  dvdrental  postgres-jdbc
The sql command runs a query or a whole script against a datasource and
Don't let the minor version increment fool you: pg_clickhouse v0.11.1, released last week, delivers a slew of improvements and bug fixes, including UPDATE, DELETE, TRUNCATE, and pgvector search pushdown.
Let's start with the latter: pgvector type mapping. Given this ClickHouse table:
CALL clickhouse_perform('ch_server', $$ CREATE TABLE items ( id Int32, category String, v Array(Float32) ) ENGINE = MergeTree ORDER BY (id); $$);
This one started with RegreSQL. Since The tests passed. The plan didn't. I've been loading production statistics into empty databases to see how much the plans alone can tell about a real workload. One paginated endpoint in a multi-tenant app wouldn't line up. Its plan was cheap, a cost of a few hundred and an estimate of one row, while pg_stat_statements in production had the same query reading thousands of buffers per call to return about eight rows.
RegreSQL compares plans by cost, and so do I. The first thing my eyes go to in a plan is the cost on the top line: small number, cheap query, move on. This query's cost couldn't see its own problem, so before deciding what RegreSQL should do about it I rebuilt the case on a synthetic schema where every row can be accounted for. Two ordinary things cause it, one tenant much bigger than the others and a query sent as a prepared statement, and between them PostgreSQL ends up planning the big tenant's query from the small tenants' runs and keeping that plan for as long as the connection lives.
Everything was captured on PostgreSQL 18.7 (the postgres:18 image) with pageinspect. The scripts are setup.sql, query.sql, late.sql and experiments.sql, which replays every plan here. setup.sql doesn't seed random(), so your week of site 1 won't be exactly 1,983 readings, but every count below is arithmetic you can redo on your own number (each reading costs the generic plan ten lookup accesses plus its scan), and the plans the planner picks come out the same. Timings are medians of EXPLAIN (ANALYZE, TIMING OFF) on my laptop, warm cache unless I say otherwise; anything closer than a tenth of a millisecond is noise.
The lab is sensor readings with the usual lookup tables hanging off them. A site is the tenant, and readings stands in for whichever tenant-scoped table grows fastest in your schema:
CREATE TABLE vendors (id int PRIMARY KEY, name text NOT NULL);
CREATE TABLE models (id int PRIMARY KEY, vendor_id int NOT NULL REFE[...]
The following speakers delivered sessions about PostgreSQL at PASS Data Community Summit, which happened from 9-11 November 2026:
On 10 November, the San Francisco Bay Area PostgreSQL Meetup Group met. Korede Aderele delivered a session.
Organizers:
On 11 November, the PostgreSQL User Group Vienna met, organized by Cornelia Biacsics & Ranjeet Meghwar. Panagiotis Stathopoulos delivered a talk.
On 12 November, the PostgreSQL Istanbul Meetup met.
Organizers:
Speakers:
On 12 November, the Postgres Meetup for All happened, organized by Elizabeth Christensen. Huseyin Demir delivered a talk.
On 12 November, Gabor Szabo hosted a meetup. âDavid Christensen and Elizabeth Christensen delivered a session.
On 12 November, the London PostgreSQL Meetup Group met, organized by
Speakers:
On 13 November, pgDay México 2026 happened.
Organizers:
Speakers:
Volunteers:
Working with the Postgres development community is such a rewarding experience.
In January 2024, Pavel Stehule asked in the hackers mailing list: why is there no VACUUM FULL CONCURRENTLY?
I happen to know that Pavel works as a consultant with some very large, very high velocity databases. He knows many interesting stories, and he doesnât ask questions just because. If he asks why donât we have VACUUM FULL CONCURRENTLY, you can bet that there is an interesting production-server story behind that.
VACUUM FULL wasn't enough
Now you, gentle reader, might be wondering what the deal is with this VA
Since June 2026, PostgreSQL security fixes have had a home of their own: a private git repository holding every pending fix as a stack of patches, and a private buildfarm that builds and tests that stack across every supported branch, continuously, before anything goes public.
Security fixes are the one kind of PostgreSQL change that canât use the normal development process. They canât be posted to pgsql-hackers, they canât go into a public commitfest, and they canât be pushed to postgresql.git and left for the public buildfarm to shake out. They have to stay under embargo until release day.
That left a gap. A fix might be reviewed carefully, but until wrap day it was a patch file passed around among a small group, or stashed in our bug tracker, often with a separate version for each of six or seven branches. Nobody was running it on the range of platforms, compilers and configurations that the buildfarm covers for ordinary commits. Then on wrap day, patches were pushed and the first broad test those fixes got is the public buildfarm, a few hours before tarballs are made.
Thatâs a lot of risk concentrated in one day, moreover the day when a broken build is most expensive.
The core of the new setup is pgsql-security, a private git repository that the security team and committers working on security issues can access. Itâs organised as a git quilt: one directory per supported branch, each holding a series file and the patches it lists, in the order they will be applied.
The patches are ordinary git format-patch output, so each carries the author, the commit message and the backpatch information that will end up in postgresql.git. A patch that applies unchanged to several branches can be listed in each branchâs series as a relative path (../master/foo.patch) instead of being copied.
Alongside the quilt, individual fixes in progress can get their own branches, which is where work happens before a fix is ready to join the stack. Work that shouldnât
[...]
Writing a Postgres extension in Rust with pgrx is a lot of fun. You write a few functions in Rust, launch an instance with cargo pgrx run and you can call these functions directly inside Postgres.
With cargo pgrx test and cargo pgrx regress, you can run unit tests and regression checks against any major version of Postgres until everything is green. Then comes the last step, and itâs the least fun one: shipping it.
Shipping a PostgreSQL means packages. A lot of packages. One for each distro (RPM/DEB), for each Postgres Major versions and for each CPU architecture. For instance with the PostgreSQL Anonymizer extension, we publish 24 packages for every releaseâŠ
Until now, the cargo pgrx package command gave you a nice directory tree and politely wished you good luck with the rest. With pgrx 0.20, that last step is gone. :-)
But before jumping into that, follow me in a quick overwiew of the new features of PGRX 0.20 which was released a few days ago !
This is a big release, with some breaking changes. Here are the highlights:
cargo pgrx migrate: assemble your upgrade scripts from small SQL fragments, one file per change.
cargo-pgrx itself compile fewer crates, and installing cargo-pgrx on Linux no longer requires the OpenSSL headers.
On Linux, cargo pgrx package can now build RPM and DEB files directly:
debian/ folder
A test says what its author expected. When the author also wrote the code, both come from the same reading of the problem, and a mistake in that reading is in both. They agree, the test passes, and the bug ships. Below is one way out of that loop for code whose answers can be computed another way: write a second implementation that is slow and plain, and compare the two on inputs neither author chose. It covers what that comparison found in a policy compiler, what it missed, and why the second implementation needs checks of its own.
The code here is a compiler. It reads a short policy ("you may view a folder if it is shared with you, or if you may view its parent") and writes PostgreSQL: views, row-level security policies, closure tables kept current by triggers, functions for single-row checks. That output is built for speed. Inheritance is not walked at query time; a table holds every ancestor of every folder, and triggers move its rows when a folder moves. Each permission can be computed two ways: as a set of ids, for lists, and as a check of one row, for writes. A lookup that another part of the permission already covers is left out.
Each of those choices is a place for a mistake. A closure row not moved on an edge case is a folder someone sees after it moved away. The fast path for lists and the fast path for one row can disagree. A test written against any of them is written by someone who knows what the optimisation was meant to do, and checks that.
The reference evaluator answers the same question with none of those choices. It reads the policy as parsed, not the compiler's model of it, and works on sets of ids in memory. Each relation is a set; each permission is computed from the sets it names. Inheritance is a loop that adds what it finds until nothing changes, a least fixed point. For the folder policy and one user, it comes down to this:
# can view = viewer or parent.view, for one user, as sets of ids
parent = {2: 1, 3: 2, 4: 3,
On a single Postgres server, primary keys stay unique because only one sequence hands out the numbers: a bigint identity column asks it for the next one, and no two rows ever get the same. Now put writers in several regions, each of them accepting inserts while the links between them are slow or down. Two regions that each ask their own sequence for âthe next numberâ will hand out the same one, and the first time those two rows meet on a subscriber, one of them is rejected.
So which primary key should we give a table that several regions write at the same time? Thatâs the question of this article. It continues the logical replication series: Part 1 listed the ways to make ids that canât collide, and Part 4 built the system that uses them, with a group of nodes in each region and every region subscribed to the others. Here we measure what each choice costs on the same workload: in size, in WAL, in joins, during failovers, and when clocks disagree.
We take the basics for granted. A primary key is a unique and non-null constraint. A generated id is a surrogate key, and it doesnât replace the natural key, because it canât stop two rows that describe the same thing. Database Normalization and Primary Keys covers both, and this article is about where the generated id comes from.
TL;DR We compared five primary keys for a table that several regions write at once. A sequence per region is the trap: when a regionâs standby is promoted, the sequence can hand out numbers that were already used. uuidv7() is cheap and needs no coordination. A composite (region, id) key lets a publication filter on the region without a second index. A bigint made of a timestamp, the region and a counter does the same with a single column, as long as the clocks agree. And whatever the key, 32 bits is a wall.
Autumn is the time when leaves change color and fall. Itâs also the time when new PostgreSQL releases come out, or at least thatâs been the tradition for quite a while.
Thereâs one more thing that autumn brings to the PostgreSQL world: PGConf.EU, the annual conference that has grown into the largest PostgreSQL community event.
This year we met in Valencia, Spain. And while Iâve attended several editions already, 2026 brought quite a few firsts for me.
Running PostgreSQL in Docker takes ten seconds to start in development â and about ten minutes to lose data in production if you copy a default compose.yaml snippet from a tutorial.
Most outages with containerized Postgres are not caused by Docker itself. They happen because Dockerâs defaults (64 MB /dev/shm, a 10-second SIGKILL timeout, unpinned :latest tags, and outdated PGDATA volume paths) collide directly with how PostgreSQL manages memory, checkpoints, and disk files.
The short checklist. Mount PG 18+ volumes at
/var/lib/postgresql(not/data), setshm_size: 1gb+, setstop_grace_period: 60s, enable--data-checksums, put PgBouncer in front of bursts, and never expose port5432on0.0.0.0.
PGDATA Mount Path
If you upgrade an older Docker Compose stack to PostgreSQL 18 or newer, the very first trap is structural.
Per the official Docker Hub postgres image documentation:
PGDATA defaulted to /var/lib/postgresql/data, and Compose files mounted volumes to /var/lib/postgresql/data.
PGDATA moved into version-specific subdirectories (/var/lib/postgresql/18/docker, and /19/docker for v19), and the official VOLUME target changed to /var/lib/postgresql.
Why did the maintainers make this breaking change? It aligns the container layout with Debianâs pg_ctlcluster convention so pg_upgrade --link can upgrade major versions cleanly inside the same parent directory in the future.
 Ollama is popular because it makes running large language models (LLMs) locally simple, private, and inexpensive. DBeaver 26.2.5, also free & open-source, recently added support for Ollama. And both pair well with PostgreSQL.
Runs AI Locally â Execute models such as Llama, Qwen, Gemma, and DeepSeek on your own computer without relying on cloud services.
Privacy and Data Control â Prompts and data can remain entirely on your machine, making Ollama attractive for sensitive business information and internal applications.
Free and Open Source â Ollama is free to use locally, with no per-token API charges. Individual models have their own licenses.
Easy Installation â Download and run models with simple commands:
ollama run llama3.2
Developer-Friendly API â Provides a local REST API compatible with many AI development tools, making integration with Python, applications, and databases straightforward.
Broad Model Support â Supports numerous open-weight models, allowing developers to experiment with different capabilities, sizes, and performance characteristics.
Works Offline â Once models are downloaded, inference can run without an internet connection.
Hardware Flexibility â Runs on macOS, Linux, and Windows, supporting CPU inference and GPU acceleration on compatible hardware.
Ollama removes much of the complexity traditionally associated with deploying LLMs. Developers can prototype AI applications, build RAG systems, experiment with AI agents, and implement natural-language-to-SQL interfaces without managing complicated inference infrastructure.
Ollama has become popular because it makes local AI accessible. It provides a straightforward way to download, run, and integrate powerful language models while retaining control over data, i
[...]Iâve made three new GitHub actions in the past few months to replace the venerable Docker-based pgxn/pgxn-tools, which has become bloated and requires more work to maintain than Iâd like. The new actions require much less maintenance, support all GitHub runner OSes and architectures, and run more quickly. What they do:
Starting simple, hereâs how to use the release action:
name: đ Release
on:
push:
jobs:
release:
name: Release on PGXN
runs-on: ubuntu-latest
steps:
uses: actions/checkout@v7
uses: pgxn/release-action@v0
with:
username: ${{ secrets.PGXN_USERNAME }}
password: ${{ secrets.PGXN_PASSWORD }}
dry-run: ${{ !startsWith( github.ref, 'refs/tags/v' ) }}
Yep, thatâs it. The pgxn/release-action action will use git archive to create a PGXN bundle and release it on PGXN. (Want to omit some files, such as GitHub workflows, from the release? Use gitattributes to exclude them!) The value passed for the dry-run option prevents publishing the bundle on PGXN except when pushing a Git tag starting with v.
The action also outputs the archive name, so you can use it elsewhere, such as a GitHub release on the last line of this workflow:
name: đ Release
on:
push:
jobs:
release:
name: Release on GitHub and PGXN
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v7
- name: Release on PGXN
uses: pgxn/release-action@v0
id: pgxn
with:
username: ${{ secrets.PGXN_USERNAME }}
password: ${{ secrets.PGXN_PASSWORD }}
dry-run: ${{ !startsWith( github.ref, 'refs/tags/v' ) }}
- name: Create GitHub Release
uses: softprops/action-gh-release@v3
if: startsWith( github.ref, 'rJust a short & quick follow-up to [yesterdays blog] before I run out the door.
I hadnât been paying attention, and yesterdayâs postgres release had a few surprises for me. Iâm catching up now.
First: read [Devrimâs blog] and [Lukasâ 5-minutes-of-postgres] for the TLDR.
Second: I had this in yesterdayâs blog â âRPM packaging now adds a header to require a specific minor. I havenât checked Debian ecosystem yet but it might also be addressing this.â
I took a quick look this morning, and Debian packaging does have the same protection.
This matters because lots of people wonât upgrade Postgres today (even though we tell them to). Next week they will try to install some new extension, and their OS packager will try to pull the latest version. Devrim and Christoph (two of our primary Postgres packagers
) have ensured that the packaging systems will protect you from a bad installation.
On Debian:
apt-mark hold postgresql-18
apt-get install -y postgresql-18-cron
Key output (installation fails):
postgres (PostgreSQL) 18.6 (Debian 18.6-1.pgdg12+2)
postgresql-18-cron : Depends: postgresql-18 (> 18.7) but 18.6-1.pgdg12+2 is to be installed
E: Unable to correct problems, you have held broken packages.
...
Allow upgrades:
apt-mark unhold postgresql-18
apt-get install -y postgresql-18-cron
postgres --version
Key output:
The following packages will be upgraded:
libpq5 postgresql-18 postgresql-18-jit postgresql-client-18
Setting up postgresql-18 (18.7-1.pgdg12+2) ...
Setting up postgresql-18-cron (1.6.8-1.pgdg12+3) ...
...
Package metadata:
apt-cache show postgresql-18-cron
Key output for selected candidate:
Version: 1.6.8-1.pgdg12+3
Depends: postgresql-18 (>> 18.7), libc6 (>= 2.14), libpq5 (>= 9.0~)
On Rocky:
Try unversioned extension installation with PostgreSQL upgrades blocked:
dnf install -y --exclude='postgresql18*' pg_cron_18
Key output (installation fails):
Problem: package pg_cron_18-1.6.8-4PGDG.rhel9.8.x86_64 from pgdg18 requires postgresql18-libs(x86-64) >= 18.7, but pgxs_extensions hash in the.pm file. The existing BlackholeFDW, FileTextArrayFDWUNRELEASED and HEAD_PLUS_UNRELEASED,locales entries can now be a hashref naming both the locale and the{ locale => 'C', encoding => 'UTF8' }. Encodings areimport-series.pl driver when present, so the farm tests exactly what agit apply rather thangit quiltimport, at full context.
../master/foo.patch) changes.
PGBuild::PatchSeries module for shared series reading, and a newcheck_patch_stack.pl script to check a patch stack.
patch_stack.log for distinct display on the server.
diagnose => 1).
git am state left behind by a failed or killed run, whichPostgres API and ABI stability has been a topic of discussion for a long time. To understand why this matters so much, start with Dave Stokes recent blog post [Is PostgreSQL Really Winning Part 2: The Evidence Beyond the Rankings]. Itâs fundamentally about âa slow core with a fast edge is a pretty good designâ and how the Postgres extension API enables an amazing ecosystem around Postgres.
The official postgres docs have [guidance on API/ABI stability], and for a bit of extra background check out [David Wheelerâs 2024 post-pgconf blog], and EnterpriseDBâs [explainer about the Postgres 17.1 ABI breakage].
The postgres community works really hard not to break ABI compatability because it means that a bunch of extensions wonât interoperate between minors. But sadly this was another of the rare cases where it was needed⊠this time as a result of CVE-2026-6460 (just one of many CVEs in the GIANT stack that 18.7 contains).
Itâs explicit in the release notes and itâs the very first bullet point. https://www.postgresql.org/docs/release/18.7
Introduce versioning logic to permit detection of composite datums that donât match the tuple descriptor we wish to interpret them with. For full protection, this change requires rebuilding C-language extensions, and there are some extensions that will require source-code changes. If necessary, the new composite_type_mismatch server parameter can be used to disable these checks, but doing so carries security risks.
This will be a pain for Postgres users. It means that extensions (which are packaged and distributed separately) need to be upgraded exactly in lockstep with the Postgres minor bugfix update itself.
One very unfortunate side-effect of the Postgres model: Postgres 18.7 has important CVE fixes â but people using extensions cannot upgrade to 18.7 and get those CVE fixes until their extensions are also updated and have released new extension versions.
Iâm doing a lot of work around extensions for CloudNativePG on Kubernetes and I saw a lot of my
[...]Last month, the Apache Software Foundation's Community Over Code came to Scotland đŽó §ó ąó łó Łó Žó ż, taking place from October 11th to 14th at the Hilton Glasgow. Even though I've been in the open source world for 25+ years, this was my first Community Over Code (!), and I loved it: great talks, an amazing hallway track with Apache community rockstars, and a Community track that I very much enjoyed. I also came away convinced that there is huge potential for synergy between the Apache data ecosystem and the PostgreSQL community.
Many thanks to the ASF and everyone who made Community Over Code Glasgow 2026 possible.
ColdFront didn't exist yet when the Call for Presentations closed, so I submitted it as a lightning talk at the last minute. On Wednesday, October 14th, I had the pleasure of presenting ColdFront: Transparent PostgreSQL Tiering to Iceberg. It was also my first lightning talk under these rules: five minutes, no laptop, no slides! Many thanks to Ruth Suehle and Brian Proffitt of the ASF for hosting.
ColdFront is one example of that synergy: it moves data from PostgreSQL to Apache Iceberg transparently, so your application keeps using plain PostgreSQL. We covered:
UPDATE, MERGE, ALTER TABLE and everything else you would expect, that successfully runs all 99 queries of TPC-DS.
The rec
[...]Number of posts in the past two months
Number of posts in the past two months
Get in touch with the Planet PostgreSQL administrators at planet at postgresql.org.