timescaledb 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7553bac6eee450d1067b66043ef721e77eac03c58dc0fbbfafb42fe1c4330600
-  data.tar.gz: d67f848537997b9558af4f174fe2289517f2f6e593b03aafc3ef47097bfac496
+  metadata.gz: 128f81d085e998eb85b11ae08b9647880e5da2033fe8c845716fb5cb0a231cb8
+  data.tar.gz: 95c934194cad90f67d4f058491b011935f1da4bf62d40c82bbc85fb293a3189c
 SHA512:
-  metadata.gz: 16792f5b215cdd992ecb006bce4492b939fdefa11dae3e32c2eb3d28645c5386a471b307aae321f1b114ce968fd9550648a4727d288fa9858a59c7a935678c7a
-  data.tar.gz: dfb95e8090ce29044889efac22385b2b390825f64f1da7a33a205a1549b89a7b039f076990e9721df1a68dc56d11c30846f391fe0d051ea0837d6bffe8a9eb48
+  metadata.gz: 589909dd6e1baa40199c0147d8b6e65a4848090d9c7ec9575be64ca841e8e690554ada570136a8b32e60c93f0b155c0cf1a9ba80c601c3923146690e102382ce
+  data.tar.gz: ca63b74219756fa81ca586ad78b55e597a86f96a354b53a5c20e531925e02bb12aad7ebff000a90082040158e1ddfa6974c97e927c40c2ec65c46c2375656c67

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timescaledb (0.1.5)
+    timescaledb (0.2.0)
       activerecord
       activesupport
       pg (~> 1.2)
@@ -33,7 +33,7 @@ GEM
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
     minitest (5.14.4)
-    pg (1.2.3)
+    pg (1.3.1)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)

data/Gemfile.scenic.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timescaledb (0.1.4)
+    timescaledb (0.1.5)
       activerecord
       activesupport
       pg (~> 1.2)
@@ -58,7 +58,7 @@ GEM
       racc (~> 1.4)
     nokogiri (1.12.5-x86_64-darwin)
       racc (~> 1.4)
-    pg (1.2.3)
+    pg (1.3.0)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)

data/README.md

@@ -1,6 +1,6 @@
-# Timescale
+# TimescaleDB
 
-Welcome to the Timescale gem! To experiment with the code, start installing the
+Welcome to the TimescaleDB gem! To experiment with the code, start installing the
 gem:
 
 ```bash
@@ -29,7 +29,7 @@ tsdb postgres://<user>@localhost:5432/<dbname> --stats
 Or just check the stats:
 
 ```bash
-tsdb "postgres://jonatasdp@localhost:5432/timescale_test" --stats
+tsdb "postgres://jonatasdp@localhost:5432/timescaledb_test" --stats
 ```
 
 These is a sample output from database example with almost no data:
@@ -89,7 +89,7 @@ continuous aggregates views.
 
 ```ruby
 Tick
-=> Timescale::Tick(time: datetime, symbol: string, price: decimal, volume: integer)
+=> Timescaledb::Tick(time: datetime, symbol: string, price: decimal, volume: integer)
 ```
 
 Note that it's only created for this session and will never be cached in the
@@ -102,7 +102,7 @@ Let's start with the `.hypertable` method.
 
 ```ruby
 Tick.hypertable
-=> #<Timescale::Hypertable:0x00007fe99c258900
+=> #<Timescaledb::Hypertable:0x00007fe99c258900
  hypertable_schema: "public",
  hypertable_name: "ticks",
  owner: "jonatasdp",
@@ -122,7 +122,7 @@ from the hypertable relation.
 ```ruby
 Tick.hypertable.chunks
 unknown OID 2206: failed to recognize type of 'primary_dimension_type'. It will be treated as String.
-=> [#<Timescale::Chunk:0x00007fe99c31b068
+=> [#<Timescaledb::Chunk:0x00007fe99c31b068
   hypertable_schema: "public",
   hypertable_name: "ticks",
   chunk_schema: "_timescaledb_internal",
@@ -175,14 +175,14 @@ The `ohlc_1m` view is also available as an ActiveRecord:
 
 ```ruby
 Ohlc1m
-=> Timescale::Ohlc1m(bucket: datetime, symbol: string, open: decimal, high: decimal, low: decimal, close: decimal, volume: integer)
+=> Timescaledb::Ohlc1m(bucket: datetime, symbol: string, open: decimal, high: decimal, low: decimal, close: decimal, volume: integer)
 ```
 
 And you can run any query as you do with regular active record queries.
 
 ```ruby
 Ohlc1m.order(bucket: :desc).last
-=> #<Timescale::Ohlc1m:0x00007fe99c2c38e0
+=> #<Timescaledb::Ohlc1m:0x00007fe99c2c38e0
  bucket: 2000-01-01 00:00:00 UTC,
  symbol: "SYMBOL",
  open: 0.13e2,
@@ -211,7 +211,9 @@ Or install it yourself as:
 
 ## Usage
 
-You can check the [all_in_one.rb](examples/all_in_one.rb) example that will:
+Check the [examples/ranking](examples/ranking) to get a Rails complete example.
+
+You can check the [all_in_one.rb](examples/all_in_one/all_in_one.rb) example that will:
 
 1. Create hypertable with compression settings
 2. Insert data
@@ -221,6 +223,11 @@ You can check the [all_in_one.rb](examples/all_in_one.rb) example that will:
 6. Check chunk status
 7. Decompress a chunk
 
+### Testing
+
+If you need some inspiration for how are you going to test your hypertables,
+please check the [spec/spec_helper.rb](spec/spec_helper.rb) for inspiration.
+
 ### Migrations
 
 Create table is now with the `hypertable` keyword allowing to pass a few options
@@ -297,7 +304,7 @@ manage database view definitions for a Rails application. TimescaleDB's
 continuous aggregates are more complex than regular PostgreSQL views, and
 the schema dumper included with Scenic can't dump a complete definition.
 
-This gem automatically configures Scenic to use a `Timescale::Scenic::Adapter`
+This gem automatically configures Scenic to use a `Timescaledb::Scenic::Adapter`
 which will correctly handle schema dumping.
 
 ### Enable ActsAsHypertable
@@ -328,7 +335,7 @@ end
 To get all the chunks from a model's hypertable, you can use `.chunks`.
 
 ```ruby
-Event.chunks # => [#<Timescale::Chunk>, ...]
+Event.chunks # => [#<Timescaledb::Chunk>, ...]
 ```
 
 ### Hypertable metadata
@@ -336,20 +343,20 @@ Event.chunks # => [#<Timescale::Chunk>, ...]
 To get the models' hypertable metadata, you can use `.hypertable`.
 
 ```ruby
-Event.hypertable # => #<Timescale::Hypertable>
+Event.hypertable # => #<Timescaledb::Hypertable>
 ```
 
-To get hypertable metadata for all hypertables: `Timescale.hypertables`.
+To get hypertable metadata for all hypertables: `Timescaledb.hypertables`.
 
 ### Compression Settings
 
 Compression settings are accessible through the hypertable.
 
 ```ruby
-Event.hypertable.compression_settings # => [#<Timescale::CompressionSettings>, ...]
+Event.hypertable.compression_settings # => [#<Timescaledb::CompressionSettings>, ...]
 ```
 
-To get compression settings for all hypertables: `Timescale.compression_settings`.
+To get compression settings for all hypertables: `Timescaledb.compression_settings`.
 
 ### Scopes
 
@@ -415,7 +422,7 @@ You can put some postgres URI directly as a parameter of
 `tsdb`. Here is an example from the console:
 
 ```bash
-tsdb "postgres://jonatasdp@localhost:5432/timescale_test"
+tsdb "postgres://jonatasdp@localhost:5432/timescaledb_test"
 ```
 
 ## More resources

data/bin/console

@@ -11,7 +11,7 @@ end
 
 ActiveRecord::Base.establish_connection(ARGV[0] || uri_from_test)
 
-Timescale::Hypertable.find_each do |hypertable|
+Timescaledb::Hypertable.find_each do |hypertable|
   class_name = hypertable.hypertable_name.singularize.camelize
 
   model = Class.new(ActiveRecord::Base) do
@@ -21,7 +21,7 @@ Timescale::Hypertable.find_each do |hypertable|
     acts_as_hypertable
   end
 
-  Timescale.const_set(class_name, model)
+  Timescaledb.const_set(class_name, model)
 end
 
 require "pry"

data/bin/tsdb

@@ -5,22 +5,22 @@ require "pry"
 
 ActiveRecord::Base.establish_connection(ARGV[0])
 
-Timescale::Hypertable.find_each do |hypertable|
+Timescaledb::Hypertable.find_each do |hypertable|
   class_name = hypertable.hypertable_name.singularize.camelize
   model = Class.new(ActiveRecord::Base) do
     self.table_name = hypertable.hypertable_name
     acts_as_hypertable
   end
-  Timescale.const_set(class_name, model)
+  Timescaledb.const_set(class_name, model)
 end
 
-Timescale::ContinuousAggregates.find_each do |cagg|
+Timescaledb::ContinuousAggregates.find_each do |cagg|
   class_name = cagg.view_name.singularize.camelize
   model = Class.new(ActiveRecord::Base) do
     self.table_name = cagg.view_name
     acts_as_hypertable
   end
-  Timescale.const_set(class_name, model)
+  Timescaledb.const_set(class_name, model)
 end
 
 def show(obj)
@@ -28,7 +28,7 @@ def show(obj)
 end
 
 if ARGV.index("--stats")
-  scope = Timescale::Hypertable.all
+  scope = Timescaledb::Hypertable.all
 
   if (only = ARGV.index("--only"))
     only_hypertables = ARGV[only+1].split(",")
@@ -40,7 +40,7 @@ if ARGV.index("--stats")
     scope = scope.where.not(hypertable_name: except_hypertables)
   end
 
-  show(Timescale.stats(scope))
+  show(Timescaledb.stats(scope))
 end
 
 if ARGV.index("--console")

data/examples/ranking/.gitattributes

@@ -0,0 +1,7 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored

data/examples/ranking/.gitignore

@@ -0,0 +1,29 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+
+# Ignore uploaded files in development.
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+
+# Ignore master key for decrypting credentials and more.
+/config/master.key

data/examples/ranking/.ruby-version

@@ -0,0 +1 @@
+2.7.1

data/examples/ranking/Gemfile

@@ -0,0 +1,33 @@
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby "2.7.1"
+
+# Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
+gem "rails", "~> 7.0.2"
+
+gem "timescaledb", path: "../../"
+gem "pg", "~> 1.1"
+gem "puma", "~> 5.0"
+gem "tzinfo-data", platforms: %i[ mingw mswin x64_mingw jruby ]
+
+# Reduces boot times through caching; required in config/boot.rb
+gem "bootsnap", require: false
+
+# Use Active Storage variants [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
+# gem "image_processing", "~> 1.2"
+
+# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
+# gem "rack-cors"
+
+group :development, :test do
+  gem "pry-rails"
+end
+
+group :development do
+  # Speed up commands on slow machines / big apps [https://github.com/rails/spring]
+  # gem "spring"
+end
+
+
+gem "scenic", "~> 1.5"

data/examples/ranking/Gemfile.lock

@@ -0,0 +1,189 @@
+PATH
+  remote: ../..
+  specs:
+    timescaledb (0.1.5)
+      activerecord
+      activesupport
+      pg (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.2)
+      actionpack (= 7.0.2)
+      activesupport (= 7.0.2)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.2)
+      actionpack (= 7.0.2)
+      activejob (= 7.0.2)
+      activerecord (= 7.0.2)
+      activestorage (= 7.0.2)
+      activesupport (= 7.0.2)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.2)
+      actionpack (= 7.0.2)
+      actionview (= 7.0.2)
+      activejob (= 7.0.2)
+      activesupport (= 7.0.2)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.2)
+      actionview (= 7.0.2)
+      activesupport (= 7.0.2)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.2)
+      actionpack (= 7.0.2)
+      activerecord (= 7.0.2)
+      activestorage (= 7.0.2)
+      activesupport (= 7.0.2)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.2)
+      activesupport (= 7.0.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.2)
+      activesupport (= 7.0.2)
+      globalid (>= 0.3.6)
+    activemodel (7.0.2)
+      activesupport (= 7.0.2)
+    activerecord (7.0.2)
+      activemodel (= 7.0.2)
+      activesupport (= 7.0.2)
+    activestorage (7.0.2)
+      actionpack (= 7.0.2)
+      activejob (= 7.0.2)
+      activerecord (= 7.0.2)
+      activesupport (= 7.0.2)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    bootsnap (1.10.3)
+      msgpack (~> 1.2)
+    builder (3.2.4)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
+    digest (3.1.0)
+    erubi (1.10.0)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.9.1)
+      concurrent-ruby (~> 1.0)
+    io-wait (0.2.1)
+    loofah (2.13.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    mini_portile2 (2.7.1)
+    minitest (5.15.0)
+    msgpack (1.4.4)
+    net-imap (0.2.3)
+      digest
+      net-protocol
+      strscan
+    net-pop (0.1.1)
+      digest
+      net-protocol
+      timeout
+    net-protocol (0.1.2)
+      io-wait
+      timeout
+    net-smtp (0.3.1)
+      digest
+      net-protocol
+      timeout
+    nio4r (2.5.8)
+    nokogiri (1.13.1)
+      mini_portile2 (~> 2.7.0)
+      racc (~> 1.4)
+    pg (1.3.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-rails (0.3.9)
+      pry (>= 0.10.4)
+    puma (5.6.1)
+      nio4r (~> 2.0)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (7.0.2)
+      actioncable (= 7.0.2)
+      actionmailbox (= 7.0.2)
+      actionmailer (= 7.0.2)
+      actionpack (= 7.0.2)
+      actiontext (= 7.0.2)
+      actionview (= 7.0.2)
+      activejob (= 7.0.2)
+      activemodel (= 7.0.2)
+      activerecord (= 7.0.2)
+      activestorage (= 7.0.2)
+      activesupport (= 7.0.2)
+      bundler (>= 1.15.0)
+      railties (= 7.0.2)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (7.0.2)
+      actionpack (= 7.0.2)
+      activesupport (= 7.0.2)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rake (13.0.6)
+    scenic (1.5.5)
+      activerecord (>= 4.0.0)
+      railties (>= 4.0.0)
+    strscan (3.0.1)
+    thor (1.2.1)
+    timeout (0.2.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.5.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bootsnap
+  pg (~> 1.1)
+  pry-rails
+  puma (~> 5.0)
+  rails (~> 7.0.2)
+  scenic (~> 1.5)
+  timescaledb!
+  tzinfo-data
+
+RUBY VERSION
+   ruby 2.7.1p83
+
+BUNDLED WITH
+   2.1.4

data/examples/ranking/README.md

@@ -0,0 +1,166 @@
+# README
+
+This example application is a "Scoring" service that stores "games" and "plays" of the games in question.
+
+There are two tables:
+
+* `games` that holds a name and description
+* `plays` is a [hypertable][hypertable] that references a `game`, storing `score` and `total_time`.
+
+Interesting things to observe here:
+
+* The gem is required on [config/initializers/timescale.rb](./config/initializers/timescale.rb).
+* The [hypertable creation](db/migrate/20220209120910_create_plays.rb) is also with the `enable_extension` command time.
+* See how the [play model](app/models/play.rb) uses [acts_as_hypertable](../../lib/timescale/acts_as_hypertable.rb).
+
+## Walkthrough
+
+Use `bin/console` to preload the environment and follow the next steps.
+
+Let's start by creating a game and a single play.
+
+```ruby
+lol = Game.create(name: "LoL", description: "League of Legends")
+Play.create(game: lol,
+  score: (rand * 100).to_i,
+  total_time: (rand * 1000).to_i)
+```
+You can also insert a few hundreds/thousands/millions of records to test it properly.
+
+```ruby
+100.times do
+   Play.create(game: lol,
+   score: (rand * 100).to_i,
+   total_time: (rand * 1000).to_i)
+end
+```
+
+You can play with multiple games and millions of play records to make it an impressive playground if you want :wink:
+
+
+Then you can experiment with the [time_bucket][time_bucket] funciton.
+
+```ruby
+Play.group("time_bucket('1 min',created_at)").count
+# => {2022-02-09 12:34:00 UTC=>1, 2022-02-09 12:39:00 UTC=>10100}
+```
+
+> Hypertables in TimescaleDB are designed to be easy to manage and to behave predictably to users familiar with standard PostgreSQL tables. Along those lines, SQL commands to create, alter, or delete hypertables in TimescaleDB are identical to those in PostgreSQL. Even though hypertables are comprised of many interlinked chunks, commands made to the hypertable automatically propagate changes down to all of the chunks belonging to that hypertable.
+
+When the model contains the `acts_as_hypertable` macro, it's possible to navigate into the hypertable internals:
+
+```ruby
+ Play.hypertable
+ # => #<Timescaledb::Hypertable:0x00007faa97df7e30
+ # hypertable_schema: "public",
+ # hypertable_name: "plays",
+ # owner: "jonatasdp",
+ # num_dimensions: 1,
+ # num_chunks: 2,
+ # compression_enabled: true,
+ # is_distributed: false,
+ # replication_factor: nil,
+ # data_nodes: nil,
+ # tablespaces: nil>
+```
+
+Each hypertable has many chunks. Chunks are the subtables spread accross the time. You can check chunks metadata from the `hypertable` relation here:
+
+```ruby
+Play.hypertable.chunks.pluck(:chunk_name)
+# => ["_hyper_1_1_chunk", "_hyper_1_2_chunk"]
+```
+
+Chunks can also be compressed/decompressed and you can check the state using scopes:
+
+```ruby
+Play.hypertable.chunks.compressed.count # => 2
+```
+
+Get a resume from chunks status:
+
+```ruby
+Play.hypertable.chunks.resume
+# => {:total=>2, :compressed=>0, :uncompressed=>2}
+```
+
+To get a full stats from all hypertables, you can see `Timescaledb.stats`:
+
+```ruby
+Timescaledb.stats
+ # => {:hypertables=>
+ #  {:count=>1,
+ #   :uncompressed=>0,
+ #   :approximate_row_count=>{"plays"=>10100},
+ #   :chunks=>{:total=>2, :compressed=>0, :uncompressed=>2},
+ #   :size=>{:uncompressed=>"1.3 MB", :compressed=>"0 Bytes"}},
+ # :continuous_aggregates=>{:total=>0},
+ # :jobs_stats=>[{:success=>100, :runs=>100, :failures=>0}]}
+```
+Note that we haven't  used compression yet. So, we can force compression directly from the `chunk` relation:
+
+```ruby
+Play.hypertable.chunks.each(&:compress!)
+```
+
+Calling `stats` to check the compressed size:
+
+```ruby
+Timescaledb.stats
+ #  {:count=>1,  ...
+ #   :size=>
+ #    {:uncompressed=>"1.2 MB",
+ #     :compressed=>"180 KB"}},
+ # :continuous_aggregates=>{:total=>0},
+ # :jobs_stats=>
+ #  [{:success=>107,
+ #    :runs=>107,
+ #    :failures=>0}]}
+```
+
+> :warning: Note that the chunks are not very effective compressing here because of the example is incomplete and with a little amount of records.
+
+You can decompress as the system will make the compression in the background as it already have a policy.
+
+```ruby
+Play.hypertable.chunks.each(&:decompress!)
+```
+
+## Dump schema
+
+The lib also contains a [schema_dumper](../../lib/timescale/schema_dumper.rb) that allows you to dump the schema and reload with the same hypertable options.
+
+```bash
+rails db:schema:dump
+```
+
+Confirm that the hypertable is on [db/schema.rb](db/schema.rb) file:
+
+```
+ grep hypertable db/schema.rb
+  create_hypertable "plays", time_column: "created_at", chunk_time_interval: "1
+  minute", compress_segmentby: "game_id", compress_orderby: "created_at ASC",
+  compression_interval: "P7D"
+```
+
+And you can also reload the configuration manually in the test environment:
+
+```bash
+RAILS_ENV=test rails db:schema:load
+```
+
+## Scenic views
+
+If you use [scenic](https://github.com/scenic-views/scenic) views, it will
+automatically recognize and dump the views.
+
+Check the [view migration](db/migrate/20220209143347_create_score_per_hours.rb)
+and the correspondent view defined in the [sql file](db/views/score_per_hours_v01.sql).
+
+> Note that scenic is not fully compatible with timescaledb continous aggregates
+> and we created a [helper](../../lib/timescale/scenic/extension.rb) to make it
+> easy to use along with scenic.
+
+[hypertable]: https://docs.timescale.com/timescaledb/latest/how-to-guides/hypertables/
+[time_bucket]: https://docs.timescale.com/api/latest/hyperfunctions/time_bucket/
+

data/examples/ranking/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks