timescaledb-rails 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b682514201eb2e88a829297e9582cfe9513a127432de8acf7a060b769f38ca2
-  data.tar.gz: c30e268a3b9be19d95537230126a1c12c8aa97746afb3227f0e544293527d399
+  metadata.gz: 7fc0e42b6db3e42267d014923180abf3c64a643937942b8b3f17ad9b2a3bf223
+  data.tar.gz: 96c3105df56f184894cdd7e3ca8658b083a87e8a050711c17e52eeae6c836c3e
 SHA512:
-  metadata.gz: 1011081beb9b4a23ff4ceafe7b47278ad7418ace4438e3a67097e8db933802afd15875ba0a28f4141154ba12170bff7e4db28c4d8c5040d716c49f53b6c8d328
-  data.tar.gz: cd429d48862ce9dd82002fe35d3953814e893bd066a6e2143a9d5245036015d21b2b23174165389888225649e963a696a2328e0b5a228bf88efc268c39a5919e
+  metadata.gz: 9988f806f0512c73456e531dd42dfe3f3c5765d9ee426bcf6f4b45e3098568fcac3518884abde8fb473a42cba66d73aa4558631b2806256ea4726496a212bdb9
+  data.tar.gz: e85fa03def618ed5d114275a6f2b929871ca0c0ea52e95ada85cca332baa2f1252f8a6bc3fc29be544aaa8dc8225dbcda52df83903bedd530a63b3683be30e8b

data/README.md

@@ -1,7 +1,6 @@
-# TimescaleDB extension for Rails [![Actions Status](https://github.com/crunchloop/timescaledb-rails/workflows/CI/badge.svg?branch=main)](https://github.com/crunchloop/timescaledb-rails/actions?query=workflow%3ACI)
-
-`timescaledb-rails` extends ActiveRecord PostgreSQL adapter and provides features from [`TimescaleDB`](https://www.timescale.com). It provides support for hypertables and other features added by TimescaleDB PostgreSQL extension.
+# TimescaleDB extension for Rails [![Gem Version](https://badge.fury.io/rb/timescaledb-rails.svg)](https://badge.fury.io/rb/timescaledb-rails) [![Actions Status](https://github.com/crunchloop/timescaledb-rails/workflows/CI/badge.svg?branch=main)](https://github.com/crunchloop/timescaledb-rails/actions?query=workflow%3ACI)
 
+`timescaledb-rails` extends ActiveRecord PostgreSQL adapter and provides features from [TimescaleDB](https://www.timescale.com). It provides support for hypertables and other features added by TimescaleDB PostgreSQL extension.
 
 ## Installation
 
@@ -17,16 +16,18 @@ Or include it in your project's `Gemfile` with Bundler:
 gem 'timescaledb-rails', '~> 0.1'
 ```
 
-## Examples
+## Usage
+
+### Migrations
 
-Create a hypertable from a PostgreSQL table by doing:
+Create a hypertable from a PostgreSQL table
 
 ```ruby
 class CreateEvent < ActiveRecord::Migration[7.0]
   def change
     create_table :events, id: false do |t|
       t.string :name, null: false
-      t.time :occured_at, null: false
+      t.time :occurred_at, null: false
 
       t.timestamps
     end
@@ -36,7 +37,7 @@ class CreateEvent < ActiveRecord::Migration[7.0]
 end
 ```
 
-Create a hypertable without a PostgreSQL table by doing:
+Create a hypertable without a PostgreSQL table
 
 ```ruby
 class CreatePayloadHypertable < ActiveRecord::Migration[7.0]
@@ -50,29 +51,228 @@ class CreatePayloadHypertable < ActiveRecord::Migration[7.0]
 end
 ```
 
-Enable hypertable compression by doing:
+Add hypertable compression
 
 ```ruby
 class AddEventCompression < ActiveRecord::Migration[7.0]
-  def change
-    add_hypertable_compression :events, 20.days, segment_by: :name, order_by: 'occured_at DESC'
+  def up
+    add_hypertable_compression :events, 20.days, segment_by: :name, order_by: 'occurred_at DESC'
+  end
+
+  def down
+    remove_hypertable_compression :events
   end
 end
 ```
 
-Disable hypertable compression by doing:
+Add hypertable retention policy
 
 ```ruby
-class RemoveEventCompression < ActiveRecord::Migration[7.0]
-  def change
-    remove_hypertable_compression :events
+class AddEventRetentionPolicy < ActiveRecord::Migration[7.0]
+  def up
+    add_hypertable_retention_policy :events, 1.year
+  end
+
+  def down
+    remove_hypertable_retention_policy :events
+  end
+end
+```
+
+Add hypertable reorder policy
+
+```ruby
+class AddEventReorderPolicy < ActiveRecord::Migration[7.0]
+  def up
+    add_hypertable_reorder_policy :events, :index_events_on_created_at_and_name
+  end
+
+  def down
+    remove_hypertable_reorder_policy :events
   end
 end
 ```
 
+Create continuous aggregate
+
+```ruby
+class CreateTemperatureEventAggregate < ActiveRecord::Migration[7.0]
+  def up
+    create_continuous_aggregate(
+      :temperature_events,
+      Event.time_bucket(1.day).avg(:value).temperature.to_sql
+    )
+
+    add_continuous_aggregate_policy(:temperature_events, 1.month, 1.day, 1.hour)
+  end
+
+  def down
+    drop_continuous_aggregate(:temperature_events)
+
+    remove_continuous_aggregate_policy(:temperature_events)
+  end
+end
+```
+
+> **Reversible Migrations:**
+>
+> Above examples implement `up`/`down` methods to better document all the different APIs. Feel free to use `change` method, timescaledb-rails defines all the reverse calls for each API method so Active Record can automatically figure out how to reverse your migration.
+
+### Models
+
+If one of your models need TimescaleDB support, just include `Timescaledb::Rails::Model`
+
+```ruby
+class Payload < ActiveRecord::Base
+  include Timescaledb::Rails::Model
+
+  self.primary_key = 'id'
+end
+```
+
+When hypertable belongs to a non default schema, don't forget to override `table_name`
+
+```ruby
+class Event < ActiveRecord::Base
+  include Timescaledb::Rails::Model
+
+  self.table_name = 'tdb.events'
+end
+```
+
+Using `.find` is not recommended, to achieve more performat results, use these other find methods
+
+```ruby
+# When you know the exact time value
+Payload.find_at_time(111, Time.new(2022, 01, 01, 10, 15, 30))
+
+# If you know that the record occurred after a given time
+Payload.find_after(222, 11.days.ago)
+
+# Lastly, if you want to scope the search by a time range
+Payload.find_between(333, 1.week.ago, 1.day.ago)
+```
+
+If you need to query data for a specific time period, `Timescaledb::Rails::Model` includes useful scopes
+
+```ruby
+# If you want to get all records from last year
+Event.last_year #=> [#<Event name...>, ...]
+
+# Or if you want to get records from this year
+Event.this_year #=> [#<Event name...>, ...]
+
+# Or even getting records from today
+Event.today #=> [#<Event name...>, ...]
+```
+
+Here the list of all available scopes
+
+* last_year
+* last_month
+* last_week
+* this_year
+* this_month
+* this_week
+* yesterday
+* today
+
+If you still need to query data by other time periods, take a look at these other scopes
+
+```ruby
+# If you want to get all records that occurred in the last 30 minutes
+Event.after(30.minutes.ago) #=> [#<Event name...>, ...]
+
+# If you want to get records that occurred in the last 4 days, excluding today
+Event.between(4.days.ago, 1.day.ago) #=> [#<Event name...>, ...]
+
+# If you want to get records that occurred at a specific time
+Event.at_time(Time.new(2023, 01, 04, 10, 20, 30)) #=> [#<Event name...>, ...]
+```
+
+If you need information about your hypertable, use the following helper methods to get useful information
+
+```ruby
+# Hypertable metadata
+Event.hypertable #=> #<Timescaledb::Rails::Hypertable ...>
+
+# Hypertable chunks metadata
+Event.hypertable_chunks #=> [#<Timescaledb::Rails::Chunk ...>, ...]
+
+# Hypertable jobs, it includes jobs like compression, retention or reorder policies, etc.
+Event.hypertable_jobs #=> [#<Timescaledb::Rails::Job ...>, ...]
+
+# Hypertable dimensions, like time or space dimensions
+Event.hypertable_dimensions #=> [#<Timescaledb::Rails::Dimension ...>, ...]
+
+# Hypertable compression settings
+Event.hypertable_compression_settings #=> [#<Timescaledb::Rails::CompressionSetting ...>, ...]
+```
+
+If you need to compress or decompress a specific chunk
+
+```ruby
+chunk = Event.hypertable_chunks.first
+
+chunk.compress! unless chunk.is_compressed?
+
+chunk.decompress! if chunk.is_compressed?
+```
+
+If you need to reorder a specific chunk
+
+```ruby
+chunk = Event.hypertable_chunks.first
+
+# If an index is not specified, it will use the one from the reorder policy
+# In case there is no reorder policy index it will raise an ArgumentError
+chunk.reorder!
+
+# If an index is specified it will use that index
+chunk.reorder!(index)
+```
+
+If you need to manually refresh a continuous aggregate
+
+```ruby
+aggregate = Event.hypertable.continuous_aggregates.first
+
+aggregate.refresh!(5.days.ago, 1.day.ago)
+```
+
+### Hyperfunctions
+
+#### Time bucket
+
+You can call the time bucket function with an interval (note that leaving the target column blank will use the default time column of the hypertable)
+
+```ruby
+Event.time_bucket(1.day)
+
+Event.time_bucket('1 day')
+
+Event.time_bucket(1.day, :created_at)
+
+Event.time_bucket(1.day, 'occurred_at')
+```
+
+You may add aggregation like so:
+
+```ruby
+Event.time_bucket(1.day).avg(:column)
+Event.time_bucket(1.day).sum(:column)
+Event.time_bucket(1.day).min(:column)
+Event.time_bucket(1.day).max(:column)
+Event.time_bucket(1.day).count
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests.
+
 ## Supported Ruby/Rails versions
 
-Supported Ruby/Rails versions are listed in [`.github/workflows/ci.yaml`](https://github.com/crunchloop/timescaledb-rails/blob/main/.github/workflows/ci.yaml)
+Supported Ruby/Rails versions are listed in [`.github/workflows/ci.yaml`](./.github/workflows/ci.yaml)
 
 ## License
 

data/lib/timescaledb/rails/extensions/active_record/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Timescaledb
+  module Rails
+    module ActiveRecord
+      # :nodoc:
+      module Base
+        extend ActiveSupport::Concern
+
+        # :nodoc:
+        module ClassMethods
+          # Returns if the current active record model is a hypertable.
+          def hypertable?
+            connection.hypertable_exists?(table_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timescaledb/rails/extensions/active_record/command_recorder.rb

@@ -17,6 +17,38 @@ module Timescaledb
           record(:remove_hypertable_compression, args, &block)
         end
 
+        def add_hypertable_reorder_policy(*args, &block)
+          record(:add_hypertable_reorder_policy, args, &block)
+        end
+
+        def remove_hypertable_reorder_policy(*args, &block)
+          record(:remove_hypertable_reorder_policy, args, &block)
+        end
+
+        def add_hypertable_retention_policy(*args, &block)
+          record(:add_hypertable_retention_policy, args, &block)
+        end
+
+        def remove_hypertable_retention_policy(*args, &block)
+          record(:remove_hypertable_retention_policy, args, &block)
+        end
+
+        def create_continuous_aggregate(*args, &block)
+          record(:create_continuous_aggregate, args, &block)
+        end
+
+        def drop_continuous_aggregate(*args, &block)
+          record(:drop_continuous_aggregate, args, &block)
+        end
+
+        def add_continuous_aggregate_policy(*args, &block)
+          record(:add_continuous_aggregate_policy, args, &block)
+        end
+
+        def remove_continuous_aggregate_policy(*args, &block)
+          record(:remove_continuous_aggregate_policy, args, &block)
+        end
+
         def invert_create_hypertable(args, &block)
           if block.nil?
             raise ::ActiveRecord::IrreversibleMigration, 'create_hypertable is only reversible if given a block (can be empty).' # rubocop:disable Layout/LineLength
@@ -36,6 +68,54 @@ module Timescaledb
 
           [:add_hypertable_compression, args, block]
         end
+
+        def invert_add_hypertable_retention_policy(args, &block)
+          [:remove_hypertable_retention_policy, args, block]
+        end
+
+        def invert_remove_hypertable_retention_policy(args, &block)
+          if args.size < 2
+            raise ::ActiveRecord::IrreversibleMigration, 'remove_hypertable_retention_policy is only reversible if given table name and drop after period.' # rubocop:disable Layout/LineLength
+          end
+
+          [:add_hypertable_retention_policy, args, block]
+        end
+
+        def invert_add_hypertable_reorder_policy(args, &block)
+          [:remove_hypertable_reorder_policy, args, block]
+        end
+
+        def invert_remove_hypertable_reorder_policy(args, &block)
+          if args.size < 2
+            raise ::ActiveRecord::IrreversibleMigration, 'remove_hypertable_reorder_policy is only reversible if given table name and index name.' # rubocop:disable Layout/LineLength
+          end
+
+          [:add_hypertable_reorder_policy, args, block]
+        end
+
+        def invert_create_continuous_aggregate(args, &block)
+          [:drop_continuous_aggregate, args, block]
+        end
+
+        def invert_drop_continuous_aggregate(args, &block)
+          if args.size < 2
+            raise ::ActiveRecord::IrreversibleMigration, 'drop_continuous_aggregate is only reversible if given view name and view query.' # rubocop:disable Layout/LineLength
+          end
+
+          [:create_continuous_aggregate, args, block]
+        end
+
+        def invert_add_continuous_aggregate_policy(args, &block)
+          [:remove_continuous_aggregate_policy, args, block]
+        end
+
+        def invert_remove_continuous_aggregate_policy(args, &block)
+          if args.size < 4
+            raise ::ActiveRecord::IrreversibleMigration, 'remove_continuous_aggregate_policy is only reversible if given view name, start offset, end offset and schedule interval.' # rubocop:disable Layout/LineLength
+          end
+
+          [:add_continuous_aggregate_policy, args, block]
+        end
       end
     end
   end

data/lib/timescaledb/rails/extensions/active_record/postgresql_database_tasks.rb

@@ -7,36 +7,53 @@ module Timescaledb
   module Rails
     module ActiveRecord
       # :nodoc:
+      # rubocop:disable Layout/LineLength
       module PostgreSQLDatabaseTasks
         # @override
-        def structure_dump(filename, extra_flags) # rubocop:disable Metrics/MethodLength
+        def structure_dump(filename, extra_flags)
           extra_flags = Array(extra_flags)
-          extra_flags << timescale_structure_dump_default_flags if timescale_enabled?
+          extra_flags |= timescale_structure_dump_default_flags if timescale_enabled?
 
           super(filename, extra_flags)
 
           return unless timescale_enabled?
 
+          hypertables(filename)
+          continuous_aggregates(filename)
+        end
+
+        def hypertables(filename)
           File.open(filename, 'a') do |file|
             Timescaledb::Rails::Hypertable.all.each do |hypertable|
               drop_ts_insert_trigger_statment(hypertable, file)
               create_hypertable_statement(hypertable, file)
               add_hypertable_compression_statement(hypertable, file)
+              add_hypertable_reorder_policy_statement(hypertable, file)
+              add_hypertable_retention_policy_statement(hypertable, file)
+            end
+          end
+        end
+
+        def continuous_aggregates(filename)
+          File.open(filename, 'a') do |file|
+            Timescaledb::Rails::ContinuousAggregate.all.each do |continuous_aggregate|
+              create_continuous_aggregate_statement(continuous_aggregate, file)
+              add_continuous_aggregate_policy_statement(continuous_aggregate, file)
             end
           end
         end
 
         def drop_ts_insert_trigger_statment(hypertable, file)
           file << "---\n"
-          file << "--- Drop ts_insert_blocker previously created by pg_dump to avoid pg errors, create_hypertable will re-create it again.\n" # rubocop:disable Layout/LineLength
+          file << "--- Drop ts_insert_blocker previously created by pg_dump to avoid pg errors, create_hypertable will re-create it again.\n"
           file << "---\n\n"
-          file << "DROP TRIGGER IF EXISTS ts_insert_blocker ON #{hypertable.hypertable_name};\n"
+          file << "DROP TRIGGER IF EXISTS ts_insert_blocker ON #{hypertable.hypertable_schema}.#{hypertable.hypertable_name};\n"
         end
 
         def create_hypertable_statement(hypertable, file)
           options = hypertable_options(hypertable)
 
-          file << "SELECT create_hypertable('#{hypertable.hypertable_name}', '#{hypertable.time_column_name}', #{options});\n\n" # rubocop:disable Layout/LineLength
+          file << "SELECT create_hypertable('#{hypertable.hypertable_schema}.#{hypertable.hypertable_name}', '#{hypertable.time_column_name}', #{options});\n\n"
         end
 
         def add_hypertable_compression_statement(hypertable, file)
@@ -44,8 +61,35 @@ module Timescaledb
 
           options = hypertable_compression_options(hypertable)
 
-          file << "ALTER TABLE #{hypertable.hypertable_name} SET (#{options});\n\n"
-          file << "SELECT add_compression_policy('#{hypertable.hypertable_name}', INTERVAL '#{hypertable.compression_policy_interval}');\n\n" # rubocop:disable Layout/LineLength
+          file << "ALTER TABLE #{hypertable.hypertable_schema}.#{hypertable.hypertable_name} SET (#{options});\n\n"
+          file << "SELECT add_compression_policy('#{hypertable.hypertable_schema}.#{hypertable.hypertable_name}', INTERVAL '#{hypertable.compression_policy_interval}');\n\n"
+        end
+
+        def add_hypertable_reorder_policy_statement(hypertable, file)
+          return unless hypertable.reorder?
+
+          file << "SELECT add_reorder_policy('#{hypertable.hypertable_schema}.#{hypertable.hypertable_name}', '#{hypertable.reorder_policy_index_name}');\n\n"
+        end
+
+        def add_hypertable_retention_policy_statement(hypertable, file)
+          return unless hypertable.retention?
+
+          file << "SELECT add_retention_policy('#{hypertable.hypertable_schema}.#{hypertable.hypertable_name}', INTERVAL '#{hypertable.retention_policy_interval}');\n\n"
+        end
+
+        def create_continuous_aggregate_statement(continuous_aggregate, file)
+          file << "CREATE MATERIALIZED VIEW #{continuous_aggregate.view_schema}.#{continuous_aggregate.view_name} WITH (timescaledb.continuous) AS\n"
+          file << "#{continuous_aggregate.view_definition.strip.indent(2)}\n\n"
+        end
+
+        def add_continuous_aggregate_policy_statement(continuous_aggregate, file)
+          return unless continuous_aggregate.refresh?
+
+          start_offset = continuous_aggregate.refresh_start_offset
+          end_offset = continuous_aggregate.refresh_end_offset
+          schedule_interval = continuous_aggregate.refresh_schedule_interval
+
+          file << "SELECT add_continuous_aggregate_policy('#{continuous_aggregate.view_schema}.#{continuous_aggregate.view_name}', start_offset => INTERVAL '#{start_offset}', end_offset => INTERVAL '#{end_offset}', schedule_interval => INTERVAL '#{schedule_interval}');\n\n"
         end
 
         def hypertable_options(hypertable)
@@ -56,27 +100,41 @@ module Timescaledb
         end
 
         def hypertable_compression_options(hypertable)
-          segmentby_setting = hypertable.compression_settings.segmentby_setting.first
-          orderby_setting = hypertable.compression_settings.orderby_setting.first
-
           sql_statements = ['timescaledb.compress']
-          sql_statements << "timescaledb.compress_segmentby = '#{segmentby_setting.attname}'" if segmentby_setting
 
-          if orderby_setting
-            orderby = Timescaledb::Rails::OrderbyCompression.new(orderby_setting.attname,
-                                                                 orderby_setting.orderby_asc).to_s
+          if (segments = compression_segment_settings(hypertable)).present?
+            sql_statements << "timescaledb.compress_segmentby = '#{segments.join(', ')}'"
+          end
 
-            sql_statements << "timescaledb.compress_orderby = '#{orderby}'"
+          if (orders = compression_order_settings(hypertable)).present?
+            sql_statements << "timescaledb.compress_orderby = '#{orders.join(', ')}'"
           end
 
           sql_statements.join(', ')
         end
 
-        # Returns `pg_dump` flag to exclude `_timescaledb_internal` schema tables.
+        def compression_order_settings(hypertable)
+          hypertable.compression_order_settings.map do |os|
+            Timescaledb::Rails::OrderbyCompression.new(os.attname, os.orderby_asc).to_s
+          end
+        end
+
+        def compression_segment_settings(hypertable)
+          hypertable.compression_segment_settings.map(&:attname)
+        end
+
+        # Returns `pg_dump` flags to exclude `_timescaledb_internal` schema tables and
+        # exclude the corresponding continuous aggregate views.
         #
-        # @return [String]
+        # @return [Array<String>]
         def timescale_structure_dump_default_flags
-          '--exclude-schema=_timescaledb_internal'
+          flags = ['--exclude-schema=_timescaledb_internal']
+
+          Timescaledb::Rails::ContinuousAggregate.pluck(:view_schema, :view_name).each do |view_schema, view_name|
+            flags << "--exclude-table=#{view_schema}.#{view_name}"
+          end
+
+          flags
         end
 
         # @return [Boolean]
@@ -84,6 +142,7 @@ module Timescaledb
           Timescaledb::Rails::Hypertable.table_exists?
         end
       end
+      # rubocop:enable Layout/LineLength
     end
   end
 end

data/lib/timescaledb/rails/extensions/active_record/schema_dumper.rb

@@ -7,7 +7,46 @@ module Timescaledb
   module Rails
     module ActiveRecord
       # :nodoc:
-      module SchemaDumper
+      module SchemaDumper # rubocop:disable Metrics/ModuleLength
+        # @override
+        def tables(stream)
+          super
+
+          continuous_aggregates(stream)
+          stream
+        end
+
+        def continuous_aggregates(stream)
+          return unless timescale_enabled?
+
+          Timescaledb::Rails::ContinuousAggregate.all.each do |continuous_aggregate|
+            continuous_aggregate(continuous_aggregate, stream)
+            continuous_aggregate_policy(continuous_aggregate, stream)
+          end
+        end
+
+        def continuous_aggregate(continuous_aggregate, stream)
+          stream.puts "  create_continuous_aggregate #{continuous_aggregate.view_name.inspect}, <<-SQL"
+          stream.puts "  #{continuous_aggregate.view_definition.strip.indent(2)}"
+          stream.puts '  SQL'
+          stream.puts
+        end
+
+        def continuous_aggregate_policy(continuous_aggregate, stream)
+          return unless continuous_aggregate.refresh?
+
+          options = [
+            continuous_aggregate.view_name.inspect,
+            continuous_aggregate.refresh_start_offset.inspect,
+            continuous_aggregate.refresh_end_offset.inspect,
+            continuous_aggregate.refresh_schedule_interval.inspect
+          ]
+
+          stream.puts "  add_continuous_aggregate_policy #{options.join(', ')}"
+          stream.puts
+        end
+
+        # @override
         def table(table, stream)
           super(table, stream)
 
@@ -16,6 +55,8 @@ module Timescaledb
 
           hypertable(hypertable, stream)
           hypertable_compression(hypertable, stream)
+          hypertable_reorder(hypertable, stream)
+          hypertable_retention(hypertable, stream)
         end
 
         private
@@ -38,6 +79,24 @@ module Timescaledb
           stream.puts
         end
 
+        def hypertable_reorder(hypertable, stream)
+          return unless hypertable.reorder?
+
+          options = [hypertable.hypertable_name.inspect, hypertable.reorder_policy_index_name.inspect]
+
+          stream.puts "  add_hypertable_reorder_policy #{options.join(', ')}"
+          stream.puts
+        end
+
+        def hypertable_retention(hypertable, stream)
+          return unless hypertable.retention?
+
+          options = [hypertable.hypertable_name.inspect, hypertable.retention_policy_interval.inspect]
+
+          stream.puts "  add_hypertable_retention_policy #{options.join(', ')}"
+          stream.puts
+        end
+
         def hypertable_options(hypertable)
           options = {
             chunk_time_interval: hypertable.chunk_time_interval
@@ -50,21 +109,27 @@ module Timescaledb
         end
 
         def hypertable_compression_options(hypertable)
-          segmentby_setting = hypertable.compression_settings.segmentby_setting.first
-          orderby_setting = hypertable.compression_settings.orderby_setting.first
-
           [].tap do |result|
-            result << "segment_by: #{segmentby_setting.attname.inspect}" if segmentby_setting
-
-            if orderby_setting
-              orderby = Timescaledb::Rails::OrderbyCompression.new(orderby_setting.attname,
-                                                                   orderby_setting.orderby_asc).to_s
+            if (segments = compression_segment_settings(hypertable)).present?
+              result << "segment_by: #{segments.join(', ').inspect}"
+            end
 
-              result << "order_by: #{orderby.inspect}"
+            if (orders = compression_order_settings(hypertable)).present?
+              result << "order_by: #{orders.join(', ').inspect}"
             end
           end
         end
 
+        def compression_order_settings(hypertable)
+          hypertable.compression_order_settings.map do |os|
+            Timescaledb::Rails::OrderbyCompression.new(os.attname, os.orderby_asc).to_s
+          end
+        end
+
+        def compression_segment_settings(hypertable)
+          hypertable.compression_segment_settings.map(&:attname)
+        end
+
         def format_hypertable_option_value(value)
           case value
           when String then value.inspect