timescaledb 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f5295cfa57caa17bb740b28dd70f54fb0c239f9d011233ae04cfffa2bbfadbf
-  data.tar.gz: ec1b742c312d289124522e490fe47269d7aa6b9774ce0d82fe99bed206ce227c
+  metadata.gz: 33706a3c899ae608bb30b9ef62ca32875045960745b526bc0700fddec09ddc8b
+  data.tar.gz: 88a7cb9f1f2f2dbb68f131547fa7c9575979f6e87b0bb29f576ee95d9bb9696c
 SHA512:
-  metadata.gz: f1a0937798a8f97bccaf8a39d61268fc040f525f04b92632e1a0fc7c8d892d73b39d7f4fd7252fe430ac3f53523b5a01570bc89257aff8cef35fa68c161204e4
-  data.tar.gz: 460df42d48ceac9d552c47408655a9c9330b3efe9bc40d8963021e7c2f4e297d4210c54fc6fe43678f56dc156ac28836f7b06d17d11977fa82a134cb356c9127
+  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

@@ -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/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_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
@@ -147,12 +149,21 @@ module Timescaledb
               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
-                self.base_query = "SELECT #{tb} as #{time_column}, #{config[:select]} FROM \"#{scope.table_name}\" GROUP BY #{[tb, *config[:group_by]].join(', ')}"
+                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)

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/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.

data/lib/timescaledb/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-20 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -170,6 +170,7 @@ files:
 - 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