timescaledb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2088f631818f19cc92ea997dea0fe5a929263c5100abb3e4c640a52de0a1c94
+  data.tar.gz: 111d3b028355623ff1b4954491c3e4a9d92dd3d491c243fd7a9d6615596ac822
+SHA512:
+  metadata.gz: c2461c306c4812a37b740ff5d0be84bb971aba512d5e7ba523f5b36a16811b3d85708a82646b5f2f4659cf82a0310723fe3fb84579aa2d8bca809942a759b125
+  data.tar.gz: 78629e727c3125ec055d17806c476c2ca7908a35386e89b52b67de3f8c07a26460d783df69425b7ac6c869c2f70e77986d672460f1c3a8b554f2b55f9aa64443

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.env

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jonatasdp@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

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

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    timescale (0.1.0)
+      activerecord
+      pg (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    dotenv (2.7.6)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    pg (1.2.3)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-its (1.3.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dotenv
+  pry
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  rspec-its
+  timescale!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Jônatas Davi Paganini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,290 @@
+# Timescale
+
+Welcome to the Timescale gem! To experiment with the code, start cloning the
+repository:
+
+```bash
+git clone https://github.com/jonatas/timescale.git
+cd timescale
+bundle install
+```
+
+Then you can run `bin/console` for an interactive prompt.
+
+```bash
+bin/console
+```
+
+You can create a `.env` file locally to run tests locally. Make sure to put your
+own credentials there!
+
+```bash
+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.
+
+Alternatively, you can also put some postgres URI directly as a parameter of
+`bin/console`. Here is an example from my console:
+
+```bash
+bin/console "postgres://jonatasdp@localhost:5432/timescale_test"
+```
+
+The console will dynamically create models for all hypertables that it finds
+in the database.
+
+It will allow you to visit any database and have all models mapped as ActiveRecord
+with the [HypertableHelpers](lib/timescale/hypertable_helpers.rb).
+
+This library was started on [twitch.tv/timescaledb](https://twitch.tv/timescaledb).
+You can watch all episodes here:
+
+1. [Wrapping Functions to Ruby Helpers](https://www.youtube.com/watch?v=hGPsUxLFAYk).
+2. [Extending ActiveRecord with Timescale Helpers](https://www.youtube.com/watch?v=IEyJIHk1Clk).
+3. [Setup Hypertables for Rails testing environment](https://www.youtube.com/watch?v=wM6hVrZe7xA).
+4. [Packing the code to this repository](https://www.youtube.com/watch?v=CMdGAl_XlL4).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'timescaledb'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install timescaledb
+
+## Usage
+
+You can check the [all_in_one.rb](examples/all_in_one.rb) that will:
+
+1. Create hypertable with compression settings
+2. Insert data
+3. Run some queries from HypertableHelpers
+4. Check chunk size per model
+5. Compress a chunk
+6. Check chunk status
+7. Decompress a chunk
+
+### Migrations
+
+Create table is now with the `hypertable` keyword allowing to pass a few options
+to the function call while also using `create_table` method:
+
+#### create_table with `:hypertable`
+
+```ruby
+hypertable_options = {
+  time_column: 'created_at',
+  chunk_time_interval: '1 min',
+  compress_segmentby: 'identifier',
+  compression_interval: '7 days'
+}
+
+create_table(:events, id: false, hypertable: hypertable_options) do |t|
+  t.string :identifier, null: false
+  t.jsonb :payload
+  t.timestamps
+end
+```
+
+#### create_continuous_aggregates
+
+This example shows a ticks table grouping ticks as OHLCV histograms for every
+minute.
+
+```ruby
+hypertable_options = {
+  time_column: 'created_at',
+  chunk_time_interval: '1 min',
+  compress_segmentby: 'symbol',
+  compress_orderby: 'created_at',
+  compression_interval: '7 days'
+}
+create_table :ticks, hypertable: hypertable_options, id: false do |t|
+  t.string :symbol
+  t.decimal :price
+  t.integer :volume
+  t.timestamps
+end
+Tick = Class.new(ActiveRecord::Base) do
+  self.table_name = 'ticks'
+  self.primary_key = 'symbol'
+  include Timescale::HypertableHelpers
+end
+
+query = Tick.select(<<~QUERY)
+  time_bucket('1m', created_at) as time,
+  symbol,
+  FIRST(price, created_at) as open,
+  MAX(price) as high,
+  MIN(price) as low,
+  LAST(price, created_at) as close,
+  SUM(volume) as volume").group("1,2")
+QUERY
+
+options = {
+  with_data: false,
+  refresh_policies: {
+    start_offset: "INTERVAL '1 month'",
+    end_offset: "INTERVAL '1 minute'",
+    schedule_interval: "INTERVAL '1 minute'"
+  }
+}
+
+create_continuous_aggregates('ohlc_1m', query, **options)
+```
+
+### Hypertable Helpers
+
+You can also use `HypertableHelpers` to get access to some basic scopes for your
+model:
+
+```ruby
+class Event < ActiveRecord::Base
+  self.primary_key = "identifier"
+
+  include Timescale::HypertableHelpers
+end
+```
+
+After including the helpers, several methods from timescaledb will be available in the
+model.
+
+### Chunks
+
+To get chunks from a single hypertable, you can use the `.chunks` directly from
+the model name.
+
+```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>
+```
+
+To get all hypertables you can use `Timescale.hypertables` method.
+
+### Hypertable metadata from model
+
+To get all details from hypertable, you can access the `.hypertable` from the
+model.
+
+```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>
+```
+
+You can also use `Timescale.hypertables` to have access of all hypertables
+metadata.
+
+### 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>]
+```
+
+It's also possible to access all data calling `Timescale.compression_settings`.
+
+### 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 is not considering hypertables
+metadata.
+
+If you add the `Timescale::HypertableHelpers` to your model, you can dynamically
+create the hypertable adding this hook to your `spec/rspec_helper.rb` file:
+
+```ruby
+  config.before(:suite) do
+    hypertable_models = ApplicationRecord
+      .descendants
+      .select{|clazz| clazz.ancestors.include?( Timescale::HypertableHelpers)}
+    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
+    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 `bin/console` 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).
+
+### TODO
+
+Here is a list of functions that would be great to have:
+
+- [ ] Dump and Restore Timescale metadata - Like db/schema.rb but for Timescale configuration.
+- [ ] Add data nodes support
+- [ ] Implement the `timescale` CLI to explore the full API.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jonatas/timescale. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/jonatas/timescale/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Timescale project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jonatas/timescale/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "timescale"
+
+def uri_from_test
+  require 'dotenv'
+  Dotenv.load!
+  ENV['PG_URI_TEST']
+end
+
+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
+  end
+  Timescale.const_set(class_name, model)
+end
+
+require "pry"
+Pry.start(Timescale)

data/bin/setup

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+
+set -vx
+
+bundle install
+
+# For running tests it's going to use PG_URI_TEST env variable.
+# Please make sure  you set it properly to a TEST database!"

data/examples/Gemfile

@@ -0,0 +1,11 @@
+
+source 'https://rubygems.org'
+
+gem "timescale", path: "../"
+gem "pg"
+gem "activerecord"
+gem "composite_primary_keys", "~> 6.0"
+gem 'pry'
+
+
+gem "dotenv", "~> 2.7"

data/examples/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: ..
+  specs:
+    timescale (0.1.0)
+      activerecord
+      pg (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    composite_primary_keys (6.0.5)
+      activerecord (>= 4.0.0)
+    concurrent-ruby (1.1.9)
+    dotenv (2.7.6)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    pg (1.2.3)
+    pry (0.14.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  composite_primary_keys (~> 6.0)
+  dotenv (~> 2.7)
+  pg
+  pry
+  timescale!
+
+BUNDLED WITH
+   2.1.4

data/examples/all_in_one.rb

@@ -0,0 +1,63 @@
+require 'bundler/setup'
+require 'timescale'
+require 'pp'
+require 'pry'
+require 'dotenv'
+Dotenv.load!
+# set PG_URI=postgres://user:pass@host:port/db_name
+ActiveRecord::Base.establish_connection(ENV['PG_URI_TEST'])
+
+# Simple example
+class Event < ActiveRecord::Base
+  self.primary_key = "identifier"
+
+  include Timescale::HypertableHelpers
+end
+
+# Setup Hypertable as in a migration
+ActiveRecord::Base.connection.instance_exec do
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+  drop_table(:events) if Event.table_exists?
+
+  hypertable_options = {
+    time_column: 'created_at',
+    chunk_time_interval: '1 min',
+    compress_segmentby: 'identifier',
+    compression_interval: '7 days'
+  }
+
+  create_table(:events, id: false, hypertable: hypertable_options) do |t|
+    t.string :identifier, null: false
+    t.jsonb :payload
+    t.timestamps
+  end
+end
+
+# Create some data just to see how it works
+1.times do
+  Event.transaction do
+    Event.create identifier: "sign_up", payload: {"name" => "Eon"}
+    Event.create identifier: "login", payload: {"email" => "eon@timescale.com"}
+    Event.create identifier: "click", payload: {"user" => "eon", "path" => "/install/timescaledb"}
+    Event.create identifier: "scroll", payload: {"user" => "eon", "path" => "/install/timescaledb"}
+    Event.create identifier: "logout", payload: {"email" => "eon@timescale.com"}
+  end
+end
+
+# Now let's see what we have in the scopes
+Event.last_hour.group(:identifier).count # => {"login"=>2, "click"=>1, "logout"=>1, "sign_up"=>1, "scroll"=>1}
+
+
+puts "compressing #{ Event.chunks.count }"
+Event.chunks.first.compress!
+
+puts "detailed size"
+pp Event.hypertable.detailed_size
+
+puts "compression stats"
+pp Event.hypertable.compression_stats
+
+puts "decompressing"
+Event.chunks.first.decompress!
+Pry.start

data/lib/timescale/chunk.rb

@@ -0,0 +1,27 @@
+module Timescale
+  class Chunk < ActiveRecord::Base
+    self.table_name = "timescaledb_information.chunks"
+    self.primary_key = "chunk_name"
+
+    belongs_to :hypertable, foreign_key: :hypertable_name
+
+    scope :compressed, -> { where(is_compressed: true) }
+    scope :uncompressed, -> { where(is_compressed: false) }
+
+    def compress!
+      execute("SELECT compress_chunk(#{chunk_relation})")
+    end
+
+    def decompress!
+      execute("SELECT decompress_chunk(#{chunk_relation})")
+    end
+
+    def chunk_relation
+      "('#{chunk_schema}.#{chunk_name}')::regclass"
+    end
+
+    def execute(sql)
+      self.class.connection.execute(sql)
+    end
+  end
+end

data/lib/timescale/compression_settings.rb

@@ -0,0 +1,6 @@
+module Timescale
+  class CompressionSettings < ActiveRecord::Base
+    self.table_name = "timescaledb_information.compression_settings"
+    belongs_to :hypertable, foreign_key: :hypertable_name
+  end
+end

data/lib/timescale/continuous_aggregates.rb

@@ -0,0 +1,9 @@
+module Timescale
+  class ContinuousAggregates < ActiveRecord::Base
+    self.table_name = "timescaledb_information.continuous_aggregates"
+    self.primary_key = 'materialization_hypertable_name'
+
+    has_many :jobs, foreign_key: "hypertable_name",
+      class_name: "Timescale::Job"
+  end
+end

data/lib/timescale/hypertable.rb

@@ -0,0 +1,31 @@
+module Timescale
+  class Hypertable < ActiveRecord::Base
+    self.table_name = "timescaledb_information.hypertables"
+
+    self.primary_key = "hypertable_name"
+
+    has_many :jobs, foreign_key: "hypertable_name"
+    has_many :chunks, foreign_key: "hypertable_name"
+
+    has_many :compression_settings,
+      foreign_key: "hypertable_name",
+      class_name: "Timescale::CompressionSettings"
+
+    has_many :continuous_aggregates,
+      foreign_key: "hypertable_name",
+      class_name: "Timescale::ContinuousAggregates"
+
+    def detailed_size
+      struct_from "SELECT * from chunks_detailed_size('#{self.hypertable_name}')"
+    end
+
+    def compression_stats
+      struct_from "SELECT * from hypertable_compression_stats('#{self.hypertable_name}')"
+    end
+
+    private
+    def struct_from(sql)
+      self.class.connection.execute(sql).map(&OpenStruct.method(:new))
+    end
+  end
+end

data/lib/timescale/hypertable_helpers.rb

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

data/lib/timescale/job.rb

@@ -0,0 +1,13 @@
+module Timescale
+  class Job < ActiveRecord::Base
+    self.table_name = "timescaledb_information.jobs"
+    self.primary_key = "job_id"
+
+    attribute :schedule_interval, :interval
+    attribute :max_runtime, :interval
+    attribute :retry_period, :interval
+
+    scope :compression, -> { where(proc_name: "tsbs_compress_chunks") }
+    scope :scheduled, -> { where(scheduled: true) }
+  end
+end

data/lib/timescale/job_stats.rb

@@ -0,0 +1,12 @@
+module Timescale
+  class JobStats < ActiveRecord::Base
+    self.table_name = "timescaledb_information.job_stats"
+
+    belongs_to :job
+
+    attribute :last_run_duration, :interval
+
+    scope :success, -> { where(last_run_status: "Success") }
+    scope :scheduled, -> { where(job_status: "Scheduled") }
+  end
+end

data/lib/timescale/migration_helpers.rb

@@ -0,0 +1,75 @@
+require 'active_record/connection_adapters/postgresql_adapter'
+
+# Useful methods to run TimescaleDB in you Ruby app.
+module Timescale
+  # Migration helpers can help you to setup hypertables by default.
+  module MigrationHelpers
+    # create_table can receive `hypertable` argument
+    # @example
+    #  options = {
+    #    time_column: 'created_at',
+    #    chunk_time_interval: '1 min',
+    #    compress_segmentby: 'identifier',
+    #    compress_orderby: 'created_at',
+    #    compression_interval: '7 days'
+    #  }
+    #
+    #  create_table(:events, id: false, hypertable: options) do |t|
+    #    t.string :identifier, null: false
+    #    t.jsonb :payload
+    #    t.timestamps
+    #  end
+    def create_table(table_name, id: :primary_key, primary_key: nil, force: nil, **options)
+      super
+      setup_hypertable_options(table_name, **options[:hypertable]) if options.key?(:hypertable)
+    end
+
+    # Setup hypertable from options
+    # @see create_table with the hypertable options.
+    def setup_hypertable_options(table_name,
+                                 time_column: 'created_at',
+                                 chunk_time_interval: '1 week',
+                                 compress_segmentby: nil,
+                                 compress_orderby: 'created_at',
+                                 compression_interval: nil
+                                )
+
+      ActiveRecord::Base.logger = Logger.new(STDOUT)
+      execute "SELECT create_hypertable('#{table_name}', '#{time_column}', chunk_time_interval => INTERVAL '#{chunk_time_interval}')"
+
+      if compress_segmentby
+        execute <<~SQL
+        ALTER TABLE #{table_name} SET (
+          timescaledb.compress,
+          timescaledb.compress_orderby = '#{compress_orderby}',
+          timescaledb.compress_segmentby = '#{compress_segmentby}'
+        )
+        SQL
+      end
+      if compression_interval
+        execute "SELECT add_compression_policy('#{table_name}', INTERVAL '#{compression_interval}')"
+      end
+    end
+
+    def create_continuous_aggregates(name, query, **options)
+      execute <<~SQL
+        CREATE MATERIALIZED VIEW #{name}
+        WITH (timescaledb.continuous) AS
+        #{query.respond_to?(:to_sql) ? query.to_sql : query}
+        WITH #{"NO" unless options[:with_data]} DATA;
+      SQL
+
+      if (policy = options[:refresh_policies])
+        # TODO: assert valid keys
+        execute <<~SQL
+          SELECT add_continuous_aggregate_policy('#{name}',
+            start_offset => #{policy[:start_offset]},
+            end_offset => #{policy[:end_offset]},
+            schedule_interval => #{policy[:schedule_interval]});
+        SQL
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(Timescale::MigrationHelpers)

data/lib/timescale/version.rb

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

data/lib/timescale.rb

@@ -0,0 +1,37 @@
+require "timescale/version"
+require 'active_record'
+require_relative 'timescale/chunk'
+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/migration_helpers'
+
+module Timescale
+  module_function
+  def chunks
+    Chunk.all
+  end
+
+  def hypertables
+    Hypertable.all
+  end
+
+  def continuous_aggregates
+    ContinuousAggregates.all
+  end
+
+  def compression_settings
+    CompressionSettings.all
+  end
+
+  def jobs
+    Job.all
+  end
+
+  def job_stats
+    JobStats.all
+  end
+end

data/timescale.gemspec

@@ -0,0 +1,32 @@
+require_relative 'lib/timescale/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "timescaledb"
+  spec.version       = Timescale::VERSION
+  spec.authors       = ["Jônatas Davi Paganini"]
+  spec.email         = ["jonatasdp@gmail.com"]
+
+  spec.summary       = %q{TimesaleDB 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"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  #spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  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.require_paths = ["lib"]
+
+  spec.add_dependency  "pg", "~> 1.2"
+  spec.add_dependency 'activerecord'
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: timescaledb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jônatas Davi Paganini
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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'
+description: Functions from timescaledb available in the ActiveRecord models.
+email:
+- jonatasdp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/Gemfile
+- examples/Gemfile.lock
+- examples/all_in_one.rb
+- lib/timescale.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/version.rb
+- timescale.gemspec
+homepage: https://github.com/jonatas/timescale
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/jonatas/timescale
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: TimesaleDB helpers for Ruby ecosystem.
+test_files: []