Metis Blog

Pgvector is a novel approach for storing and processing vectors with a PostgreSQL database. This greatly improves any operation on embeddings like text search or Machine Learning inference. In this post, we explore how pgvector works, how to get started, and how to tune it to get the best possible performance.

In this blog post we are going to use Sequelize to explore the IMDb dataset. We’re going to build a proper Database Monitoring around to see the performance changes and how to tune the queries. We’ll write an application in JavaScript with Express and a PostgreSQL database.

Schema migration refers to the strategic alteration of a database's structure, encompassing modifications to tables, relationships, and data types. This dynamic process is not merely a technical task, but a crucial cornerstone in maintaining the integrity, efficiency, and scalability of a database system. See this post to learn how to overcome all the problems you may face.

Fast and efficient database operations are the key for a seamless and responsive user experience that keeps customers engaged and loyal. In this article we focus on eight strategies to improve database performance. We include both hardware and software, query optimizations, configuration, and data normalization aspects.

Database is the most crucial part of each application. While we can accept some issues with the frontend or with the backend, we simply cannot let our database fail or become slow. In this post we will see the crucial database performance metrics and how to improve database performance. We will focus on monitoring, configuration, and various database engines (postgres or mysql), and we will see why they are important.

Partitions let us split the logically one large table into smaller physical ones. This can improve the queries performance by accessing fewer rows, optimizing random-access reads, and using very targeted indexes. Let’s see how it works in PostgreSQL and how Metis handles that.

We continue our journey into how Metis can prevent, monitor, and troubleshoot our databases. In previous part we started playing with Sequelize, a feature-rich ORM for TypeScript. This time we’re going to see more challenging examples. We are going to see actual insights provided by Metis and how they improve the query performance.

Let’s see how Metis can prevent, monitor, and troubleshoot our databases. In this part we’re going to play with Sequelize, a feature-rich ORM for TypeScript. We are going to see actual insights provided by Metis and how they improve the query performance.

Machine Learning is the thing! Let’s see how we can optimize queries with ChatGPT and other online solutions, and how Metis can help even better.

Let’s see how Metis can prevent, monitor, and troubleshoot our databases. In this part we’re going to prepare a database based on IMDb and start with sample queries to see actual examples. We are going to see actual insights provided by Metis and how they improve the query performance.

Databases are complex beasts. They have options for various areas like memory usage, backups, write-ahead-logs, monitoring, replication, and many more. Installing a database is just the beginning, we need to configure it accordingly later on to match our needs. In this blog post we cover the most important settings you should use.

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.