Metis Blog

One of the good practices for database design is normalization. We decompose data into multiple tables to avoid duplication and make data storage more organized. As an outcome, we need to join tables when querying the data. SQL engine needs to calculate the result of the join operation, and there are multiple join strategies (algorithms) that can be used. In this blogpost we’ll understand typical join algorithms and when they’re used.

Collecting data from multiple sources poses multiple risks. Missing values can be represented differently. Dates may be parsed incorrectly. International strings may get wrong encoding. In this post we are going to see various issues that may occur during the problem, and how to address them along the way.

SQL engine needs to execute the query somehow. But how does it do that? And how can we get some insights into details? In this blog post we’ll see what is an SQL, why it's important, and what tools to use to read it.

SQL databases are often used as black boxes. We just create tables, insert some data, and query it later. We rarely think what data we get as an output of a SELECT statement. We just assume it’s “the data”. However, it is not as simple as it may seem. In this post we are going to see how to control the visibility of changes that are not yet persisted in the database.

CLI tools often have similar interface. They have parameters, default values, some auto-completion. We would like to be able to define such an interfance in an easy way. At Metis, we decided to build a library to support these typical CLI elements, and we decided to release it on an MIT license. In this post we describe what we did and how we approached this problem.

PostgreSQL database queries are a common performance bottleneck for many reasons. There are well known techniques for speeding up the queries, like caching or read replicas. They can save a lot of time and headache, however, it may not be straightforward how to introduce them to the existing codebase. One of the solutions that seems like it can be applied much easier is indexing. In this post we’re going to examine indexes on a JSONB data type. We’ll see what they are, how they are constructed under the hood, and what dimensions to consider to assess the performance improvement.

In this post we’re going to learn how to save ourselves from deploying an invalid code to production. We’ll consider various areas, like data quality, performance, data loss, and we’ll see what a good database observability solution is.