timescaledb-rails 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af4399bfd70056ed23cfb0994580a8c61fcd88722a72ce7839761b305c6d2029
-  data.tar.gz: dad61e01554eee6ee23fd780a6745196d7fb5b3703398c795bbe3e00dfbe028b
+  metadata.gz: 12170e03389f6ac4f3bba7816dfb20dc75a47103032ec3e3799f3c78dca25a4b
+  data.tar.gz: f26796af01f755648e952f9e851f24d05d7adb3439e3653d793beef624ea8044
 SHA512:
-  metadata.gz: 1679b7421eca2f5b557b83a7b338f72444d073009f532b77d75e8e233c07828750d02afc96f4b2ee0a5c61ce6c750f03832742621df1187529cddcec3e46995f
-  data.tar.gz: 3628e056c77754629a65c2ef343c59702272bbec882b47f2e70564fbd1008080729e05017f923a0145d78e186bb272a5e13394605ccf96bcb39a34f520c3ad9a
+  metadata.gz: 22c4c72512895fadb2a7701222e6b890b60a15948dc9c6b5c01ded24afff9865d6ebc954673452b55b95ac68b18c933dc2bf7aec6ac135285ecfa950d346e8e3
+  data.tar.gz: f67c442f8d2eb837566f8cc3a450d809a769343799997f3979a222bd0413c2ce89fad70b9b8f3e96267ab61e8bcf3cc2c167c15a60db1f1144ea17daf9cfee36

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,19 +51,127 @@ 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
+```
+
+Add hypertable retention policy
+
+```ruby
+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
 ```
 
+### Models
+
+If one of your models need TimescaleDB support, just include `Timescaledb::Rails::Model`
+```ruby
+class Event < ActiveRecord::Base
+  include Timescaledb::Rails::Model
+end
+```
+
+If the hypertable does not belong to the default schema, don't forget to override `table_name`
+
+```ruby
+class Event < ActiveRecord::Base
+  include Timescaledb::Rails::Model
+
+  self.table_name = 'v1.events'
+end
+```
+
+If you need to query data for a specific time period, `Timescaledb::Rails::Model` incluldes 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 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?
+```
+
+## 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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Timescaledb
+  module Rails
+    module ActiveRecord
+      # :nodoc:
+      module CommandRecorder
+        def create_hypertable(*args, &block)
+          record(:create_hypertable, args, &block)
+        end
+
+        def add_hypertable_compression(*args, &block)
+          record(:add_hypertable_compression, args, &block)
+        end
+
+        def remove_hypertable_compression(*args, &block)
+          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 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
+          end
+
+          [:drop_table, args.first, block]
+        end
+
+        def invert_add_hypertable_compression(args, &block)
+          [:remove_hypertable_compression, args, block]
+        end
+
+        def invert_remove_hypertable_compression(args, &block)
+          if args.size < 2
+            raise ::ActiveRecord::IrreversibleMigration, 'remove_hypertable_compression is only reversible if given table name and compress period.' # rubocop:disable Layout/LineLength
+          end
+
+          [: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
+      end
+    end
+  end
+end

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

@@ -9,8 +9,11 @@ module Timescaledb
       # :nodoc:
       module PostgreSQLDatabaseTasks
         # @override
-        def structure_dump(filename, extra_flags)
-          super
+        def structure_dump(filename, extra_flags) # rubocop:disable Metrics/MethodLength
+          extra_flags = Array(extra_flags)
+          extra_flags << timescale_structure_dump_default_flags if timescale_enabled?
+
+          super(filename, extra_flags)
 
           return unless timescale_enabled?
 
@@ -19,6 +22,8 @@ module Timescaledb
               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
@@ -45,30 +50,57 @@ module Timescaledb
           file << "SELECT add_compression_policy('#{hypertable.hypertable_name}', INTERVAL '#{hypertable.compression_policy_interval}');\n\n" # rubocop:disable Layout/LineLength
         end
 
+        def add_hypertable_reorder_policy_statement(hypertable, file)
+          return unless hypertable.reorder?
+
+          file << "SELECT add_reorder_policy('#{hypertable.hypertable_name}', '#{hypertable.reorder_policy_index_name}');\n\n" # rubocop:disable Layout/LineLength
+        end
+
+        def add_hypertable_retention_policy_statement(hypertable, file)
+          return unless hypertable.retention?
+
+          file << "SELECT add_retention_policy('#{hypertable.hypertable_name}', INTERVAL '#{hypertable.retention_policy_interval}');\n\n" # rubocop:disable Layout/LineLength
+        end
+
         def hypertable_options(hypertable)
           sql_statements = ["if_not_exists => 'TRUE'"]
-          sql_statements << "chunk_time_interval => INTERVAL '#{hypertable.chunk_time_interval.inspect}'"
+          sql_statements << "chunk_time_interval => INTERVAL '#{hypertable.chunk_time_interval}'"
 
           sql_statements.compact.join(', ')
         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
 
+        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` flag to exclude `_timescaledb_internal` schema tables.
+        #
+        # @return [String]
+        def timescale_structure_dump_default_flags
+          '--exclude-schema=_timescaledb_internal'
+        end
+
+        # @return [Boolean]
         def timescale_enabled?
           Timescaledb::Rails::Hypertable.table_exists?
         end

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

@@ -16,6 +16,8 @@ module Timescaledb
 
           hypertable(hypertable, stream)
           hypertable_compression(hypertable, stream)
+          hypertable_reorder(hypertable, stream)
+          hypertable_retention(hypertable, stream)
         end
 
         private
@@ -38,6 +40,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 +70,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

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

@@ -1,12 +1,27 @@
 # frozen_string_literal: true
 
-require 'active_record/connection_adapters/postgresql_adapter'
-
 module Timescaledb
   module Rails
     module ActiveRecord
       # :nodoc:
       module SchemaStatements
+        # Returns an array of hypertable names defined in the database.
+        def hypertables
+          query_values('SELECT hypertable_name FROM timescaledb_information.hypertables')
+        end
+
+        # Checks to see if the hypertable exists on the database.
+        #
+        #   hypertable_exists?(:developers)
+        #
+        def hypertable_exists?(hypertable)
+          query_value(
+            <<-SQL.squish
+              SELECT COUNT(*) FROM timescaledb_information.hypertables WHERE hypertable_name = #{quote(hypertable)}
+            SQL
+          ).to_i.positive?
+        end
+
         # Converts given standard PG table into a hypertable.
         #
         #   create_hypertable('readings', 'created_at', chunk_time_interval: '7 days')
@@ -38,9 +53,50 @@ module Timescaledb
 
           execute "ALTER TABLE #{table_name} SET (#{options.join(', ')})"
 
-          execute "SELECT add_compression_policy('#{table_name}', INTERVAL '#{compress_after}')"
+          execute "SELECT add_compression_policy('#{table_name}', INTERVAL '#{compress_after.inspect}')"
+        end
+
+        # Disables compression from given table.
+        #
+        #   remove_hypertable_compression('events')
+        #
+        def remove_hypertable_compression(table_name, compress_after = nil, segment_by: nil, order_by: nil) # rubocop:disable Lint/UnusedMethodArgument
+          execute "SELECT remove_compression_policy('#{table_name.inspect}');"
+        end
+
+        # Add a data retention policy to given hypertable.
+        #
+        #   add_hypertable_retention_policy('events', 7.days)
+        #
+        def add_hypertable_retention_policy(table_name, drop_after)
+          execute "SELECT add_retention_policy('#{table_name}', INTERVAL '#{drop_after.inspect}')"
+        end
+
+        # Removes data retention policy from given hypertable.
+        #
+        #   remove_hypertable_retention_policy('events')
+        #
+        def remove_hypertable_retention_policy(table_name, _drop_after = nil)
+          execute "SELECT remove_retention_policy('#{table_name}')"
+        end
+
+        # Adds a policy to reorder chunks on a given hypertable index in the background.
+        #
+        #   add_hypertable_reorder_policy('events', 'index_events_on_created_at_and_name')
+        #
+        def add_hypertable_reorder_policy(table_name, index_name)
+          execute "SELECT add_reorder_policy('#{table_name}', '#{index_name}')"
+        end
+
+        # Removes a policy to reorder a particular hypertable.
+        #
+        #   remove_hypertable_reorder_policy('events')
+        #
+        def remove_hypertable_reorder_policy(table_name, _index_name = nil)
+          execute "SELECT remove_reorder_policy('#{table_name}')"
         end
 
+        # @return [String]
         def hypertable_options_to_sql(options)
           sql_statements = options.map do |option, value|
             case option

data/lib/timescaledb/rails/model/scopes.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Timescaledb
+  module Rails
+    module Model
+      # :nodoc:
+      module Scopes
+        extend ActiveSupport::Concern
+
+        # rubocop:disable Metrics/BlockLength
+        included do
+          scope :last_year, lambda {
+            date = Date.current - 1.year
+
+            between_time_column(date.beginning_of_year, date.end_of_year)
+          }
+
+          scope :last_month, lambda {
+            date = Date.current - 1.month
+
+            between_time_column(date.beginning_of_month, date.end_of_month)
+          }
+
+          scope :last_week, lambda {
+            date = Date.current - 1.week
+
+            between_time_column(date.beginning_of_week, date.end_of_week)
+          }
+
+          scope :yesterday, lambda {
+            where("DATE(#{hypertable_time_column_name}) = ?", Date.current - 1.day)
+          }
+
+          scope :this_year, lambda {
+            between_time_column(Date.current.beginning_of_year, Date.current.end_of_year)
+          }
+
+          scope :this_month, lambda {
+            between_time_column(Date.current.beginning_of_month, Date.current.end_of_month)
+          }
+
+          scope :this_week, lambda {
+            between_time_column(Date.current.beginning_of_week, Date.current.end_of_week)
+          }
+
+          scope :today, lambda {
+            where("DATE(#{hypertable_time_column_name}) = ?", Date.current)
+          }
+
+          # @!visibility private
+          scope :between_time_column, lambda { |from, to|
+            where("DATE(#{hypertable_time_column_name}) BETWEEN ? AND ?", from, to)
+          }
+        end
+        # rubocop:enable Metrics/BlockLength
+      end
+    end
+  end
+end

data/lib/timescaledb/rails/model.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'timescaledb/rails/model/scopes'
+
+module Timescaledb
+  module Rails
+    # :nodoc:
+    module Model
+      PUBLIC_SCHEMA_NAME = 'public'
+
+      extend ActiveSupport::Concern
+
+      include Scopes
+
+      # :nodoc:
+      module ClassMethods
+        delegate :time_column_name, to: :hypertable, prefix: true
+
+        # Returns only the name of the hypertable, table_name could include
+        # the schema path, we need to remove it.
+        #
+        # @return [String]
+        def hypertable_name
+          table_name.split('.').last
+        end
+
+        # Returns the schema where hypertable is stored.
+        #
+        # @return [String]
+        def hypertable_schema
+          if table_name.split('.').size > 1
+            table_name.split('.')[0..-2].join('.')
+          else
+            PUBLIC_SCHEMA_NAME
+          end
+        end
+
+        # @return [Timescaledb::Rails::Hypertable]
+        def hypertable
+          Timescaledb::Rails::Hypertable.find_by(hypertable_where_options)
+        end
+
+        # @return [ActiveRecord::Relation<Timescaledb::Rails::Chunk>]
+        def hypertable_chunks
+          Timescaledb::Rails::Chunk.where(hypertable_where_options)
+        end
+
+        # @return [ActiveRecord::Relation<Timescaledb::Rails::Job>]
+        def hypertable_jobs
+          Timescaledb::Rails::Job.where(hypertable_where_options)
+        end
+
+        # @return [ActiveRecord::Relation<Timescaledb::Rails::Dimension>]
+        def hypertable_dimensions
+          Timescaledb::Rails::Dimension.where(hypertable_where_options)
+        end
+
+        # @return [ActiveRecord::Relation<Timescaledb::Rails::CompressionSetting>]
+        def hypertable_compression_settings
+          Timescaledb::Rails::CompressionSetting.where(hypertable_where_options)
+        end
+
+        private
+
+        # Returns hypertable name and schema.
+        #
+        # @return [Hash]
+        def hypertable_where_options
+          { hypertable_name: hypertable_name, hypertable_schema: hypertable_schema }
+        end
+      end
+    end
+  end
+end

data/lib/timescaledb/rails/models/chunk.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Timescaledb
+  module Rails
+    # :nodoc:
+    class Chunk < ::ActiveRecord::Base
+      self.table_name = 'timescaledb_information.chunks'
+      self.primary_key = 'hypertable_name'
+
+      scope :compressed, -> { where(is_compressed: true) }
+      scope :decompressed, -> { where(is_compressed: false) }
+
+      def chunk_full_name
+        "#{chunk_schema}.#{chunk_name}"
+      end
+
+      def compress!
+        ::ActiveRecord::Base.connection.execute(
+          "SELECT compress_chunk('#{chunk_full_name}')"
+        )
+      end
+
+      def decompress!
+        ::ActiveRecord::Base.connection.execute(
+          "SELECT decompress_chunk('#{chunk_full_name}')"
+        )
+      end
+    end
+  end
+end

data/lib/timescaledb/rails/models/hypertable.rb

@@ -11,6 +11,7 @@ module Timescaledb
                                       class_name: 'Timescaledb::Rails::CompressionSetting'
       has_many :dimensions, foreign_key: 'hypertable_name', class_name: 'Timescaledb::Rails::Dimension'
       has_many :jobs, foreign_key: 'hypertable_name', class_name: 'Timescaledb::Rails::Job'
+      has_many :chunks, foreign_key: 'hypertable_name', class_name: 'Timescaledb::Rails::Chunk'
 
       # @return [String]
       def time_column_name
@@ -19,14 +20,34 @@ module Timescaledb
 
       # @return [String]
       def chunk_time_interval
-        time_dimension.time_interval
+        interval = time_dimension.time_interval
+
+        interval.is_a?(String) ? interval : interval.inspect
+      end
+
+      # @return [ActiveRecord::Relation<CompressionSetting>]
+      def compression_segment_settings
+        compression_settings.segmentby_setting
+      end
+
+      # @return [ActiveRecord::Relation<CompressionSetting>]
+      def compression_order_settings
+        compression_settings.orderby_setting.where.not(attname: time_column_name)
       end
 
       # @return [String]
       def compression_policy_interval
-        ActiveSupport::Duration.parse(compression_job.config['compress_after']).inspect
-      rescue ActiveSupport::Duration::ISO8601Parser::ParsingError
-        compression_job.config['compress_after']
+        parse_duration(compression_job.config['compress_after'])
+      end
+
+      # @return [String]
+      def reorder_policy_index_name
+        reorder_job.config['index_name']
+      end
+
+      # @return [String]
+      def retention_policy_interval
+        parse_duration(retention_job.config['drop_after'])
       end
 
       # @return [Boolean]
@@ -34,8 +55,28 @@ module Timescaledb
         compression_job.present?
       end
 
+      # @return [Boolean]
+      def reorder?
+        reorder_job.present?
+      end
+
+      # @return [Boolean]
+      def retention?
+        retention_job.present?
+      end
+
       private
 
+      # @return [Job]
+      def reorder_job
+        @reorder_job ||= jobs.policy_reorder.first
+      end
+
+      # @return [Job]
+      def retention_job
+        @retention_job ||= jobs.policy_retention.first
+      end
+
       # @return [Job]
       def compression_job
         @compression_job ||= jobs.policy_compression.first
@@ -45,6 +86,13 @@ module Timescaledb
       def time_dimension
         @time_dimension ||= dimensions.time.first
       end
+
+      # @return [String]
+      def parse_duration(duration)
+        ActiveSupport::Duration.parse(duration).inspect
+      rescue ActiveSupport::Duration::ISO8601Parser::ParsingError
+        duration
+      end
     end
   end
 end

data/lib/timescaledb/rails/models/job.rb

@@ -8,8 +8,12 @@ module Timescaledb
       self.primary_key = 'hypertable_name'
 
       POLICY_COMPRESSION = 'policy_compression'
+      POLICY_REORDER = 'policy_reorder'
+      POLICY_RETENTION = 'policy_retention'
 
       scope :policy_compression, -> { where(proc_name: POLICY_COMPRESSION) }
+      scope :policy_reorder, -> { where(proc_name: POLICY_REORDER) }
+      scope :policy_retention, -> { where(proc_name: POLICY_RETENTION) }
     end
   end
 end

data/lib/timescaledb/rails/models.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './models/chunk'
 require_relative './models/compression_setting'
 require_relative './models/dimension'
-require_relative './models/job'
 require_relative './models/hypertable'
+require_relative './models/job'

data/lib/timescaledb/rails/railtie.rb

@@ -2,11 +2,6 @@
 
 require 'rails'
 
-require_relative 'extensions/active_record/database_tasks'
-require_relative 'extensions/active_record/postgresql_database_tasks'
-require_relative 'extensions/active_record/schema_dumper'
-require_relative 'extensions/active_record/schema_statements'
-
 module Timescaledb
   module Rails
     # :nodoc:
@@ -19,21 +14,7 @@ module Timescaledb
 
       initializer 'timescaledb-rails.add_timescale_support_to_active_record' do
         ActiveSupport.on_load(:active_record) do
-          ::ActiveRecord::Tasks::DatabaseTasks.extend(
-            Timescaledb::Rails::ActiveRecord::DatabaseTasks
-          )
-
-          ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks.prepend(
-            Timescaledb::Rails::ActiveRecord::PostgreSQLDatabaseTasks
-          )
-
-          ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(
-            Timescaledb::Rails::ActiveRecord::SchemaStatements
-          )
-
-          ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(
-            Timescaledb::Rails::ActiveRecord::SchemaDumper
-          )
+          Timescaledb::Rails.load
         end
       end
     end

data/lib/timescaledb/rails/version.rb

@@ -3,6 +3,6 @@
 module Timescaledb
   # :nodoc:
   module Rails
-    VERSION = '0.1.2'
+    VERSION = '0.1.4'
   end
 end

data/lib/timescaledb/rails.rb

@@ -1,7 +1,23 @@
 # frozen_string_literal: true
 
+require_relative './rails/model'
+
+require_relative './rails/extensions/active_record/base'
+require_relative './rails/extensions/active_record/command_recorder'
+require_relative './rails/extensions/active_record/postgresql_database_tasks'
+require_relative './rails/extensions/active_record/schema_dumper'
+require_relative './rails/extensions/active_record/schema_statements'
+
 module Timescaledb
   # :nodoc:
   module Rails
+    # Adds TimescaleDB support to ActiveRecord.
+    def self.load
+      ::ActiveRecord::Migration::CommandRecorder.prepend(ActiveRecord::CommandRecorder)
+      ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks.prepend(ActiveRecord::PostgreSQLDatabaseTasks)
+      ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::SchemaStatements)
+      ::ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(ActiveRecord::SchemaDumper)
+      ::ActiveRecord::Base.include(ActiveRecord::Base) # rubocop:disable Rails/ActiveSupportOnLoad
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Iván Etchart
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-24 00:00:00.000000000 Z
+date: 2022-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -25,6 +25,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -119,11 +133,15 @@ files:
 - README.md
 - lib/timescaledb-rails.rb
 - lib/timescaledb/rails.rb
-- lib/timescaledb/rails/extensions/active_record/database_tasks.rb
+- lib/timescaledb/rails/extensions/active_record/base.rb
+- lib/timescaledb/rails/extensions/active_record/command_recorder.rb
 - lib/timescaledb/rails/extensions/active_record/postgresql_database_tasks.rb
 - lib/timescaledb/rails/extensions/active_record/schema_dumper.rb
 - lib/timescaledb/rails/extensions/active_record/schema_statements.rb
+- lib/timescaledb/rails/model.rb
+- lib/timescaledb/rails/model/scopes.rb
 - lib/timescaledb/rails/models.rb
+- lib/timescaledb/rails/models/chunk.rb
 - lib/timescaledb/rails/models/compression_setting.rb
 - lib/timescaledb/rails/models/dimension.rb
 - lib/timescaledb/rails/models/hypertable.rb

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Timescaledb
-  module Rails
-    module ActiveRecord
-      # :nodoc:
-      module DatabaseTasks
-        # @override
-        def structure_dump_flags_for(adapter)
-          return (flags = super) if adapter != 'postgresql'
-
-          if flags.nil?
-            timescaledb_structure_dump_default_flags
-          elsif flags.is_a?(Array)
-            flags << timescaledb_structure_dump_default_flags
-          elsif flags.is_a?(String)
-            "#{flags} #{timescaledb_structure_dump_default_flags}"
-          else
-            flags
-          end
-        end
-
-        # Returns `pg_dump` flag to exclude `_timescaledb_internal` schema tables.
-        #
-        # @return [String]
-        def timescaledb_structure_dump_default_flags
-          '--exclude-schema=_timescaledb_internal'
-        end
-      end
-    end
-  end
-end