Category: All posts
Apr 14, 2025
Posted by
Jônatas Davi Paganini
In case you missed the quiet launch of our timescaledb-ruby gem, we’re here to remind you that you can now connect PostgreSQL and Ruby when using TimescaleDB. 🎉 This integration delivers a deeply integrated experience that will feel natural to Ruby and Rails developers.
PostgreSQL has long embraced language independence, but we understand that every developer community brings its own preferences, practices, and expectations when working with databases. Seamless database integration leads to faster data access, better performance, and greater scalability, so our goal is clear: support developers in their current environments and make TimescaleDB feel like a native part of any PostgreSQL workflow, no matter the programming language they use.
This integration journey began with Ruby and the continuous aggregates macro, which lets you easily define real-time materialized views that automatically stay up to date as new data comes in—with a single line of Ruby code. However, we have since expanded it to PHP and TypeScript, with the great help of our community ♥️.
I believe SQL is cool, but developers prefer to write their favorite programming language. That was also my case as a Rubyist (👋, it’s Jônatas, developer advocate at Timescale!). Ruby is a dynamic, open-source programming language known for its simplicity and readability, making it ideal for building clean, maintainable code quickly.
With our Ruby/PostgreSQL/TimescaleDB integration, you’ll get:
The timescaledb-ruby library works by adding conveniences to the ActiveRecord migrations and models.
For example, the create_table method used in migration can also receive the hypertable argument, which enables you to configure all TimescaleDB data lifecycles during the table creation process.
Let’s have a look at our Ruby setup. Select the code in the tab to see other examples in PHP and TypeScript.
hypertable_options = {
time_column: 'created_at', # partition data by this column
chunk_time_interval: '1 day', # create a new table for each day
compress_segmentby: 'identifier', # columnar compression key
compress_after: '7 days', # start compression after 7 days
compress_orderby: 'created_at DESC', # compression order
drop_after: '6 months' # delete data after 6 months
}
create_table(:events, id: false, hypertable: hypertable_options) do |t|
t.timestamptz :created_at, null: false
t.string :identifier, null: false
t.jsonb :payload
endimport { Entity, PrimaryColumn } from 'typeorm';
import { Hypertable, TimeColumn } from '@timescaledb/typeorm';
@Entity('page_loads')
@Hypertable({
compression: { // Optional compression
compress: true,
compress_orderby: 'time',
compress_segmentby: 'user_agent',
policy: {
schedule_interval: '7 days',
},
},
})
export class PageLoad {
@PrimaryColumn({ name: 'user_agent', type: 'varchar' })
userAgent!: string;
@TimeColumn()
time!: Date;
}return new class extends Migration
{
public function up(): void
{
Schema::createExtensionIfNotExists('timescaledb');
Schema::create('visits', function (Blueprint $table) {
$table->identity();
$table->bigInteger('website_id');
$table->text('url');
$table->float('duration');
$table->timestampTz('created_at');
$table->primary(['id', 'created_at']);
$table->index(['website_id', 'created_at']);
$table->timescale(
new CreateHypertable('created_at', '1 day'),
new CreateReorderPolicyByIndex('website_id', 'created_at'),
new EnableCompression(segmentBy: 'website_id'),
new CreateCompressionPolicy('3 days'),
new CreateRetentionPolicy('1 year'),
new EnableChunkSkipping('id'),
);
});
Schema::continuousAggregate('visits_agg', function(CaggBlueprint $table) {
$table->as("
SELECT
time_bucket('1 hour', created_at) AS bucket,
website_id,
url,
SUM(duration) AS duration
FROM visits
GROUP BY bucket, website_id, url
");
$table->realtime();
$table->index(['website_id','url']);
$table->timescale(
new CreateRefreshPolicy('5 minutes', '1 days', '2 hours'),
new EnableCompression(),
new CreateCompressionPolicy('2 days'),
);
});
}
};If you like this library, consider giving it a star: https://github.com/timescale/timescaledb-ruby ⭐️
Building on the foundation of our Ruby integration, we've already expanded to TypeScript with our official timescaledb-ts package, which provides seamless integration with TypeORM. Meanwhile, the PHP community has embraced TimescaleDB through the community-maintained Laravel PostgreSQL Enhanced package (thanks to Tobias Petry!), bringing powerful time-series capabilities to Laravel applications.
This isn't just about specific languages—it's about creating a blueprint for how TimescaleDB can integrate seamlessly with any language ecosystem, whether through our official packages or community-led initiatives.
While TimescaleDB works with any language that connects to PostgreSQL, we believe in going beyond basic compatibility. Language-specific integrations deliver a number of benefits:
Our goal isn't just to be compatible with your stack—it's to become an essential, natural extension of it.
Want to create your own integration? Read the integration guide.
Here's where you come in. We're actively seeking developers who want to build and maintain TimescaleDB integrations for their language communities. Whether you're passionate about Python, Go, Rust, PHP, JavaScript, Java, .NET, or any other ecosystem, we want to support your efforts.
Here's what we're offering to community integration maintainers:
If you’re interested, book a Technical Office Hours call with me (Jônatas, developer advocate at Timescale), and let’s start!
As part of this initiative, I presented "The PostgreSQL Performance Workshop for Rubyists" at a few conferences, including Tropical on Rails in São Paulo, Brazil. I shared some of the workshop’s takeaways in my personal blog, along with a Ruby ORM benchmark that compared the performance of ActiveRecord versus Sequel.
To provide you with even more educational resources, we're bringing Ruby to the Timescale blog and showing the real-world impact of these integrations. Check out this article from an early developer adopter of the timescaledb gem on how to set up a dashboard for global energy data analytics.
We're approaching this ecosystem expansion methodically. Throughout this process, you can expect to see us document our approach, share best practices, and create reusable patterns that make TimescaleDB integration consistent across languages while remaining idiomatic to each.
We're committed to building a strong community around TimescaleDB and fostering broader ecosystem development. Here's how we plan to engage and support developers throughout our expansion:
Through these initiatives, we aim to create an inclusive community where developers can learn, collaborate, and build amazing applications with TimescaleDB.
At Timescale, we believe real-time analytics is part of any data-driven business, which translates into time-series data everywhere. Developers in every language community deserve first-class tools to work with this demanding workload. By expanding our ecosystem support and embracing community-led integrations, we're creating a more inclusive and powerful platform for all developers.
Join us in this mission! Here’s how you can get involved:
Are you building an integration for TimescaleDB in your preferred language? We'd love to hear about it! Share your project or reach out to our Ecosystem team directly.