timescaledb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2088f631818f19cc92ea997dea0fe5a929263c5100abb3e4c640a52de0a1c94
-  data.tar.gz: 111d3b028355623ff1b4954491c3e4a9d92dd3d491c243fd7a9d6615596ac822
+  metadata.gz: 69db00d0dc568db01a5bd739183cd5615dbdc66267ad1441502d5c3774753dcb
+  data.tar.gz: be2271adcbc9e9b81302d9597824d18462ff64530c095c9e4a3239db1ccbaa51
 SHA512:
-  metadata.gz: c2461c306c4812a37b740ff5d0be84bb971aba512d5e7ba523f5b36a16811b3d85708a82646b5f2f4659cf82a0310723fe3fb84579aa2d8bca809942a759b125
-  data.tar.gz: 78629e727c3125ec055d17806c476c2ca7908a35386e89b52b67de3f8c07a26460d783df69425b7ac6c869c2f70e77986d672460f1c3a8b554f2b55f9aa64443
+  metadata.gz: cc6a3bf67e7c73096d6a9a739d1a52ca0f4c560c80e1a7febf90a8e99d3f1009bd282ad16dfeb235b03c6613e27d7d35938a51a10314a1ffb83209b81686e748
+  data.tar.gz: effbd8f2686a312671c9275945a8705ec64453687699935872e7cb5e3445e1edcd982ee86b625dc69ba673166b13c9839d11a5756e95212b3dab4cca59055eeb

data/Gemfile

@@ -2,9 +2,3 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in timescale.gemspec
 gemspec
-
-gem 'dotenv'
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"
-gem 'rspec-its'
-gem 'pry'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timescale (0.1.0)
+    timescaledb (0.1.1)
       activerecord
       pg (~> 1.2)
 
@@ -61,7 +61,7 @@ DEPENDENCIES
   rake (~> 12.0)
   rspec (~> 3.0)
   rspec-its
-  timescale!
+  timescaledb!
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -7,12 +7,13 @@ repository:
 git clone https://github.com/jonatas/timescale.git
 cd timescale
 bundle install
+rake install
 ```
 
-Then you can run `bin/console` for an interactive prompt.
+Then, with `rake install` or installing the gem in your computer, you can run `tsdb` for an interactive prompt.
 
 ```bash
-bin/console
+tsdb postgres://<user>@localhost:5432/<dbname> --stats --flags
 ```
 
 You can create a `.env` file locally to run tests locally. Make sure to put your
@@ -22,14 +23,35 @@ own credentials there!
 PG_URI_TEST="postgres://<user>@localhost:5432/<dbname>"
 ```
 
-You can also use `bin/console` without any parameters and it will use the
-`PG_URI_TEST` from your `.env` file.
+You can put some postgres URI directly as a parameter of
+`tsdb`. Here is an example from the console:
 
-Alternatively, you can also put some postgres URI directly as a parameter of
-`bin/console`. Here is an example from my console:
+```bash
+tsdb "postgres://jonatasdp@localhost:5432/timescale_test"
+```
+
+To join the console use `--console`:
 
 ```bash
-bin/console "postgres://jonatasdp@localhost:5432/timescale_test"
+tsdb "postgres://jonatasdp@localhost:5432/timescale_test" --console
+```
+
+Or just check the stats:
+
+```bash
+tsdb "postgres://jonatasdp@localhost:5432/timescale_test" --stats
+```
+
+These is a sample output from an almost empty database:
+
+```ruby
+{:hypertables=>
+  {:count=>3,
+   :uncompressed=>2,
+   :chunks=>{:total=>1, :compressed=>0, :uncompressed=>1},
+   :size=>{:before_compressing=>"80 KB", :after_compressing=>"0 Bytes"}},
+ :continuous_aggregates=>{:count=>1},
+ :jobs_stats=>[{:success=>nil, :runs=>nil, :failures=>nil}]}
 ```
 
 The console will dynamically create models for all hypertables that it finds
@@ -265,7 +287,7 @@ create the hypertable adding this hook to your `spec/rspec_helper.rb` file:
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+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.
 
 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/bin/console

@@ -13,11 +13,14 @@ ActiveRecord::Base.establish_connection(ARGV[0] || uri_from_test)
 
 Timescale::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.primary_key = self.column_names.first
-    include Timescale::HypertableHelpers
+
+    acts_as_hypertable
   end
+
   Timescale.const_set(class_name, model)
 end
 

data/bin/tsdb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "timescale"
+
+ActiveRecord::Base.establish_connection(ARGV[0])
+
+Timescale::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.primary_key = self.column_names.first
+    include Timescale::HypertableHelpers
+  end
+  Timescale.const_set(class_name, model)
+end
+
+if ARGV.index("--stats")
+  pp Timescale.show_stats
+end
+
+if ARGV.index("--console")
+  require "pry"
+  Pry.start(Timescale)
+end

data/lib/timescale/acts_as_hypertable.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Timescale
+  # If you want your model to hook into its underlying hypertable
+  # as well as have access to TimescaleDB specific data, methods, and more,
+  # specify this macro in your model.
+  #
+  # @note Your model's table needs to have already been converted to a hypertable
+  # via the TimescaleDB `create_hypertable` function for this to work.
+  #
+  # @see https://docs.timescale.com/api/latest/hypertable/create_hypertable/ for
+  #   how to use the SQL `create_hypertable` function.
+  # @see Timescale::MigrationHelpers#create_table for how to create a new hypertable
+  # via a Rails migration utilizing the standard `create_table` method.
+  #
+  # @example Enabling the macro on your model
+  #   class Event < ActiveRecord::Base
+  #     acts_as_hypertable
+  #   end
+  #
+  # @see Timescale::ActsAsHypertable::ClassMethods#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
+    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
+    end
+  end
+end

data/lib/timescale/hypertable.rb

@@ -15,12 +15,28 @@ module Timescale
       foreign_key: "hypertable_name",
       class_name: "Timescale::ContinuousAggregates"
 
-    def detailed_size
+    def chunks_detailed_size
       struct_from "SELECT * from chunks_detailed_size('#{self.hypertable_name}')"
     end
 
+    def approximate_row_count
+      struct_from("SELECT * FROM approximate_row_count('#{self.hypertable_name}')").first.approximate_row_count
+    end
+
     def compression_stats
-      struct_from "SELECT * from hypertable_compression_stats('#{self.hypertable_name}')"
+      struct_from("SELECT * from hypertable_compression_stats('#{self.hypertable_name}')").first || {}
+    end
+
+    def detailed_size
+      struct_from("SELECT * FROM hypertable_detailed_size('#{self.hypertable_name}')").first
+    end
+
+    def before_total_bytes
+      compression_stats["before_compression_total_bytes"] || detailed_size.total_bytes
+    end
+
+    def after_total_bytes
+      compression_stats["after_compression_total_bytes"] || 0
     end
 
     private

data/lib/timescale/job_stats.rb

@@ -8,5 +8,11 @@ module Timescale
 
     scope :success, -> { where(last_run_status: "Success") }
     scope :scheduled, -> { where(job_status: "Scheduled") }
+    scope :resume, -> do
+      select("sum(total_successes)::int as success,
+             sum(total_runs)::int as runs,
+             sum(total_failures)::int as failures")
+        .to_a.map{|e|e.attributes.transform_keys(&:to_sym) }
+    end
   end
 end

data/lib/timescale/stats_report.rb

@@ -0,0 +1,28 @@
+require "active_support/core_ext/numeric/conversions"
+module Timescale
+  module StatsReport
+    module_function
+    def resume
+      {
+        hypertables: {
+          count: Hypertable.count,
+          uncompressed: Hypertable.all.to_a.count { |h| h.compression_stats.empty? },
+          approximate_row_count: Hypertable.all.to_a.map do |hypertable|
+              { hypertable.hypertable_name => hypertable.approximate_row_count }
+            end.inject(&:merge!),
+          chunks: {
+            total: Chunk.count,
+            compressed: Chunk.compressed.count,
+            uncompressed: Chunk.uncompressed.count
+          },
+          size: {
+            before_compressing: Hypertable.all.map{|h|h.before_total_bytes}.inject(:+).to_s(:human_size),
+            after_compressing: Hypertable.all.map{|h|h.after_total_bytes}.inject(:+).to_s(:human_size)
+          }
+        },
+        continuous_aggregates: { count: ContinuousAggregates.count },
+        jobs_stats: JobStats.resume
+      }
+    end
+  end
+end

data/lib/timescale/version.rb

@@ -1,3 +1,3 @@
 module Timescale
-  VERSION = "0.1.0"
+  VERSION = '0.1.2'
 end

data/lib/timescale.rb

@@ -1,16 +1,19 @@
-require "timescale/version"
 require 'active_record'
+
+require_relative 'timescale/acts_as_hypertable'
 require_relative 'timescale/chunk'
+require_relative 'timescale/compression_settings'
+require_relative 'timescale/continuous_aggregates'
 require_relative 'timescale/hypertable'
 require_relative 'timescale/job'
 require_relative 'timescale/job_stats'
-require_relative 'timescale/continuous_aggregates'
-require_relative 'timescale/compression_settings'
-require_relative 'timescale/hypertable_helpers'
+require_relative 'timescale/stats_report'
 require_relative 'timescale/migration_helpers'
+require_relative 'timescale/version'
 
 module Timescale
   module_function
+
   def chunks
     Chunk.all
   end
@@ -34,4 +37,16 @@ module Timescale
   def job_stats
     JobStats.all
   end
+
+  def show_stats
+    StatsReport.resume
+  end
+
+  def default_hypertable_options
+    Timescale::ActsAsHypertable::DEFAULT_OPTIONS
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  include Timescale::ActsAsHypertable
 end

data/timescale.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jônatas Davi Paganini"]
   spec.email         = ["jonatasdp@gmail.com"]
 
-  spec.summary       = %q{TimesaleDB helpers for Ruby ecosystem.}
+  spec.summary       = %q{TimescaleDB helpers for Ruby ecosystem.}
   spec.description   = %q{Functions from timescaledb available in the ActiveRecord models.}
   spec.homepage      = "https://github.com/jonatas/timescale"
   spec.license       = "MIT"
@@ -23,10 +23,16 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/tsdb}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency  "pg", "~> 1.2"
-  spec.add_dependency 'activerecord'
+  spec.add_dependency "activerecord"
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "dotenv"
+  spec.add_development_dependency "rake", "~> 12.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-09-24 00:00:00.000000000 Z
+date: 2021-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -38,10 +38,81 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
 description: Functions from timescaledb available in the ActiveRecord models.
 email:
 - jonatasdp@gmail.com
-executables: []
+executables:
+- tsdb
 extensions: []
 extra_rdoc_files: []
 files:
@@ -56,18 +127,20 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/tsdb
 - examples/Gemfile
 - examples/Gemfile.lock
 - examples/all_in_one.rb
 - lib/timescale.rb
+- lib/timescale/acts_as_hypertable.rb
 - lib/timescale/chunk.rb
 - lib/timescale/compression_settings.rb
 - lib/timescale/continuous_aggregates.rb
 - lib/timescale/hypertable.rb
-- lib/timescale/hypertable_helpers.rb
 - lib/timescale/job.rb
 - lib/timescale/job_stats.rb
 - lib/timescale/migration_helpers.rb
+- lib/timescale/stats_report.rb
 - lib/timescale/version.rb
 - timescale.gemspec
 homepage: https://github.com/jonatas/timescale
@@ -94,5 +167,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: TimesaleDB helpers for Ruby ecosystem.
+summary: TimescaleDB helpers for Ruby ecosystem.
 test_files: []

data/lib/timescale/hypertable_helpers.rb

@@ -1,39 +0,0 @@
-require_relative 'chunk'
-require_relative 'hypertable'
-module Timescale
-  module HypertableHelpers
-    extend ActiveSupport::Concern
-
-    included do
-      scope :chunks, -> () do
-        Chunk.where(hypertable_name: self.table_name)
-      end
-
-      scope :hypertable, -> () do
-        Hypertable.find_by(hypertable_name: self.table_name)
-      end
-
-      scope :jobs, -> () do
-        Job.where(hypertable_name: self.table_name)
-      end
-
-      scope :job_stats, -> () do
-        JobStats.where(hypertable_name: self.table_name)
-      end
-
-      scope :compression_settings, -> () do
-        CompressionSettings.where(hypertable_name: self.table_name)
-      end
-
-      scope :continuous_aggregates, -> () do
-        ContinuousAggregates.where(hypertable_name: self.table_name)
-      end
-
-      scope :last_month, -> { where('created_at > ?', 1.month.ago) }
-      scope :last_week, -> { where('created_at > ?', 1.week.ago) }
-      scope :last_hour, -> { where('created_at > ?', 1.hour.ago) }
-      scope :yesterday, -> { where('DATE(created_at) = ?', 1.day.ago.to_date) }
-      scope :today, -> { where('DATE(created_at) = ?', Date.today) }
-    end
-  end
-end