timescaledb 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f5295cfa57caa17bb740b28dd70f54fb0c239f9d011233ae04cfffa2bbfadbf
-  data.tar.gz: ec1b742c312d289124522e490fe47269d7aa6b9774ce0d82fe99bed206ce227c
+  metadata.gz: 2a82c28a5761d43b30d50afa56a1b41b4e27e81c0280c1a79659cef76430fed8
+  data.tar.gz: c7b912b564a84a5904194f4a05e4767229538285298513d7f1940d93208dbfe0
 SHA512:
-  metadata.gz: f1a0937798a8f97bccaf8a39d61268fc040f525f04b92632e1a0fc7c8d892d73b39d7f4fd7252fe430ac3f53523b5a01570bc89257aff8cef35fa68c161204e4
-  data.tar.gz: 460df42d48ceac9d552c47408655a9c9330b3efe9bc40d8963021e7c2f4e297d4210c54fc6fe43678f56dc156ac28836f7b06d17d11977fa82a134cb356c9127
+  metadata.gz: 82f1e4582467e4ac74cb9a14323667a40be51b12edd4181fe50be5c73779b6256833c2885863fa10b23c1808cf82b06328f477e2cf0ca4e554db444ddb4f20ab
+  data.tar.gz: 51bcf8fa51b7463fcd99542d4917217e51507388eb7bb660a15406d0a0a690b7f612efd3d0514e1a6189156983a031f461fc0a58976e6145f43cfe55368f82f7

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

@@ -41,41 +41,41 @@ module Timescaledb
         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

@@ -23,7 +23,6 @@ module Timescaledb
   module ActsAsHypertable
     DEFAULT_OPTIONS = {
       time_column: :created_at,
-      # Add any default time vector options here if needed
     }.freeze
 
     def acts_as_hypertable?

data/lib/timescaledb/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Timescaledb
+  class Configuration
+    attr_accessor :scenic_integration
+
+    DEFAULTS = {
+      scenic_integration: :enabled
+    }.freeze
+
+    def initialize
+      @scenic_integration = DEFAULTS[:scenic_integration]
+    end
+
+    def enable_scenic_integration?
+      case @scenic_integration
+      when :enabled then scenic_detected?
+      else false # :disabled, :false, nil, etc.
+      end
+    end
+
+    private
+
+    def scenic_detected?
+      # Try to require scenic to see if it's available
+      require 'scenic'
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/timescaledb/connection_handling.rb

@@ -2,15 +2,32 @@ module Timescaledb
   class ConnectionNotEstablishedError < StandardError; end
 
   module_function
-  
+
   # @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

@@ -3,8 +3,7 @@ module Timescaledb
     self.table_name = "timescaledb_information.continuous_aggregates"
     self.primary_key = 'materialization_hypertable_name'
 
-    has_many :jobs, foreign_key: "hypertable_name",
-      class_name: "Timescaledb::Job"
+    has_many :jobs, foreign_key: 'hypertable_name', primary_key: 'view_name', class_name: 'Timescaledb::Job'
 
     has_many :chunks, foreign_key: "hypertable_name",
       class_name: "Timescaledb::Chunk"

data/lib/timescaledb/continuous_aggregates_helper.rb

@@ -18,6 +18,8 @@ module Timescaledb
         /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
@@ -134,25 +136,47 @@ module Timescaledb
             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
+                attr_accessor :config, :timeframe, :base_query, :base_model, :previous_timeframe, :interval, :aggregate_name, :prev_klass
               end
 
               self.table_name = _table_name
               self.config = config
               self.timeframe = timeframe
+              self.previous_timeframe = previous_timeframe
+              self.aggregate_name = aggregate_name
 
-              interval = "'1 #{timeframe.to_s}'"
+              self.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]}")
-                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
-                self.base_query = "SELECT #{tb} as #{time_column}, #{config[:select]} FROM \"#{scope.table_name}\" GROUP BY #{[tb, *config[:group_by]].join(', ')}"
+
+              def self.prev_klass
+                base_model.const_get("#{aggregate_name}_per_#{previous_timeframe}".classify)
+              end
+
+              def self.base_query
+                @base_query ||= begin
+                  tb = "time_bucket(#{interval}, #{time_column})"
+                  if previous_timeframe
+                    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
+                    "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.map { |key, value| "#{key} = '#{value}'" }.join(' AND ')
+                      elsif scope.where_clause.ast.present? && scope.where_clause.ast.to_sql.present?
+                        scope.where_clause.ast.to_sql
+                      end
+
+                    sql = "SELECT #{tb} as #{time_column}, #{config[:select]}"
+                    sql += " FROM \"#{base_model.table_name}\""
+                    sql += " WHERE #{config[:where]}" if config[:where]
+                    sql += " GROUP BY #{[tb, *config[:group_by]].join(', ')}"
+                    sql
+                  end
+                end
               end
 
               def self.refresh!(start_time = nil, end_time = nil)

data/lib/timescaledb/migration_helpers.rb

@@ -48,7 +48,7 @@ module Timescaledb
                           **hypertable_options)
 
       original_logger = ActiveRecord::Base.logger
-      ActiveRecord::Base.logger = Logger.new(STDOUT)
+      ActiveRecord::Base.logger = Logger.new(STDOUT) unless original_logger.nil?
 
       dimension = "by_range(#{quote(time_column)}, #{parse_interval(chunk_time_interval)})"
 
@@ -84,7 +84,9 @@ module Timescaledb
     # @option refresh_policies [String] schedule_interval: INTERVAL
     # @option materialized_only [Boolean] Override the WITH clause 'timescaledb.materialized_only'
     # @option create_group_indexes [Boolean] Override the WITH clause 'timescaledb.create_group_indexes'
-    # @option finalized [Boolean] Override the WITH clause 'timescaledb.finalized'
+    # @option finalized [Boolean] Set to false for legacy (non-finalized) format. Note: the finalized
+    #   parameter was removed in TimescaleDB 2.14+ where all aggregates are finalized by default.
+    #   Only use finalized: false on TimescaleDB 2.7-2.13 for legacy compatibility.
     #
     # @see https://docs.timescale.com/api/latest/continuous-aggregates/create_materialized_view/
     # @see https://docs.timescale.com/api/latest/continuous-aggregates/add_continuous_aggregate_policy/
@@ -99,13 +101,17 @@ module Timescaledb
     #   SQL
     #
     def create_continuous_aggregate(table_name, query, **options)
+      # Only include finalized when explicitly false (legacy format).
+      # The parameter was removed in TimescaleDB 2.14+ where all aggregates are finalized by default.
+      finalized_clause = options[:finalized] == false ? ",timescaledb.finalized=false" : ""
+
       execute <<~SQL
         CREATE MATERIALIZED VIEW #{table_name}
         WITH (
           timescaledb.continuous
           #{build_with_clause_option_string(:materialized_only, options)}
           #{build_with_clause_option_string(:create_group_indexes, options)}
-          #{build_with_clause_option_string(:finalized, options)}
+          #{finalized_clause}
         ) AS
         #{query.respond_to?(:to_sql) ? query.to_sql : query}
         WITH #{'NO' unless options[:with_data]} DATA;

data/lib/timescaledb/scenic/extension.rb

@@ -67,5 +67,3 @@ module Timescaledb
 end
 
 
-Scenic::Adapters::Postgres.include(Timescaledb::Scenic::Extension)
-ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(Timescaledb::Scenic::MigrationHelpers)

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
 
@@ -119,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.
@@ -162,7 +162,10 @@ module Timescaledb
           ""
         end
 
-        with_clause_opts = "materialized_only: #{aggregate[:materialized_only]}, finalized: #{aggregate[:finalized]}"
+        # Only output finalized when false (legacy format) - the parameter was
+        # removed in TimescaleDB 2.14+ where all aggregates are finalized by default
+        with_clause_opts = "materialized_only: #{aggregate[:materialized_only]}"
+        with_clause_opts += ", finalized: false" if aggregate[:finalized] == false
         stream.puts <<~AGG.indent(2)
           create_continuous_aggregate("#{aggregate.view_name}", <<-SQL, #{refresh_policies_opts}#{with_clause_opts})
             #{aggregate.view_definition.strip.gsub(/;$/, '')}

data/lib/timescaledb/version.rb

@@ -1,3 +1,3 @@
 module Timescaledb
-  VERSION = '0.3.1'
+  VERSION = '0.3.3'
 end

data/lib/timescaledb.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
+require_relative 'timescaledb/configuration'
 require_relative 'timescaledb/application_record'
 require_relative 'timescaledb/acts_as_hypertable'
 require_relative 'timescaledb/acts_as_hypertable/core'
@@ -22,6 +25,39 @@ require_relative 'timescaledb/extension'
 require_relative 'timescaledb/version'
 
 module Timescaledb
+  class << self
+    def configure
+      yield(configuration) if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def setup_scenic_integration
+      return unless configuration.enable_scenic_integration?
+      return if @scenic_integration_setup
+
+      begin
+        require 'scenic'
+        require_relative 'timescaledb/scenic/adapter'
+        require_relative 'timescaledb/scenic/extension'
+
+        ::Scenic.configure do |config|
+          config.database = Timescaledb::Scenic::Adapter.new
+        end
+
+        ::Scenic::Adapters::Postgres.include(Timescaledb::Scenic::Extension)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(Timescaledb::Scenic::MigrationHelpers)
+
+        @scenic_integration_setup = true
+      rescue LoadError
+        # This is expected when the scenic gem is not being used
+        @scenic_integration_setup = false
+      end
+    end
+  end
+
   module_function
 
   def connection
@@ -65,15 +101,12 @@ module Timescaledb
   end
 end
 
-begin
-  require 'scenic'
-  require_relative 'timescaledb/scenic/adapter'
-  require_relative 'timescaledb/scenic/extension'
-
-  Scenic.configure do |config|
-    config.database = Timescaledb::Scenic::Adapter.new
+# Delay scenic integration setup to respect user configuration when using Rails
+if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+  ActiveSupport.on_load(:active_record) do
+    Timescaledb.setup_scenic_integration
   end
-
-rescue LoadError
-  # This is expected when the scenic gem is not being used
+else
+  # For non-Rails usage, setup immediately
+  Timescaledb.setup_scenic_integration
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Jônatas Davi Paganini
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-20 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -166,6 +165,7 @@ files:
 - lib/timescaledb/application_record.rb
 - lib/timescaledb/chunk.rb
 - lib/timescaledb/compression_settings.rb
+- lib/timescaledb/configuration.rb
 - lib/timescaledb/connection.rb
 - lib/timescaledb/connection_handling.rb
 - lib/timescaledb/continuous_aggregates.rb
@@ -202,7 +202,6 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://timescale.github.io/timescaledb-ruby/
   source_code_uri: https://github.com/timescale/timescaledb-ruby
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -217,8 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: TimescaleDB helpers for Ruby ecosystem.
 test_files: []