timescaledb 0.2.9 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89553264709636b53e3d56174f3e244561c10f2c4801b922ba25adb8bf32aca7
-  data.tar.gz: f254f76133d13d6854f8f7dee865a0f3bb4adc57617c200ee276d1408541475a
+  metadata.gz: 0f5295cfa57caa17bb740b28dd70f54fb0c239f9d011233ae04cfffa2bbfadbf
+  data.tar.gz: ec1b742c312d289124522e490fe47269d7aa6b9774ce0d82fe99bed206ce227c
 SHA512:
-  metadata.gz: b30bbba9b0da08b3cad42fbc80e73c7aed2e37763d01cfd2b93d569e4bd65768a507fc6e25a757c7b83bd4f9ad3e7e18d98090b7a2f2e8bebcb5d16fb3a63d7c
-  data.tar.gz: bb0ba7379e86631d71256cf66cc506eb42511145f17e343e749bc10e28b7c394a482e9d4a3380ff9ee2af511be51d44529556566fe08421aa92b924755d492c8
+  metadata.gz: f1a0937798a8f97bccaf8a39d61268fc040f525f04b92632e1a0fc7c8d892d73b39d7f4fd7252fe430ac3f53523b5a01570bc89257aff8cef35fa68c161204e4
+  data.tar.gz: 460df42d48ceac9d552c47408655a9c9330b3efe9bc40d8963021e7c2f4e297d4210c54fc6fe43678f56dc156ac28836f7b06d17d11977fa82a134cb356c9127

data/lib/timescaledb/acts_as_hypertable/core.rb

@@ -35,7 +35,7 @@ module Timescaledb
             CompressionSettings.where(hypertable_name: table_name)
           end
 
-          scope :continuous_aggregates, -> do
+          scope :caggs, -> do
             ContinuousAggregates.where(hypertable_name: table_name)
           end
         end

data/lib/timescaledb/acts_as_hypertable.rb

@@ -22,7 +22,8 @@ module Timescaledb
   #   for configuration options
   module ActsAsHypertable
     DEFAULT_OPTIONS = {
-      time_column: :created_at
+      time_column: :created_at,
+      # Add any default time vector options here if needed
     }.freeze
 
     def acts_as_hypertable?
@@ -45,10 +46,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,8 +61,8 @@ 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
 
-ActiveRecord::Base.extend Timescaledb::ActsAsHypertable

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/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'
 
@@ -14,6 +14,29 @@ module Timescaledb
         total: count
       }
     end
+
+    scope :hierarchical, -> do
+      with_recursive = <<~SQL
+        WITH RECURSIVE caggs AS (
+          SELECT mat_hypertable_id, parent_mat_hypertable_id, user_view_name
+            FROM _timescaledb_catalog.continuous_agg
+          UNION ALL
+          SELECT continuous_agg.mat_hypertable_id, continuous_agg.parent_mat_hypertable_id, continuous_agg.user_view_name
+            FROM _timescaledb_catalog.continuous_agg
+        JOIN caggs ON caggs.parent_mat_hypertable_id = continuous_agg.mat_hypertable_id
+        )
+        SELECT * FROM caggs
+        ORDER BY mat_hypertable_id
+      SQL
+      views = unscoped
+        .select("distinct user_view_name")
+        .from("(#{with_recursive}) as caggs")
+        .pluck(:user_view_name)
+        .uniq
+
+      views.map do |view|
+        find_by(view_name: view)
+      end
+    end
   end
-  ContinuousAggregates = ContinuousAggregate
 end

data/lib/timescaledb/continuous_aggregates_helper.rb

@@ -0,0 +1,180 @@
+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',
+      }
+
+      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]}")
+                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(', ')}"
+              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/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 => INTERVAL '#{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.
@@ -165,6 +186,14 @@ module Timescaledb
       value = options[option_key] ? 'true' : 'false'
       ",timescaledb.#{option_key}=#{value}"
     end
+
+    def parse_interval(interval)
+      if interval.is_a?(Numeric)
+        interval
+      else
+        "INTERVAL '#{interval}'"
+      end
+    end
   end
 end
 

data/lib/timescaledb/schema_dumper.rb

@@ -78,7 +78,7 @@ module Timescaledb
 
       options = {
         time_column: time.column_name,
-        chunk_time_interval: time.time_interval.inspect,
+        chunk_time_interval: time.time_interval ? time.time_interval.inspect : time.integer_interval,
         **timescale_compression_settings_for(hypertable),
         **timescale_space_partition_for(hypertable),
         **timescale_index_options_for(hypertable)
@@ -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}"
@@ -154,19 +152,19 @@ module Timescaledb
     def timescale_continuous_aggregates(stream)
       return unless Timescaledb::ContinuousAggregates.table_exists?
 
-      Timescaledb::ContinuousAggregates.all.find_each do |aggregate|
+      Timescaledb::ContinuousAggregates.hierarchical.each do |aggregate|
         refresh_policies_opts = if (refresh_policy = aggregate.jobs.refresh_continuous_aggregate.first)
           interval = timescale_interval(refresh_policy.schedule_interval)
           end_offset = timescale_interval(refresh_policy.config["end_offset"])
           start_offset = timescale_interval(refresh_policy.config["start_offset"])
-          %(refresh_policies: { start_offset: "#{start_offset}", end_offset: "#{end_offset}", schedule_interval: "#{interval}"})
+          %(refresh_policies: { start_offset: "#{start_offset}", end_offset: "#{end_offset}", schedule_interval: "#{interval}"}, )
         else
           ""
         end
 
         with_clause_opts = "materialized_only: #{aggregate[:materialized_only]}, finalized: #{aggregate[:finalized]}"
         stream.puts <<~AGG.indent(2)
-          create_continuous_aggregate("#{aggregate.view_name}", <<-SQL, #{refresh_policies_opts}, #{with_clause_opts})
+          create_continuous_aggregate("#{aggregate.view_name}", <<-SQL, #{refresh_policies_opts}#{with_clause_opts})
             #{aggregate.view_definition.strip.gsub(/;$/, '')}
           SQL
         AGG

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.2.9'
+  VERSION = '0.3.1'
 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.2.9
+  version: 0.3.1
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-05 00:00:00.000000000 Z
+date: 2024-12-20 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,13 @@ 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/database.rb
 - lib/timescaledb/database/chunk_statements.rb
 - lib/timescaledb/database/hypertable_statements.rb
@@ -181,12 +195,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 +217,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