Database Tech with Fexingo: SQL, NoSQL, and Data Storage Conversations

Lucas and Luna unpack the surprisingly compact way modern time-series databases store billions of timestamps and values. They explain why classic compression tricks like dictionary encoding fall short when every data point is unique, and how delta-of-delta encoding plus XOR-based value packing — the approach popularized by Facebook's Gorilla paper — can shrink a metric stream by over 90%. The conv...

In this episode of Database Tech with Fexingo, Lucas and Luna dig into a classic but often misunderstood database performance tool: the query cache. They explain why query caches seem like a great idea but can degrade performance dramatically in write-heavy environments, using the real-world example of MySQL's query cache, which was removed in MySQL 8.0. The episode walks through the mechanics of...

In this episode of Database Tech with Fexingo, Lucas and Luna explore why denormalization—deliberately duplicating data for speed—can beat clever joins in hot paths. They walk through a concrete example: an e-commerce product page that avoids four joins by storing a precomputed fast-path row. They discuss the trade-offs: consistency risk, write amplification, and the eventual-consistency patterns...

Lucas and Luna explore the hidden costs of database triggers. While triggers automate data integrity, they often introduce performance bottlenecks, debugging nightmares, and surprising side effects. Through real-world examples, they discuss when to use triggers and when to avoid them, offering practical advice for database engineers. This episode unpacks the subtle dangers of triggers and suggests...

In this episode of Database Tech with Fexingo, Lucas and Luna drill into the hidden bottleneck that takes down applications right when they get popular: database connection pooling. They explain why connection pools exist, how they can become a single point of failure under burst traffic, and walk through a real-world scenario—a flash sale at a mid-sized e-commerce company—where the pool drains, q...

On this episode of Database Tech with Fexingo, Lucas and Luna dive into adaptive radix trees (ARTs) — a cache-friendly index structure that's quietly replacing B-trees in some of the world's most demanding databases. They start with a concrete benchmark: a 2013 paper from the Technische Universität München showed ARTs beating B-trees by over 50 percent on a 10-million-key workload while using less...

Episode 149 of Database Tech with Fexingo drills into the hidden cost of missing statistics. Hosts Lucas and Luna explain why database query optimizers rely on histograms to estimate row counts — and what happens when those estimates are stale or missing entirely. Using a concrete example: a customer orders table with 10 million rows and a status column that's 99 percent 'completed' but only 1 per...

Lucas and Luna dive into the hidden role of histograms in database query planning. When PostgreSQL's planner assumes uniform data distribution, it can pick a disastrously slow plan — like choosing a nested loop join against a table with millions of rows. They explore real-world cases where skewed data, missing statistics, and out-of-date ANALYZE lead to queries that crawl, and how extended statist...

In this episode of Database Tech with Fexingo, Lucas and Luna explore the role of sparse indexes in database performance, contrasting them with dense indexes and explaining why they are a critical tool for large-scale data retrieval. Using the example of a time-series database storing millions of sensor readings per minute, they explain how sparse indexes reduce storage overhead and speed up queri...

When a database outgrows a single machine, sharding spreads data across clusters — but naive range-based sharding concentrates hot spots and makes resharding a nightmare. In this episode, Lucas and Luna break down why consistent hashing, not simple modulo or range partitioning, is the backbone of scalable systems like Cassandra and DynamoDB. They walk through how a hash ring maps keys to nodes, ho...

In Episode 145 of Database Tech with Fexingo, Lucas and Luna dive into the hidden costs of false positives in database Bloom filters. They explore how a classic space-saving optimization can backfire when filter parameters are tuned wrong, using a real-world example from a large e-commerce catalog. The discussion covers the math of false positive rates, the trade-off between memory and disk I/O, a...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into multiversion concurrency control, the technique that lets Postgres and other databases run reads and writes simultaneously without stepping on each other. They explain why snapshots are built from visibility rules rather than locks, how a transaction's view of committed data is determined by row versioning, and why long-runnin...

In this episode of Database Tech with Fexingo, Lucas and Luna tackle a problem every database engineer has hit: you write a record, then read it back, and it's not there. That's replication lag, and it can break the read-your-writes consistency your application promises. Using a real-world example of a user updating their profile and immediately seeing the old version, they explain why lag happens...

Lucas and Luna dive into the hidden fragility of autoincrement primary keys when databases scale horizontally. They use the concrete example of a social platform that hit a key collision after sharding, explaining why the classic INTEGER AUTOINCREMENT breaks across distributed systems. The episode walks through the trade-offs of UUIDs, ULIDs, and snowflake IDs, and why the choice of key strategy i...

Cloud storage costs jumped 15% this quarter, and database admins are feeling the heat. Lucas and Luna dive into one of the most underappreciated techniques for slashing storage bills: dictionary encoding. Using a real example from a user-activity table with a country column containing just 25 distinct values among 50 million rows, they show how mapping strings to integer codes can shrink that colu...

When a database crashes mid-transaction, how does it know what to undo and what to redo? This episode explains ARIES — the Algorithm for Recovery and Isolation Exploiting Semantics — the de facto standard for crash-consistent recovery in transactional databases. Lucas and Luna break down the steal/no-force policy, the three-phase redo-undo process, and how ARIES avoids redoing already-persisted wo...

Write skew is a subtle but dangerous anomaly in database isolation. In this episode, Lucas and Luna break down the classic double-booking scenario where two appointment-scheduling transactions both succeed under snapshot isolation but shouldn't. Then they explore how Serializable Snapshot Isolation (SSI) in PostgreSQL detects the conflict via read-write dependencies and aborts one transaction, pre...

When building a user profile service, you often need to insert a new record or update an existing one atomically. Using separate INSERT and UPDATE statements under high concurrency creates race conditions and potential data corruption. This episode explores why modern databases offer upsert operations—PostgreSQL's ON CONFLICT, MySQL's ON DUPLICATE KEY, and SQLite's INSERT OR REPLACE—to guarantee a...

When a flash sale triggers a cache stampede that takes down a product catalog for hours, it's clear that cache-aside has a flaw. This episode explains why write-through caching prevents the stampede, keeps data consistent, and when it's worth the write latency. With a real-world retail example, Lucas and Luna dissect the tradeoffs between cache-aside, write-through, and write-behind strategies. #C...

Lucas and Luna dive into write-ahead logging (WAL), the mechanism that ensures your database can survive a power failure without losing data. They explain how PostgreSQL, Oracle, and SQL Server implement WAL, the performance trade-offs of synchronous vs asynchronous commit, and how checkpointing keeps the log from growing forever. A practical breakdown of a core ACID property. #WriteAheadLogging #...

Partition pruning is one of the most effective yet underappreciated optimizations in modern databases. In this episode, Lucas and Luna explore how PostgreSQL and BigQuery use partition pruning to reduce a full-table scan of a year's data down to just a single month. They walk through real-world numbers: a 12x reduction in data scanned, and a query that drops from 45 seconds to under 4. Along the w...

In this episode of Database Tech with Fexingo, Lucas and Luna explore a common yet overlooked optimization: why merge joins can outperform hash joins when both input tables are pre-sorted. Using a concrete PostgreSQL example with a 10-million-row join, they break down the trade-offs in memory pressure, CPU cache behavior, and disk spill avoidance. Lucas argues that modern optimizers often underest...

In this episode of Database Tech with Fexingo, Lucas and Luna break down a real-world query optimization: replacing a self-join with a SQL window function to compute running totals. They discuss how window functions like ROW_NUMBER, RANK, and LEAD reduce query time from seconds to milliseconds by eliminating multiple table scans. Lucas explains the OVER clause, partitioning, and ordering, and cont...

Episode 132 of Database Tech with Fexingo dives into a common but costly mistake: storing every raw time-series data point forever. Lucas and Luna examine a smart-meter company collecting one-minute readings from 10,000 meters, producing 5.2 billion data points per year. They break down the storage costs, query slowdowns, and why downsampling to hourly aggregates preserves insight while slashing i...

Most teams still schedule maintenance windows to add a column or change a table schema, but in production databases with millions of rows, those windows can stretch into hours of downtime. This episode explains why online schema migration tools like gh-ost and pt-online-schema-change are the safer, faster alternative. Lucas walks through the trigger-based and binlog-based approaches, compares lock...