timescaledb 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a20c2f12a3673694b39fd99aa005d743bbc027031d3abc7c25fda904f71ee33f
-  data.tar.gz: fd27816a15c114baa3d75a08bd083de5493efd7ce60ebe200d6543a3dcb266bf
+  metadata.gz: 33706a3c899ae608bb30b9ef62ca32875045960745b526bc0700fddec09ddc8b
+  data.tar.gz: 88a7cb9f1f2f2dbb68f131547fa7c9575979f6e87b0bb29f576ee95d9bb9696c
 SHA512:
-  metadata.gz: db6642dbdb2588359fc63fff080f34479725cef75d7972f081aa2a1beb680314cf1555ba7ec94956d16cceb3ac3b7724de131e010ba1d06361350f162ed3250c
-  data.tar.gz: df04ac079954e4b815d922d2a076929e6c4d5f5e9c11d46a54287138e8485fb171b276361a3bae43618c068709fa9f07c0ec34faa88c3afff18ac9d65d511766
+  metadata.gz: a700d4b61d11af54856fb02e19db676a720ba5ff3c2367e7eb9ba153bc14ae1c3c67d9130bfc47e1ecac786a007274df9c3595a6b10fe797fb06b13ae30ac957
+  data.tar.gz: 05c45d270e86c24d40984cea92e8870869441580d35426b5028ca17b346a47ad7468482337adec69eaf0d6daecdd4292d7108868677a7388f35cf2529d7e631a

data/bin/tsdb

@@ -6,17 +6,19 @@ require "pry"
 
 Timescaledb.establish_connection(ARGV[0])
 
-hypertables = Timescaledb.connection.query('SELECT * FROM timescaledb_information.hypertables')
+ActiveSupport.on_load(:active_record) { extend Timescaledb::ActsAsHypertable }
+
 
 if ARGV.index("--stats")
+  hypertables = Timescaledb::Hypertable.all
   if (only = ARGV.index("--only"))
     only_hypertables = ARGV[only+1].split(",")
 
-    hypertables.select! { |hypertable| only_hypertables.includes?(hypertable.hypertable_name) }
+    hypertables.select! { |hypertable| only_hypertables.include?(hypertable.hypertable_name) }
   elsif (except = ARGV.index("--except"))
     except_hypertables = ARGV[except+1].split(",")
 
-    hypertables.select! { |hypertable| except_hypertables.includes?(hypertable.hypertable_name) }
+    hypertables.select! { |hypertable| except_hypertables.include?(hypertable.hypertable_name) }
   end
 
   stats = Timescaledb::Stats.new(hypertables).to_h
@@ -25,25 +27,26 @@ if ARGV.index("--stats")
 end
 
 if ARGV.index("--console")
-  ActiveRecord::Base.establish_connection(ARGV[0])
-
   Timescaledb::Hypertable.find_each do |hypertable|
     class_name = hypertable.hypertable_name.singularize.camelize
     model = Class.new(ActiveRecord::Base) do
-      self.table_name = hypertable.hypertable_name
+      self.table_name = "#{hypertable.hypertable_schema}.#{hypertable.hypertable_name}"
+
       acts_as_hypertable time_column: hypertable.main_dimension.column_name
     end
-    Timescaledb.const_set(class_name, model)
-  end
 
-  Timescaledb::ContinuousAggregates.find_each do |cagg|
-    class_name = cagg.view_name.singularize.camelize
-    model = Class.new(ActiveRecord::Base) do
-      self.table_name = cagg.view_name
-      acts_as_hypertable
+    Timescaledb::ContinuousAggregate.where( hypertable_schema: hypertable.hypertable_schema, hypertable_name: hypertable.hypertable_name).hierarchical.find_each do |cagg|
+      cagg_model_name = cagg.view_name.singularize.camelize
+      cagg_model = Class.new(ActiveRecord::Base) do
+        self.table_name = cagg.view_name
+        self.schema_name = cagg.view_schema
+        acts_as_hypertable
+      end
+      model.const_set(cagg_model_name, cagg_model)
     end
     Timescaledb.const_set(class_name, model)
   end
 
+
   Pry.start(Timescaledb)
 end

data/lib/timescaledb/acts_as_hypertable/core.rb

@@ -35,47 +35,47 @@ module Timescaledb
             CompressionSettings.where(hypertable_name: table_name)
           end
 
-          scope :continuous_aggregates, -> do
+          scope :caggs, -> do
             ContinuousAggregates.where(hypertable_name: table_name)
           end
         end
 
         def define_default_scopes
+          scope :between, ->(start_time, end_time) do
+            where("#{time_column} BETWEEN ? AND ?", start_time, end_time)
+          end
+
           scope :previous_month, -> do
-            where(
-              "DATE(#{time_column}) >= :start_time AND DATE(#{time_column}) <= :end_time",
-              start_time: Date.today.last_month.in_time_zone.beginning_of_month.to_date,
-              end_time: Date.today.last_month.in_time_zone.end_of_month.to_date
-            )
+            ref = 1.month.ago.in_time_zone
+            between(ref.beginning_of_month, ref.end_of_month)
           end
 
           scope :previous_week, -> do
-            where(
-              "DATE(#{time_column}) >= :start_time AND DATE(#{time_column}) <= :end_time",
-              start_time: Date.today.last_week.in_time_zone.beginning_of_week.to_date,
-              end_time: Date.today.last_week.in_time_zone.end_of_week.to_date
-            )
+            ref = 1.week.ago.in_time_zone
+            between(ref.beginning_of_week, ref.end_of_week)
           end
 
           scope :this_month, -> do
-            where(
-              "DATE(#{time_column}) >= :start_time AND DATE(#{time_column}) <= :end_time",
-              start_time: Date.today.in_time_zone.beginning_of_month.to_date,
-              end_time: Date.today.in_time_zone.end_of_month.to_date
-            )
+            ref = Time.now.in_time_zone
+            between(ref.beginning_of_month, ref.end_of_month)
           end
 
           scope :this_week, -> do
-            where(
-              "DATE(#{time_column}) >= :start_time AND DATE(#{time_column}) <= :end_time",
-              start_time: Date.today.in_time_zone.beginning_of_week.to_date,
-              end_time: Date.today.in_time_zone.end_of_week.to_date
-            )
+            ref = Time.now.in_time_zone
+            between(ref.beginning_of_week, ref.end_of_week)
+          end
+
+          scope :yesterday, -> do
+            ref = 1.day.ago.in_time_zone
+            between(ref.yesterday, ref.yesterday)
+          end
+
+          scope :today, -> do
+            ref = Time.now.in_time_zone
+            between(ref.beginning_of_day, ref.end_of_day)
           end
 
-          scope :yesterday, -> { where("DATE(#{time_column}) = ?", Date.yesterday.in_time_zone.to_date) }
-          scope :today, -> { where("DATE(#{time_column}) = ?", Date.today.in_time_zone.to_date) }
-          scope :last_hour, -> { where("#{time_column} between ? and ?", 1.hour.ago.in_time_zone, Time.now.end_of_hour.in_time_zone) }
+          scope :last_hour, -> { where("#{time_column} > ?", 1.hour.ago.in_time_zone) }
         end
 
         def normalize_hypertable_options

data/lib/timescaledb/acts_as_hypertable.rb

@@ -22,7 +22,7 @@ module Timescaledb
   #   for configuration options
   module ActsAsHypertable
     DEFAULT_OPTIONS = {
-      time_column: :created_at
+      time_column: :created_at,
     }.freeze
 
     def acts_as_hypertable?
@@ -45,10 +45,12 @@ module Timescaledb
     # @param [Hash] options The options to initialize your macro with.
     # @option options [Boolean] :skip_association_scopes to avoid `.hypertable`, `.chunks` and other scopes related to metadata.
     # @option options [Boolean] :skip_default_scopes to avoid the generation of default time related scopes like `last_hour`, `last_week`, `yesterday` and so on...
+    # @option options [Boolean] :skip_time_vector to avoid the generation of time vector related scopes
     def acts_as_hypertable(options = {})
       return if acts_as_hypertable?
 
       include Timescaledb::ActsAsHypertable::Core
+      include Timescaledb::Toolkit::TimeVector
 
       class_attribute :hypertable_options, instance_writer: false
 
@@ -58,6 +60,7 @@ module Timescaledb
 
       define_association_scopes unless options[:skip_association_scopes]
       define_default_scopes unless options[:skip_default_scopes]
+      define_default_vector_scopes unless options[:skip_time_vector]
     end
   end
 end

data/lib/timescaledb/connection.rb

@@ -1,4 +1,5 @@
 require 'singleton'
+require 'ostruct'
 
 module Timescaledb
   # Minimal connection setup for Timescaledb directly with the PG.

data/lib/timescaledb/connection_handling.rb

@@ -5,12 +5,29 @@ module Timescaledb
   
   # @param [String] config with the postgres connection string.
   def establish_connection(config)
+    # Establish connection for Timescaledb
     Connection.instance.config = config
+    
+    # Also establish connection for ActiveRecord if it's defined
+    if defined?(ActiveRecord::Base)
+      ActiveRecord::Base.establish_connection(config)
+    end
   end
 
   # @param [PG::Connection] to use it directly from a raw connection
-  def use_connection conn
-    Connection.instance.use_connection conn
+  def use_connection(conn)
+    Connection.instance.use_connection(conn)
+    
+    # Also set ActiveRecord connection if it's defined
+    if defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+      ar_conn = ActiveRecord::Base.connection
+      current_conn = ar_conn.raw_connection
+      
+      # Only set if it's different to avoid redundant assignment
+      if current_conn != conn
+        ar_conn.instance_variable_set(:@raw_connection, conn)
+      end
+    end
   end
 
   def connection

data/lib/timescaledb/continuous_aggregates.rb

@@ -1,5 +1,5 @@
 module Timescaledb
-  class ContinuousAggregate < ::Timescaledb::ApplicationRecord
+  class ContinuousAggregates < ::Timescaledb::ApplicationRecord
     self.table_name = "timescaledb_information.continuous_aggregates"
     self.primary_key = 'materialization_hypertable_name'
 
@@ -39,5 +39,4 @@ module Timescaledb
       end
     end
   end
-  ContinuousAggregates = ContinuousAggregate
 end

data/lib/timescaledb/continuous_aggregates_helper.rb

@@ -0,0 +1,191 @@
+module Timescaledb
+  module ContinuousAggregatesHelper
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :rollup_rules, default: {
+        /count\(\*\)\s+as\s+(\w+)/ => 'sum(\1) as \1',
+        /sum\((\w+)\)\s+as\s+(\w+)/ => 'sum(\2) as \2',
+        /min\((\w+)\)\s+as\s+(\w+)/ => 'min(\2) as \2',
+        /max\((\w+)\)\s+as\s+(\w+)/ => 'max(\2) as \2',
+        /first\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'first(\3, \2) as \3',
+        /high\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'max(\1) as \1',
+        /low\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'min(\1) as \1',
+        /last\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'last(\3, \2) as \3',
+        /candlestick_agg\((\w+),\s*(\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'rollup(\4) as \4',
+        /stats_agg\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'rollup(\3) as \3',
+        /stats_agg\((\w+)\)\s+as\s+(\w+)/ => 'rollup(\2) as \2',
+        /state_agg\((\w+)\)\s+as\s+(\w+)/ => 'rollup(\2) as \2',
+        /percentile_agg\((\w+),\s*(\w+)\)\s+as\s+(\w+)/ => 'rollup(\3) as \3',
+        /heartbeat_agg\((\w+)\)\s+as\s+(\w+)/ => 'rollup(\2) as \2',
+        /stats_agg\(([^)]+)\)\s+(as\s+(\w+))/ => 'rollup(\3) \2',
+        /stats_agg\((.*)\)\s+(as\s+(\w+))/ => 'rollup(\3) \2'
+      }
+
+      scope :rollup, ->(interval) do
+        select_values = (self.select_values - ["time"]).select{|e|!e.downcase.start_with?("time_bucket")}
+        if self.select_values.any?{|e|e.downcase.start_with?('time_bucket(')} || self.select_values.include?('time')
+          select_values = apply_rollup_rules(select_values)
+          select_values.gsub!(/time_bucket\((.+), (.+)\)/, "time_bucket(#{interval}, \2)")
+          select_values.gsub!(/\btime\b/, "time_bucket(#{interval}, time) as time")
+        end
+        group_values = self.group_values.dup
+
+        if self.segment_by_column
+          if !group_values.include?(self.segment_by_column)
+            group_values << self.segment_by_column
+          end
+          if !select_values.include?(self.segment_by_column.to_s)
+            select_values.insert(0, self.segment_by_column.to_s)
+          end
+        end
+        where_values = self.where_values_hash
+        tb = "time_bucket(#{interval}, #{time_column})"
+        self.unscoped.select("#{tb} as #{time_column}, #{select_values.join(', ')}")
+          .where(where_values)
+          .group(tb, *group_values)
+      end
+    end
+
+    class_methods do
+      def continuous_aggregates(options = {})
+        @time_column = options[:time_column] || self.time_column
+        @timeframes = options[:timeframes] || [:minute, :hour, :day, :week, :month, :year]
+        
+        scopes = options[:scopes] || []
+        @aggregates = {}
+
+        scopes.each do |scope_name|
+          @aggregates[scope_name] = {
+            scope_name: scope_name,
+            select: nil,
+            group_by: nil,
+            refresh_policy: options[:refresh_policy] || {}
+          }
+        end
+
+        # Allow for custom aggregate definitions to override or add to scope-based ones
+        @aggregates.merge!(options[:aggregates] || {})
+
+        # Add custom rollup rules if provided
+        self.rollup_rules.merge!(options[:custom_rollup_rules] || {})
+
+        define_continuous_aggregate_classes unless options[:skip_definition]
+      end
+
+      def refresh_aggregates(timeframes = nil)
+        timeframes ||= @timeframes
+        @aggregates.each do |aggregate_name, _|
+          timeframes.each do |timeframe|
+            klass = const_get("#{aggregate_name}_per_#{timeframe}".classify)
+            klass.refresh!
+          end
+        end
+      end
+
+      def create_continuous_aggregates(with_data: false)
+        @aggregates.each do |aggregate_name, config|
+          @timeframes.each do |timeframe|
+            klass = const_get("#{aggregate_name}_per_#{timeframe}".classify)
+            connection.execute <<~SQL
+              CREATE MATERIALIZED VIEW IF NOT EXISTS #{klass.table_name}
+              WITH (timescaledb.continuous) AS
+              #{klass.base_query}
+              #{with_data ? 'WITH DATA' : 'WITH NO DATA'};
+            SQL
+
+            if (policy = klass.refresh_policy)
+              connection.execute <<~SQL
+                SELECT add_continuous_aggregate_policy('#{klass.table_name}',
+                  start_offset => INTERVAL '#{policy[:start_offset]}',
+                  end_offset =>  INTERVAL '#{policy[:end_offset]}',
+                  schedule_interval => INTERVAL '#{policy[:schedule_interval]}');
+              SQL
+            end
+          end
+        end
+      end
+
+      def apply_rollup_rules(select_values)
+        result = select_values.dup
+        rollup_rules.each do |pattern, replacement|
+          result.gsub!(pattern, replacement)
+        end
+        # Remove any remaining time_bucket
+        result.gsub!(/time_bucket\(.+?\)( as \w+)?/, '')
+        result
+      end
+
+      def drop_continuous_aggregates
+        @aggregates.each do |aggregate_name, _|
+          @timeframes.reverse_each do |timeframe|
+            view_name = "#{aggregate_name}_per_#{timeframe}"
+            connection.execute("DROP MATERIALIZED VIEW IF EXISTS #{view_name} CASCADE")
+          end
+        end
+      end
+
+      private
+
+      def define_continuous_aggregate_classes
+        base_model = self
+        @aggregates.each do |aggregate_name, config|
+          previous_timeframe = nil
+          @timeframes.each do |timeframe|
+            _table_name = "#{aggregate_name}_per_#{timeframe}"
+            class_name = "#{aggregate_name}_per_#{timeframe}".classify
+            const_set(class_name, Class.new(base_model) do
+              class << self
+                attr_accessor :config, :timeframe, :base_query, :base_model
+              end
+
+              self.table_name = _table_name
+              self.config = config
+              self.timeframe = timeframe
+
+              interval = "'1 #{timeframe.to_s}'"
+              self.base_model = base_model
+              tb = "time_bucket(#{interval}, #{time_column})"
+              if previous_timeframe
+                prev_klass = base_model.const_get("#{aggregate_name}_per_#{previous_timeframe}".classify)
+                select_clause = base_model.apply_rollup_rules("#{config[:select]}")
+                # Note there's no where clause here, because we're using the previous timeframe's data
+                self.base_query = "SELECT #{tb} as #{time_column}, #{select_clause} FROM \"#{prev_klass.table_name}\" GROUP BY #{[tb, *config[:group_by]].join(', ')}"
+              else
+                scope = base_model.public_send(config[:scope_name])
+                config[:select] = scope.select_values.select{|e|!e.downcase.start_with?("time_bucket")}.join(', ')
+                config[:group_by] = scope.group_values
+                config[:where] = if scope.where_values_hash.present?
+                  scope.where_values_hash.to_sql
+                  elsif scope.where_clause.ast.present? && scope.where_clause.ast.to_sql.present?
+                  scope.where_clause.ast.to_sql
+                end
+                self.base_query = "SELECT #{tb} as #{time_column}, #{config[:select]}"
+                self.base_query += " FROM \"#{base_model.table_name}\""
+                self.base_query += " WHERE #{config[:where]}" if config[:where]
+                self.base_query += " GROUP BY #{[tb, *config[:group_by]].join(', ')}"
+              end
+
+              def self.refresh!(start_time = nil, end_time = nil)
+                if start_time && end_time
+                  connection.execute("CALL refresh_continuous_aggregate('#{table_name}', '#{start_time}', '#{end_time}')")
+                else
+                  connection.execute("CALL refresh_continuous_aggregate('#{table_name}', null, null)")
+                end
+              end
+
+              def readonly?
+                true
+              end
+
+              def self.refresh_policy
+                config[:refresh_policy]&.dig(timeframe)
+              end
+            end)
+            previous_timeframe = timeframe
+          end
+        end
+      end
+    end
+  end
+end

data/lib/timescaledb/counter_cache.rb

@@ -0,0 +1,88 @@
+module Timescaledb
+  module CounterCache
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :counter_cache_options, default: {}
+    end
+
+    module ClassMethods
+      def belongs_to_with_counter_cache(name, scope = nil, **options)
+        if options[:counter_cache] == :timescaledb || options[:counter_cache].is_a?(Array)
+          setup_timescaledb_counter_cache(name, options)
+          options.delete(:counter_cache)
+        end
+        
+        belongs_to(name, scope, **options)
+      end
+
+      private
+
+      def setup_timescaledb_counter_cache(association_name, options)
+        timeframes = if options[:counter_cache] == :timescaledb
+          [:hour, :day]  # Default timeframes
+        else
+          options[:counter_cache]
+        end
+
+        # Store counter cache configuration
+        self.counter_cache_options[association_name] = {
+          timeframes: timeframes,
+          foreign_key: options[:foreign_key] || "#{association_name}_id"
+        }
+
+        # Setup continuous aggregate for counting
+        setup_counter_aggregate(association_name, timeframes)
+        
+        # Setup associations on the target class
+        setup_target_associations(association_name, timeframes)
+      end
+
+      def setup_counter_aggregate(association_name, timeframes)
+        scope_name = "#{association_name}_count"
+        
+        # Define the base counting scope
+        scope scope_name, -> { select(counter_cache_options[association_name][:foreign_key], "count(*) as count").group(1) }
+        
+        # Create continuous aggregates for each timeframe
+        continuous_aggregates(
+          scopes: [scope_name],
+          timeframes: timeframes,
+          refresh_policy: {
+            start_offset: "1 day",
+            end_offset: "1 hour",
+            schedule_interval: "1 hour"
+          }
+        )
+      end
+
+      def setup_target_associations(association_name, timeframes)
+        target_class = reflect_on_association(association_name).klass
+        
+        timeframes.each do |timeframe|
+          view_name = "#{table_name}_#{association_name}_count_per_#{timeframe}"
+          
+          target_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            has_many :#{view_name.pluralize},
+                     class_name: "#{self}::#{association_name.to_s.classify}CountPer#{timeframe.to_s.classify}",
+                     foreign_key: :#{counter_cache_options[association_name][:foreign_key]}
+
+            def #{view_name}_total
+              #{view_name.pluralize}.sum(:count)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+# Extend ActiveRecord with counter cache functionality
+ActiveSupport.on_load(:active_record) do
+  extend Timescaledb::CounterCache
+  
+  class << self
+    alias_method :belongs_to_without_counter_cache, :belongs_to
+    alias_method :belongs_to, :belongs_to_with_counter_cache
+  end
+end

data/lib/timescaledb/hypertable.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module Timescaledb
   class Hypertable < ::Timescaledb::ApplicationRecord
     self.table_name = "timescaledb_information.hypertables"

data/lib/timescaledb/migration_helpers.rb

@@ -16,7 +16,7 @@ module Timescaledb
     #    chunk_time_interval: '1 min',
     #    compress_segmentby: 'identifier',
     #    compress_orderby: 'created_at',
-    #    compression_interval: '7 days'
+    #    compress_after: '7 days'
     #  }
     #
     #  create_table(:events, id: false, hypertable: options) do |t|
@@ -41,7 +41,8 @@ module Timescaledb
                           chunk_time_interval: '1 week',
                           compress_segmentby: nil,
                           compress_orderby: 'created_at',
-                          compression_interval: nil,
+                          compress_after: nil,
+                          drop_after: nil,
                           partition_column: nil,
                           number_partitions: nil,
                           **hypertable_options)
@@ -49,30 +50,24 @@ module Timescaledb
       original_logger = ActiveRecord::Base.logger
       ActiveRecord::Base.logger = Logger.new(STDOUT)
 
-      options = ["chunk_time_interval => #{chunk_time_interval_clause(chunk_time_interval)}"]
-      options += hypertable_options.map { |k, v| "#{k} => #{quote(v)}" }
+      dimension = "by_range(#{quote(time_column)}, #{parse_interval(chunk_time_interval)})"
 
-      arguments = [
-        quote(table_name),
-        quote(time_column),
-        (quote(partition_column) if partition_column),
-        (number_partitions if partition_column),
-        *options
+      arguments = [ quote(table_name), dimension,
+        *hypertable_options.map { |k, v| "#{k} => #{quote(v)}" }
       ]
 
       execute "SELECT create_hypertable(#{arguments.compact.join(', ')})"
 
-      if compress_segmentby
-        execute <<~SQL
-          ALTER TABLE #{table_name} SET (
-            timescaledb.compress,
-            timescaledb.compress_orderby = '#{compress_orderby}',
-            timescaledb.compress_segmentby = '#{compress_segmentby}'
-          )
-        SQL
+      if partition_column && number_partitions
+        execute "SELECT add_dimension('#{table_name}', by_hash(#{quote(partition_column)}, #{number_partitions}))"
       end
-      if compression_interval
-        execute "SELECT add_compression_policy('#{table_name}', INTERVAL '#{compression_interval}')"
+
+      if compress_segmentby || compress_after
+        add_compression_policy(table_name, orderby: compress_orderby, segmentby: compress_segmentby, compress_after: compress_after)
+      end
+
+      if drop_after
+        add_retention_policy(table_name, drop_after: drop_after)
       end
     ensure
       ActiveRecord::Base.logger = original_logger if original_logger
@@ -146,14 +141,40 @@ module Timescaledb
       execute "SELECT remove_continuous_aggregate_policy('#{table_name}')"
     end
 
-    def create_retention_policy(table_name, interval:)
-      execute "SELECT add_retention_policy('#{table_name}', INTERVAL '#{interval}')"
+    def create_retention_policy(table_name, drop_after:)
+      execute "SELECT add_retention_policy('#{table_name}', drop_after => #{parse_interval(drop_after)})"
     end
 
+    alias_method :add_retention_policy, :create_retention_policy
+
     def remove_retention_policy(table_name)
       execute "SELECT remove_retention_policy('#{table_name}')"
     end
 
+
+    # Enable compression policy.
+    #
+    # @param table_name [String] The name of the table.
+    # @param orderby [String] The column to order by.
+    # @param segmentby [String] The column to segment by.
+    # @param compress_after [String] The interval to compress after.
+    # @param compression_chunk_time_interval [String] In case to merge chunks.
+    #
+    # @see https://docs.timescale.com/api/latest/compression/add_compression_policy/
+    def add_compression_policy(table_name, orderby:, segmentby:, compress_after: nil, compression_chunk_time_interval: nil)
+      options = []
+      options << 'timescaledb.compress'
+      options << "timescaledb.compress_orderby = '#{orderby}'" if orderby
+      options << "timescaledb.compress_segmentby = '#{segmentby}'" if segmentby
+      options << "timescaledb.compression_chunk_time_interval = INTERVAL '#{compression_chunk_time_interval}'" if compression_chunk_time_interval
+      execute <<~SQL
+        ALTER TABLE #{table_name} SET (
+          #{options.join(',')}
+        )
+      SQL
+      execute "SELECT add_compression_policy('#{table_name}', compress_after => INTERVAL '#{compress_after}')" if compress_after
+    end
+
     private
 
     # Build a string for the WITH clause of the CREATE MATERIALIZED VIEW statement.
@@ -166,11 +187,11 @@ module Timescaledb
       ",timescaledb.#{option_key}=#{value}"
     end
 
-    def chunk_time_interval_clause(chunk_time_interval)
-      if chunk_time_interval.is_a?(Numeric)
-        chunk_time_interval
+    def parse_interval(interval)
+      if interval.is_a?(Numeric)
+        interval
       else
-        "INTERVAL '#{chunk_time_interval}'"
+        "INTERVAL '#{interval}'"
       end
     end
   end

data/lib/timescaledb/schema_dumper.rb

@@ -90,7 +90,7 @@ module Timescaledb
 
     def timescale_retention_policy(hypertable, stream)
       hypertable.jobs.where(proc_name: "policy_retention").each do |job|
-        stream.puts %Q[  create_retention_policy "#{job.hypertable_name}", interval: "#{job.config["drop_after"]}"]
+        stream.puts %Q[  create_retention_policy "#{job.hypertable_name}", drop_after: "#{job.config["drop_after"]}"]
       end
     end
 
@@ -106,14 +106,12 @@ module Timescaledb
         if setting.orderby_column_index
           if setting.orderby_asc
             direction = "ASC"
-            if setting.orderby_nullsfirst
-              direction += " NULLS FIRST"
-            end
+            # For ASC, default is NULLS LAST, so only add if explicitly set to FIRST
+            direction += " NULLS FIRST" if setting.orderby_nullsfirst == true
           else
             direction = "DESC"
-            if !setting.orderby_nullsfirst
-              direction += " NULLS LAST"
-            end
+            # For DESC, default is NULLS FIRST, so only add if explicitly set to LAST
+            direction += " NULLS LAST" if setting.orderby_nullsfirst == false
           end
 
           compression_settings[:compress_orderby] << "#{setting.attname} #{direction}"
@@ -121,7 +119,7 @@ module Timescaledb
       end
 
       hypertable.jobs.compression.each do |job|
-        compression_settings[:compression_interval] = job.config["compress_after"]
+        compression_settings[:compress_after] = job.config["compress_after"]
       end
 
       # Pack the compression setting arrays into a comma-separated string instead.

data/lib/timescaledb/toolkit/time_vector.rb

@@ -9,23 +9,23 @@ module Timescaledb
 
       module ClassMethods
         def value_column
-          @value_column ||= time_vector_options[:value_column] || :val
+          @value_column ||= hypertable_options[:value_column] || :val
         end
 
         def time_column
-          respond_to?(:time_column) && super || time_vector_options[:time_column]
+          respond_to?(:time_column) && super || hypertable_options[:time_column]
         end
 
         def segment_by_column
-          time_vector_options[:segment_by]
+          hypertable_options[:segment_by] || hypertable_options[:compress_segment_by]
         end
 
         protected
 
-        def define_default_scopes
-          scope :volatility, -> (segment_by: segment_by_column) do
+        def define_default_vector_scopes
+          scope :volatility, -> (segment_by: segment_by_column, value: value_column) do
             select([*segment_by,
-               "timevector(#{time_column}, #{value_column}) -> sort() -> delta() -> abs() -> sum() as volatility"
+               "timevector(#{time_column}, #{value}) -> sort() -> delta() -> abs() -> sum() as volatility"
             ].join(", ")).group(segment_by)
           end
 
@@ -36,11 +36,15 @@ module Timescaledb
               .group(segment_by)
           end
 
-          scope :lttb, -> (threshold:, segment_by: segment_by_column, time: time_column, value: value_column) do
+          scope :lttb, -> (threshold:, segment_by: segment_by_column, time: time_column, value: value_column, value_exp: value_column) do
+            if value =~ /(.*)\bas\b(.*)/
+              value_exp = $1
+              value = $2
+            end
             lttb_query = <<~SQL
-              WITH x AS ( #{select(*segment_by, time_column, value_column).to_sql})
+              WITH x AS ( #{select(*segment_by, time_column, value_exp || value).to_sql})
               SELECT #{"x.#{segment_by}," if segment_by}
-                (lttb( x.#{time_column}, x.#{value_column}, #{threshold}) -> unnest()).*
+                (lttb( x.#{time_column}, x.#{value}, #{threshold}) -> unnest()).*
               FROM x
               #{"GROUP BY #{segment_by}" if segment_by}
             SQL

data/lib/timescaledb/toolkit.rb

@@ -1,3 +1,2 @@
 require_relative "toolkit/helpers"
-require_relative "acts_as_time_vector"
 require_relative "toolkit/time_vector"

data/lib/timescaledb/version.rb

@@ -1,3 +1,3 @@
 module Timescaledb
-  VERSION = '0.3.0'
+  VERSION = '0.3.2'
 end

data/lib/timescaledb.rb

@@ -3,6 +3,7 @@ require 'active_record'
 require_relative 'timescaledb/application_record'
 require_relative 'timescaledb/acts_as_hypertable'
 require_relative 'timescaledb/acts_as_hypertable/core'
+require_relative 'timescaledb/continuous_aggregates_helper'
 require_relative 'timescaledb/connection'
 require_relative 'timescaledb/toolkit'
 require_relative 'timescaledb/chunk'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-06 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +152,7 @@ dependencies:
         version: '0'
 description: Functions from timescaledb available in the ActiveRecord models.
 email:
-- jonatasdp@gmail.com
+- jonatas@timescale.com
 executables:
 - tsdb
 extensions: []
@@ -149,13 +163,14 @@ files:
 - lib/timescaledb.rb
 - lib/timescaledb/acts_as_hypertable.rb
 - lib/timescaledb/acts_as_hypertable/core.rb
-- lib/timescaledb/acts_as_time_vector.rb
 - lib/timescaledb/application_record.rb
 - lib/timescaledb/chunk.rb
 - lib/timescaledb/compression_settings.rb
 - lib/timescaledb/connection.rb
 - lib/timescaledb/connection_handling.rb
 - lib/timescaledb/continuous_aggregates.rb
+- lib/timescaledb/continuous_aggregates_helper.rb
+- lib/timescaledb/counter_cache.rb
 - lib/timescaledb/database.rb
 - lib/timescaledb/database/chunk_statements.rb
 - lib/timescaledb/database/hypertable_statements.rb
@@ -181,12 +196,13 @@ files:
 - lib/timescaledb/toolkit/helpers.rb
 - lib/timescaledb/toolkit/time_vector.rb
 - lib/timescaledb/version.rb
-homepage: https://github.com/jonatas/timescaledb
+homepage: https://github.com/timescale/timescaledb-ruby
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/jonatas/timescaledb
+  homepage_uri: https://timescale.github.io/timescaledb-ruby/
+  source_code_uri: https://github.com/timescale/timescaledb-ruby
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -202,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: TimescaleDB helpers for Ruby ecosystem.

data/lib/timescaledb/acts_as_time_vector.rb

@@ -1,18 +0,0 @@
-module Timescaledb
-  module ActsAsTimeVector
-    def acts_as_time_vector(options = {})
-      return if acts_as_time_vector?
-
-      include Timescaledb::Toolkit::TimeVector
-
-      class_attribute :time_vector_options, instance_writer: false
-      define_default_scopes
-      self.time_vector_options = options
-    end
-
-    def acts_as_time_vector?
-      included_modules.include?(Timescaledb::ActsAsTimeVector)
-    end
-  end
-end
-ActiveRecord::Base.extend Timescaledb::ActsAsTimeVector