Graph Queries in Postgres with Apache AGE

New ❄️ 🐘 blog! Graphing complex relationships with Apache Age and connecting to data in object store with pg_lake. 🛠️ All the things in the open source toolbox! https://lnkd.in/gecjxxeD

The data ecosystem has a habit of reinventing itself just when everyone has finished agreeing on the last standard. And we might be watching one of those inflection points again. With Apache Polaris and the Apache Iceberg REST Catalog, the conversation around “open data” is starting to feel less theoretical and a bit more real. The industry has spent years debating “open vs proprietary” when the real constraint has often been governance consistency, not file format. What’s interesting here is the cultural shift as much as the technical one, Interoperability, transparency, and shared ownership are no longer just architectural ideals; they’re becoming design requirements. If control planes are finally becoming truly vendor-neutral, does competitive advantage move away from storage formats and toward how well each ecosystem can operate on shared data? Read on for more: https://lnkd.in/ezxMb3Ya #OpenData #DataEngineering #Interoperability #OpenSource

Spring Boot: Spring Data repositories can return regular lists, paginated lists, or even streams. In some scenarios, streams are the way to go. A little article of mine on Hackernoon: #SpringBoot #JavaStream https://lnkd.in/ddrs_JbG

Never use SELECT * in production queries. Fetch only the columns you need: ✔ Better performance ✔ Lower memory usage ✔ Cleaner code #SQL

Day 50 of Only Hard SQL Challenge. This problem focuses on computing median per user without using built-in functions, along with absolute deviation for each transaction. It highlights: Window functions Ranking within partitions Handling even vs odd cases Careful edge-case consideration 🔗 https://lnkd.in/gyxSdp9P #SQL #DataAnalytics #DataScience #SQLChallenge

N+1 queries are the silent performance killer we all know about, yet they still sneak into production. I recently ran into this at work. On a small dataset, the page was fine. At scale, it started turtle loading. It’s a classic reminder that the fundamentals always matter... The problem usually starts with a simple loop. You fetch 1,000 records, then loop through them to fetch a related piece of data for each. That is 1,001 trips to the database. Even if the queries are fast, the network latency of 1,000 round-trips is what actually kills the response time. How to actually fix it: - Use a JOIN: Let the database engine do the heavy lifting in one trip. - Understand the Engine: Whether the DB uses a Nested Loop, Hash Join, or Sort-Merge, it’s doing it in-memory or on-disk locally, which is thousands of times faster than the application-level loop. - Indexing: A JOIN on an unindexed foreign key just replaces one bottleneck with another (the "Full Table Scan"). If you are interested in a high-level look at the underlying mechanics and the specific join strategies, I have shared the full post here: 👉 https://lnkd.in/e8JNjTFy

🔓 Solved a SQL Injection lab focused on hidden data retrieval through manipulation of the WHERE clause using Burp Suite. During this lab, I practiced: • SQL Injection testing techniques • HTTP request manipulation with Burp Suite • Identifying insecure query handling • Extracting hidden application data securely in a lab environment Also documented the full attack flow with a small write-up and PoC for better understanding and reproducibility. GitHub: [ https://lnkd.in/gDmPwXXr ]

During a legacy data migration, imported images kept rendering as broken files. Everything looked fine in the logs. No errors, no warnings. It took me some back and forth to finally discover that TDS was quietly truncating varbinary(max) columns on the way out. One SQL command fixed it. . . . Here's an article I wrote diving into this topic: https://lnkd.in/d7cVt76V

Everyone says "use Apache Iceberg." Nobody explains *why* it actually matters. Here's what changed for me after working with it on a production platform: The old problem: You run a query on a large table. Someone else is writing to it at the same time. You get dirty reads. Inconsistent results. Silent data corruption. What Iceberg solves: → ACID transactions on data lake tables → Time travel — query your table as it looked 3 days ago → Schema evolution — add/rename/drop columns without rewriting data → Hidden partitioning — no more wrong partition filters breaking your queries The part that actually impressed me: Iceberg tracks every change in a metadata layer. Every snapshot. Every schema version. Every partition update. Your data doesn't move. Only the metadata pointer does. That's how you get zero-downtime schema changes on a live production table. If you're still using plain Parquet on HDFS you're one schema change away from a bad day. What's your current table format? Iceberg / Delta / Hudi — or still raw Parquet? #DataEngineering #ApacheIceberg #DataLakehouse #ETL #BigData

We reached the final post of our series about extending MariaDB with a new data type using the Type_handler framework. Let's have a look at the limitations & workarounds. 🦭🧩 https://lnkd.in/dbFseKAU #mariadb #plugin