AWS 将 DuckDB 集成进 PostgreSQL，数据工程师该重新思考了

PostgreSQL（交易型 OLTP）　　　　　　　　S3（分析型 OLAP）
近90天订单数据　　　　　　　　　　3年历史数据，Parquet / Iceberg 格式
         │　　　　　　　　　　　　　　　    │
         │　　  　　　夜间 ETL 任务　　　   │
         └───────────► 数据拷贝 ◄───────────┘
                          │
                      统一数仓表
                          │
                       数据看板

-- one-time setup
CREATE EXTENSION aurora_analytics;

-- point at the Parquet files already sitting in S3
CREATE FOREIGN TABLE orders_history ()
SERVER s3_analytics
OPTIONS (files 's3://my-bucket/orders/*.parquet');

-- Aurora reads the Parquet metadata and infers the columns for you -
-- you don't hand-type a schema

SELECT o.customer_id, o.amount, o.created_at
FROM orders o                 -- live table in Postgres
UNION ALL
SELECT h.customer_id, h.amount, h.created_at
FROM orders_history h         -- foreign table backed by S3
WHERE h.created_at > now() - interval '3 years';

PostgreSQL（交易型 OLTP）　　　　　　　　S3（分析型 OLAP）
实时订单数据　　　　　　　　　　历史数据，Parquet / Iceberg / Glue 元数据目录
         │　　　　　　　　　　　　　　　　   │
         └────────── 单条 SQL 查询 ──────────┘
                          │
                       数据看板

package main

import (
 "context"
 "database/sql"
 "log"
 "time"
 _ "github.com/lib/pq"
)

// checkQuery times a single query and flags it if it crosses a threshold.
// Point this at your foreign-table queries after rollout - it's the
// cheapest way to catch a scan that's quietly getting expensive.
func checkQuery(ctx context.Context, db *sql.DB, label, query string, warnAfter time.Duration) {
 start := time.Now()
 rows, err := db.QueryContext(ctx, query)
 if err != nil {
  log.Printf("[%s] query failed: %v", label, err)
  return
 }
 defer rows.Close()
 count := 0
 for rows.Next() {
  count++
 }
 elapsed := time.Since(start)
 status := "ok"
 if elapsed > warnAfter {
  status = "SLOW"
 }
 log.Printf("[%s] rows=%d elapsed=%s status=%s", label, count, elapsed, status)
}

func main() {
 db, err := sql.Open("postgres", "postgres://user:pass@aurora-host:5432/mydb?sslmode=require")
 if err != nil {
  log.Fatal(err)
 }
 defer db.Close()
 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 defer cancel()
 // cheap: hits the live OLTP table, indexed lookup
 checkQuery(ctx, db, "live_orders",
  `SELECT id FROM orders WHERE customer_id = 42 LIMIT 10`,
  200*time.Millisecond)
 // potentially expensive: scans the S3-backed foreign table
 checkQuery(ctx, db, "history_scan",
  `SELECT count(*) FROM orders_history WHERE created_at > now() - interval '1 year'`,
  2*time.Second)
}