Metis Blog

Last time we saw what could be the reason for high CPU usage. In this blog post we are going to see some troubleshooting scenarios and queries that can help us identify and fix the issue.

High CPU usage in our database may indicate multiple issues. There could be a lot of calculations performed in the background. Our database could be lacking available memory and do a lot of paging. The database could as well spend a lot of time on busy waiting. In this post we are going to see how to deal with such cases.

We want our applications to never fail. To achieve that, we need to guarantee that the data storage is always on. How to do that with SQL databases? How to make sure that the engine never fails? And how to scale it to get better performance?

Choosing a database is hard, however, maintaining it afterwards is even harder. In this post we talk about elements to focus on, tooling, monitoring, and other aspects of keeping the database up and running.

Modern SQL engines need to perform multiple operations concurrently and in parallel. This poses multiple problems around protecting data consistency and shared memory. In this blog post we are going to see what mechanisms are used to protect the memory from corruption, and how isolation levels are implemented under the hood.

Most of us know how to SELECT data, JOIN tables, or use subqueries. However, Data Query Language (DQL) part of the SQL gives us much more. Let’s see how to use Common Table Expressions (CTE) and Window Functions to enhance our queries significantly and make them easier to maintain.

SQL database provides multiple ways of auditing what happened in the database. In this blog post, we’re going to examine various solutions, analyze performance, cognitive load, and other aspects of the solution.

Choosing a database for the next project may not be easy. There are numerous aspects to consider, and the decision will mostly stay with us for a long time. In this post we examine various different solutions, and provide a general guidance on what to think about during the selection process.

Object Relational Mapper is a library that takes care of mapping the domain model into the database entities and the other way round. While the library is smart, it sometimes cannot figure out how to do things efficiently. This may result in poor performance and lesser user experience. In this blog post we’re going to see what issues we may face, and how to avoid them.

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.