timescaledb 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33706a3c899ae608bb30b9ef62ca32875045960745b526bc0700fddec09ddc8b
-  data.tar.gz: 88a7cb9f1f2f2dbb68f131547fa7c9575979f6e87b0bb29f576ee95d9bb9696c
+  metadata.gz: 2a82c28a5761d43b30d50afa56a1b41b4e27e81c0280c1a79659cef76430fed8
+  data.tar.gz: c7b912b564a84a5904194f4a05e4767229538285298513d7f1940d93208dbfe0
 SHA512:
-  metadata.gz: a700d4b61d11af54856fb02e19db676a720ba5ff3c2367e7eb9ba153bc14ae1c3c67d9130bfc47e1ecac786a007274df9c3595a6b10fe797fb06b13ae30ac957
-  data.tar.gz: 05c45d270e86c24d40984cea92e8870869441580d35426b5028ca17b346a47ad7468482337adec69eaf0d6daecdd4292d7108868677a7388f35cf2529d7e631a
+  metadata.gz: 82f1e4582467e4ac74cb9a14323667a40be51b12edd4181fe50be5c73779b6256833c2885863fa10b23c1808cf82b06328f477e2cf0ca4e554db444ddb4f20ab
+  data.tar.gz: 51bcf8fa51b7463fcd99542d4917217e51507388eb7bb660a15406d0a0a690b7f612efd3d0514e1a6189156983a031f461fc0a58976e6145f43cfe55368f82f7

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,12 +2,12 @@ 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)
@@ -17,12 +17,12 @@ module Timescaledb
   # @param [PG::Connection] to use it directly from a raw connection
   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)

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

@@ -136,34 +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]}")
-                # 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
+
+              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
-                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)

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

@@ -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.2'
+  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.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Jônatas Davi Paganini
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-18 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -166,11 +165,11 @@ 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
 - 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
@@ -203,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
@@ -218,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: []

data/lib/timescaledb/counter_cache.rb

@@ -1,88 +0,0 @@
-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