For years we’ve been focused on making Citus the best solution for scaling out your database. We’ve seen customers attain up to 100x performance when compared on the same hardware to vanilla Postgres. Of course you don’t always need to scale out to get good performance–if you have 10 GB of data a single node Postgres can work great. But at data sizes of 100 GB and up, the need to scale out may exist.

Today, with the release of Citus 5.2, it’s now easier to get started earlier so you don’t have to worry about when that moment comes where you won’t be able to scale up further. Our 5.2 release makes scaling out your memory and processing power easier by:

Supporting most major ORMs out of the box

Providing broader SQL coverage

Improving transactional semantics for a single shard

Getting started earlier with improved ORM support

For years we encouraged customers not to scale out before they needed to. We still see that as a great approach today, but you don’t have to hit 1 TB of data before you can get great performance gains. These performance gains used to come with a trade-off, you had to choose flexibility of the way you were used to working or contort your application.

Today that extra contortion isn’t needed. If you model your data up front, your application should just work, and now you can reap the benefits of scaling out your workload. The key features that make this easier for you are:

Support for the RETURNING clause on inserts.

clause on inserts. Support for sequences and SERIAL auto-incrementing columns

auto-incrementing columns Support for popular expressions as defaults, such as now()

Support for LIMIT/OFFSET

Support for custom schemas

We’ve tested popular ORMs such as Rails with ActiveRecord and Django and already heard from many customers that this release enables them to use their framework out of the box.

Broader SQL coverage

SQL is a powerful language for letting you report and access your data. We’re fans of SQL and we want you to have the full capabilities for it. Unfortunately, with a distributed system mapping single node SQL to distributed SQL can be a complex problem. Today though we’re excited to say that in certain use cases our SQL coverage can reach up to 100%.

In cases where you’re able to model your data so that joins always happen on data that is colocated we now have full SQL support. This means you can take advantage of all the powers of SQL as long as you hit a single node (which contains the particular customer or tenant ID we’re querying). Want to scale out but need to use window functions, CTEs, and more? Now you can without having to rewrite all your application level SQL.

Single node transactions

In addition to broader SQL support, we now offer stronger transactional guarantees when working with a single node. You don’t have to do anything extra to take advantage of this. BEGIN a transaction as you normally would and if it’s interacting with a distributed table your transaction will be propagated down to that node. When you’re done either COMMIT or ROLLBACK and your transaction will be handled accordingly.

In conclusion

We’re excited for all of these updates–which should allow Citus to be used more quickly and easily. Whether you’re at 100 GB or 100 TB, you shouldn’t have to lose all the other benefits that come with a robust database like Postgres. The 5.2 release is one more step closer to making scaling simple so you can focus on your app. Give it a try locally today or sign up for Citus Cloud and boot a 5.2 cluster to take advantage of all the new features.