timescaledb 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91dfb6aac43ec8ab347ac9cf1bc553631310259cd4f6726c42f466c08f74c761
-  data.tar.gz: 4436ff5f2067264fc814592efebaa9ce32d69ece7607e7d728a95356db04f739
+  metadata.gz: c64be262fa0fbecf13ec6b6b8820b471c9d83e6842306efc59b950a693d4755b
+  data.tar.gz: d702011692906410bd38107d16f9f20801977deb8f4a0cc3372dc5f61aed29ae
 SHA512:
-  metadata.gz: 71492adbe4cd1771db48b2b796affa50d3f3157b420f59482e61d4a76dfc8fcec52f5face66047fc8069f5bcdd35bace4c8ff4e0fec88ffe1331872b3d625862
-  data.tar.gz: 4ecf26d66361af9d79cf33f99b9a25b8233df229a0ffa6ac33afe54d4f4c4d03e6c13609c60cceabc95dc30d8e49f7343588174fb0715bda044942360ebed53b
+  metadata.gz: bc45bab9ddc1e32c1630bb4258299ee1a74b5b7991eb9281332d7de77161e4ad76cedb0cc2ddb30dbf609b68607a2cf0d7799c11130348bda94974fd46d152c1
+  data.tar.gz: 4b6e7da46622c902fc1960fcba1b4d41b4674a8490eef2025f835b767efd3838573befffaed7fffceb65de5e65c793453d3eacfc681a1846f13ba2b485897ce6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timescaledb (0.1.2)
+    timescaledb (0.1.4)
       activerecord
       pg (~> 1.2)
 
@@ -21,6 +21,10 @@ GEM
       zeitwerk (~> 2.3)
     coderay (1.1.3)
     concurrent-ruby (1.1.9)
+    database_cleaner-active_record (2.0.1)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
     diff-lcs (1.4.4)
     dotenv (2.7.6)
     i18n (1.8.10)
@@ -56,6 +60,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  database_cleaner-active_record
   dotenv
   pry
   rake (~> 12.0)

data/README.md

@@ -290,132 +290,107 @@ options = {
 create_continuous_aggregates('ohlc_1m', query, **options)
 ```
 
-### Hypertable Helpers
+### Enable ActsAsHypertable
 
-You can say `acts_as_hypertable` to get access to some basic scopes for your
+You can declare a Rails model as a Hypertable by invoking the `acts_as_hypertable` macro. This macro extends your existing model with timescaledb-related functionality.
 model:
 
 ```ruby
 class Event < ActiveRecord::Base
-  self.primary_key = "identifier"
-
   acts_as_hypertable
 end
 ```
 
-After including the helpers, several methods from timescaledb will be available in the
-model.
+By default, ActsAsHypertable assumes a record's _time_column_ is called `created_at`.
 
-### Chunks
+### Options
 
-To get chunks from a single hypertable, you can use the `.chunks` directly from
-the model name.
+If you are using a different time_column name, you can specify it as follows when invoking the `acts_as_hypertable` macro:
 
 ```ruby
-Event.chunks
-# DEBUG: Timescale::Chunk Load (9.0ms)  SELECT "timescaledb_information"."chunks".* FROM "timescaledb_information"."chunks" WHERE "timescaledb_information"."chunks"."hypertable_name" = $1  [["hypertable_name", "events"]]
-# => [#<Timescale::Chunk:0x00007f94b0c86008
-#   hypertable_schema: "public",
-#   hypertable_name: "events",
-#   chunk_schema: "_timescaledb_internal",
-#   chunk_name: "_hyper_180_74_chunk",
-#   primary_dimension: "created_at",
-#   primary_dimension_type: "timestamp without time zone",
-#   range_start: 2021-09-22 21:28:00 +0000,
-#   range_end: 2021-09-22 21:29:00 +0000,
-#   range_start_integer: nil,
-#   range_end_integer: nil,
-#   is_compressed: false,
-#   chunk_tablespace: nil,
-#   data_nodes: nil>
+class Event < ActiveRecord::Base
+  acts_as_hypertable time_column: :timestamp
+end
 ```
 
-To get all hypertables you can use `Timescale.hypertables` method.
+### Chunks
+
+To get all the chunks from a model's hypertable, you can use `.chunks`.
 
-### Hypertable metadata from model
+```ruby
+Event.chunks # => [#<Timescale::Chunk>, ...]
+```
 
-To get all details from hypertable, you can access the `.hypertable` from the
-model.
+### Hypertable metadata
+
+To get the models' hypertable metadata, you can use `.hypertable`.
 
 ```ruby
-Event.hypertable
-# Timescale::Hypertable Load (4.8ms)  SELECT "timescaledb_information"."hypertables".* FROM "timescaledb_information"."hypertables" WHERE "timescaledb_information"."hypertables"."hypertable_name" = $1 LIMIT $2  [["hypertable_name", "events"], ["LIMIT", 1]]
-# => #<Timescale::Hypertable:0x00007f94c3151cd8
-#  hypertable_schema: "public",
-#  hypertable_name: "events",
-#  owner: "jonatasdp",
-#  num_dimensions: 1,
-#  num_chunks: 1,
-#  compression_enabled: true,
-#  is_distributed: false,
-#  replication_factor: nil,
-#  data_nodes: nil,
-#  tablespaces: nil>
+Event.hypertable # => #<Timescale::Hypertable>
 ```
 
-You can also use `Timescale.hypertables` to have access of all hypertables
-metadata.
+To get hypertable metadata for all hypertables: `Timescale.hypertables`.
 
 ### Compression Settings
 
 Compression settings are accessible through the hypertable.
 
 ```ruby
-Event.hypertable.compression_settings
-#  Timescale::Hypertable Load (1.2ms)  SELECT "timescaledb_information"."hypertables".* FROM "timescaledb_information"."hypertables" WHERE "timescaledb_information"."hypertables"."hypertable_name" = $1 LIMIT $2  [["hypertable_name", "events"], ["LIMIT", 1]]
-#  Timescale::CompressionSettings Load (1.2ms)  SELECT "timescaledb_information"."compression_settings".* FROM "timescaledb_information"."compression_settings" WHERE "timescaledb_information"."compression_settings"."hypertable_name" = $1  [["hypertable_name", "events"]]
-# => [#<Timescale::CompressionSettings:0x00007f94b0bf7010
-#   hypertable_schema: "public",
-#   hypertable_name: "events",
-#   attname: "identifier",
-#   segmentby_column_index: 1,
-#   orderby_column_index: nil,
-#   orderby_asc: nil,
-#   orderby_nullsfirst: nil>,
-#  #<Timescale::CompressionSettings:0x00007f94b0c3e460
-#   hypertable_schema: "public",
-#   hypertable_name: "events",
-#   attname: "created_at",
-#   segmentby_column_index: nil,
-#   orderby_column_index: 1,
-#   orderby_asc: true,
-#   orderby_nullsfirst: false>]
+Event.hypertable.compression_settings # => [#<Timescale::CompressionSettings>, ...]
 ```
 
-It's also possible to access all data calling `Timescale.compression_settings`.
+To get compression settings for all hypertables: `Timescale.compression_settings`.
 
-### RSpec Hooks
+### Scopes
 
-In case you want to use TimescaleDB on a Rails environment, you may have some
-issues as the schema dump used for tests is not considering hypertables
-metadata.
+When you enable ActsAsHypertable on your model, we include a couple default scopes. They are:
 
-If you add the `acts_as_hypertable`  to your model, you can dynamically
-verify if the `Timescale::ActsAsHypertable` module is included to
-create the hypertable for testing environment.
+| Scope name             | What they return                      |
+|------------------------|---------------------------------------|
+| `Model.previous_month` | Records created in the previous month |
+| `Model.previous_week`  | Records created in the previous week  |
+| `Model.this_month`     | Records created this month            |
+| `Model.this_week`      | Records created this week             |
+| `Model.yesterday`      | Records created yesterday             |
+| `Model.today`          | Records created today                 |
+| `Model.last_hour`      | Records created in the last hour      |
 
-Consider adding this hook to your `spec/rspec_helper.rb` file:
+All time-related scopes respect your application's timezone.
+
+## RSpec Hooks
+
+In case you want to use TimescaleDB on a Rails environment, you may have some
+issues as the schema dump used for tests does not consider hypertables metadata.
+
+As a work around, you can dynamically create the hypertables yourself for
+testing environments using the following hook which you can
+define in `spec/rspec_helper.rb`:
 
 ```ruby
-  config.before(:suite) do
-    hypertable_models = ApplicationRecord
-      .descendants
-      .select{|clazz| clazz.included_modules.include?(Timescale::ActsAsHypertable)
-    hypertable_models.each do |clazz|
-      if clazz.hypertable.exists?
-        ApplicationRecord.logger.info "skip recreating hypertable for '#{clazz.table_name}'."
-        next
-      end
-      ApplicationRecord.connection.execute <<~SQL
-        SELECT create_hypertable('#{clazz.table_name}', 'created_at')
-      SQL
+config.before(:suite) do
+  hypertable_models = ActiveRecord::Base.descendants.select(&:acts_as_hypertable?)
+
+  hypertable_models.each do |klass|
+    table_name = klass.table_name
+    time_column = klass.hypertable_options[:time_column]
+
+    if klass.try(:hypertable).present?
+      ApplicationRecord.logger.info "hypertable already created for '#{table_name}', skipping."
+      next
     end
+
+    ApplicationRecord.connection.execute <<~SQL
+      SELECT create_hypertable('#{table_name}', '#{time_column.to_s}')
+    SQL
   end
+end
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `tsdb` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install the development dependencies. Then, `bundle exec rake test:setup` to setup the test database and tables. Finally, run `bundle exec rspec` to run the tests.
+
+You can also run `tsdb` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/Rakefile

@@ -3,4 +3,13 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec
+
+namespace :test do
+  task :setup do
+    require_relative "spec/spec_helper"
+
+    teardown_tables
+    setup_tables
+  end
+end

data/lib/timescale/acts_as_hypertable/core.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Timescale
+  module ActsAsHypertable
+    module Core
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def time_column
+          @time_column ||= hypertable_options[:time_column] || :created_at
+        end
+
+        protected
+
+        def define_association_scopes
+          scope :chunks, -> do
+            Chunk.where(hypertable_name: table_name)
+          end
+
+          scope :hypertable, -> do
+            Hypertable.find_by(hypertable_name: table_name)
+          end
+
+          scope :jobs, -> do
+            Job.where(hypertable_name: table_name)
+          end
+
+          scope :job_stats, -> do
+            JobStats.where(hypertable_name: table_name)
+          end
+
+          scope :compression_settings, -> do
+            CompressionSettings.where(hypertable_name: table_name)
+          end
+
+          scope :continuous_aggregates, -> do
+            ContinuousAggregates.where(hypertable_name: table_name)
+          end
+        end
+
+        def define_default_scopes
+          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
+            )
+          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
+            )
+          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
+            )
+          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
+            )
+          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} > ?", 1.hour.ago.in_time_zone) }
+        end
+
+        def normalize_hypertable_options
+          hypertable_options[:time_column] = hypertable_options[:time_column].to_sym
+        end
+      end
+    end
+  end
+end

data/lib/timescale/acts_as_hypertable.rb

@@ -18,97 +18,45 @@ module Timescale
   #     acts_as_hypertable
   #   end
   #
-  # @see Timescale::ActsAsHypertable::ClassMethods#acts_as_hypertable
+  # @see Timescale::ActsAsHypertable#acts_as_hypertable
   #   for configuration options
   module ActsAsHypertable
-    extend ActiveSupport::Concern
-
     DEFAULT_OPTIONS = {
       time_column: :created_at
     }.freeze
 
-    module ClassMethods
-      # == Configuration options
-      #
-      # @param [Hash] options The options to initialize your macro with.
-      # @option options [Symbol] :time_column The name of the column in your
-      #   model's table containing time values. The name provided should be
-      #   the same name as the `time_column_name` you passed to the
-      #   TimescaleDB `create_hypertable` function.
-      #
-      # @example Enabling the macro on your model with options
-      #   class Event < ActiveRecord::Base
-      #     acts_as_hypertable time_column: :timestamp
-      #   end
-      #
-      def acts_as_hypertable(options = {})
-        return if already_declared_as_hypertable?
-
-        extend Timescale::ActsAsHypertable::HypertableClassMethods
-
-        class_attribute :hypertable_options, instance_writer: false
-
-        self.hypertable_options = DEFAULT_OPTIONS.dup
-        hypertable_options.merge!(options)
-        normalize_hypertable_options
-
-        define_association_scopes
-        define_default_scopes
-      end
-
-      def define_association_scopes
-        scope :chunks, -> do
-          Chunk.where(hypertable_name: table_name)
-        end
-
-        scope :hypertable, -> do
-          Hypertable.find_by(hypertable_name: table_name)
-        end
-
-        scope :jobs, -> do
-          Job.where(hypertable_name: table_name)
-        end
-
-        scope :job_stats, -> do
-          JobStats.where(hypertable_name: table_name)
-        end
-
-        scope :compression_settings, -> do
-          CompressionSettings.where(hypertable_name: table_name)
-        end
-
-        scope :continuous_aggregates, -> do
-          ContinuousAggregates.where(hypertable_name: table_name)
-        end
-      end
-
-      def define_default_scopes
-        scope :last_month, -> { where("#{time_column} > ?", 1.month.ago) }
-        scope :last_week, -> { where("#{time_column} > ?", 1.week.ago) }
-        scope :last_hour, -> { where("#{time_column} > ?", 1.hour.ago) }
-        scope :yesterday, -> { where("#{time_column} = ?", 1.day.ago.to_date) }
-        scope :today, -> { where("#{time_column} = ?", Date.today) }
-      end
-
-      private
-
-      def already_declared_as_hypertable?
-        singleton_class
-          .included_modules
-          .include?(Timescale::ActsAsHypertable::HypertableClassMethods)
-      end
+    def acts_as_hypertable?
+      included_modules.include?(Timescale::ActsAsHypertable::Core)
     end
 
-    module HypertableClassMethods
-      def time_column
-        @hypertable_time_column ||= hypertable_options[:time_column] || :created_at
-      end
-
-      protected
-
-      def normalize_hypertable_options
-        hypertable_options[:time_column] = hypertable_options[:time_column].to_sym
-      end
+    # == Configuration options
+    #
+    # @param [Hash] options The options to initialize your macro with.
+    # @option options [Symbol] :time_column The name of the column in your
+    #   model's table containing time values. The name provided should be
+    #   the same name as the `time_column_name` you passed to the
+    #   TimescaleDB `create_hypertable` function.
+    #
+    # @example Enabling the macro on your model with options
+    #   class Event < ActiveRecord::Base
+    #     acts_as_hypertable time_column: :timestamp
+    #   end
+    #
+    def acts_as_hypertable(options = {})
+      return if acts_as_hypertable?
+
+      include Timescale::ActsAsHypertable::Core
+
+      class_attribute :hypertable_options, instance_writer: false
+
+      self.hypertable_options = DEFAULT_OPTIONS.dup
+      hypertable_options.merge!(options)
+      normalize_hypertable_options
+
+      define_association_scopes
+      define_default_scopes
     end
   end
 end
+
+ActiveRecord::Base.extend Timescale::ActsAsHypertable

data/lib/timescale/version.rb

@@ -1,3 +1,3 @@
 module Timescale
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/timescale.rb

@@ -1,6 +1,7 @@
 require 'active_record'
 
 require_relative 'timescale/acts_as_hypertable'
+require_relative 'timescale/acts_as_hypertable/core'
 require_relative 'timescale/chunk'
 require_relative 'timescale/compression_settings'
 require_relative 'timescale/continuous_aggregates'
@@ -47,7 +48,3 @@ module Timescale
     Timescale::ActsAsHypertable::DEFAULT_OPTIONS
   end
 end
-
-ActiveSupport.on_load :active_record do
-  include Timescale::ActsAsHypertable
-end

data/timescale.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "dotenv"
   spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "database_cleaner-active_record"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-07 00:00:00.000000000 Z
+date: 2021-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Functions from timescaledb available in the ActiveRecord models.
 email:
 - jonatasdp@gmail.com
@@ -133,6 +147,7 @@ files:
 - examples/all_in_one.rb
 - lib/timescale.rb
 - lib/timescale/acts_as_hypertable.rb
+- lib/timescale/acts_as_hypertable/core.rb
 - lib/timescale/chunk.rb
 - lib/timescale/compression_settings.rb
 - lib/timescale/continuous_aggregates.rb