timescaledb 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69db00d0dc568db01a5bd739183cd5615dbdc66267ad1441502d5c3774753dcb
-  data.tar.gz: be2271adcbc9e9b81302d9597824d18462ff64530c095c9e4a3239db1ccbaa51
+  metadata.gz: 91dfb6aac43ec8ab347ac9cf1bc553631310259cd4f6726c42f466c08f74c761
+  data.tar.gz: 4436ff5f2067264fc814592efebaa9ce32d69ece7607e7d728a95356db04f739
 SHA512:
-  metadata.gz: cc6a3bf67e7c73096d6a9a739d1a52ca0f4c560c80e1a7febf90a8e99d3f1009bd282ad16dfeb235b03c6613e27d7d35938a51a10314a1ffb83209b81686e748
-  data.tar.gz: effbd8f2686a312671c9275945a8705ec64453687699935872e7cb5e3445e1edcd982ee86b625dc69ba673166b13c9839d11a5756e95212b3dab4cca59055eeb
+  metadata.gz: 71492adbe4cd1771db48b2b796affa50d3f3157b420f59482e61d4a76dfc8fcec52f5face66047fc8069f5bcdd35bace4c8ff4e0fec88ffe1331872b3d625862
+  data.tar.gz: 4ecf26d66361af9d79cf33f99b9a25b8233df229a0ffa6ac33afe54d4f4c4d03e6c13609c60cceabc95dc30d8e49f7343588174fb0715bda044942360ebed53b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    timescaledb (0.1.1)
+    timescaledb (0.1.2)
       activerecord
       pg (~> 1.2)
 

data/README.md

@@ -1,40 +1,30 @@
 # Timescale
 
-Welcome to the Timescale gem! To experiment with the code, start cloning the
-repository:
+Welcome to the Timescale gem! To experiment with the code, start installing the
+gem:
 
 ```bash
-git clone https://github.com/jonatas/timescale.git
-cd timescale
-bundle install
-rake install
+gem install timescaledb
 ```
 
-Then, with `rake install` or installing the gem in your computer, you can run `tsdb` for an interactive prompt.
+## The `tsdb` CLI
 
-```bash
-tsdb postgres://<user>@localhost:5432/<dbname> --stats --flags
-```
+When you install the gem locally, a new command line application named `tsdb`
+will be linked in your command line.
 
-You can create a `.env` file locally to run tests locally. Make sure to put your
-own credentials there!
+It accepts a Postgresql URI and some extra flags that can help you to get more
+info from your TimescaleDB server:
 
 ```bash
-PG_URI_TEST="postgres://<user>@localhost:5432/<dbname>"
+tsdb <uri> --stats
 ```
 
-You can put some postgres URI directly as a parameter of
-`tsdb`. Here is an example from the console:
+Where the `<uri>` is replaced with params from your connection like:
 
 ```bash
-tsdb "postgres://jonatasdp@localhost:5432/timescale_test"
+tsdb postgres://<user>@localhost:5432/<dbname> --stats
 ```
 
-To join the console use `--console`:
-
-```bash
-tsdb "postgres://jonatasdp@localhost:5432/timescale_test" --console
-```
 
 Or just check the stats:
 
@@ -42,7 +32,7 @@ Or just check the stats:
 tsdb "postgres://jonatasdp@localhost:5432/timescale_test" --stats
 ```
 
-These is a sample output from an almost empty database:
+These is a sample output from database example with almost no data:
 
 ```ruby
 {:hypertables=>
@@ -54,19 +44,153 @@ These is a sample output from an almost empty database:
  :jobs_stats=>[{:success=>nil, :runs=>nil, :failures=>nil}]}
 ```
 
+To start a interactive ruby/[pry](https://github.com/pry/pry) console use `--console`:
 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).
+Let's consider the [caggs.sql](https://gist.github.com/jonatas/95573ad8744994094ec9f284150004f9#file-caggs-sql)
+as the example of database.
 
-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).
+```bash
+psql postgres://jonatasdp@localhost:5432/playground -f caggs.sql
+```
+
+Then use `tsdb` in the command line with the same URI and `--stats`:
+
+```bash
+tsdb postgres://jonatasdp@localhost:5432/playground --stats
+{:hypertables=>
+  {:count=>1,
+   :uncompressed=>1,
+   :approximate_row_count=>{"ticks"=>352},
+   :chunks=>{:total=>1, :compressed=>0, :uncompressed=>1},
+   :size=>{:uncompressed=>"88 KB", :compressed=>"0 Bytes"}},
+ :continuous_aggregates=>{:total=>1},
+ :jobs_stats=>[{:success=>nil, :runs=>nil, :failures=>nil}]}
+```
+
+To have some interactive playground with the actual database using ruby, just
+try the same command before changing from `--stats` to `--console`:
+
+### tsdb --console
+
+The same database from previous example, is used so
+the context has a hypertable named `ticks` and a view named `ohlc_1m`.
+
+
+```ruby
+tsdb postgres://jonatasdp@localhost:5432/playground --console
+pry(Timescale)>
+```
+
+The `tsdb` CLI will automatically create ActiveRecord models for hypertables and
+continuous aggregates views.
+
+```ruby
+Tick
+=> Timescale::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
+library or any other place.
+
+In this case, `Tick` model comes from `ticks` hypertable that was found in the database.
+It contains several extra methods inherited from `acts_as_hypertable` macro.
+
+Let's start with the `.hypertable` method.
+
+```ruby
+Tick.hypertable
+=> #<Timescale::Hypertable:0x00007fe99c258900
+ hypertable_schema: "public",
+ hypertable_name: "ticks",
+ owner: "jonatasdp",
+ num_dimensions: 1,
+ num_chunks: 1,
+ compression_enabled: false,
+ is_distributed: false,
+ replication_factor: nil,
+ data_nodes: nil,
+ tablespaces: nil>
+```
+
+The core of the hypertables are the fragmentation of the data into chunks that
+are the child tables that distribute the data. You can check all chunks directly
+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
+  hypertable_schema: "public",
+  hypertable_name: "ticks",
+  chunk_schema: "_timescaledb_internal",
+  chunk_name: "_hyper_33_17_chunk",
+  primary_dimension: "time",
+  primary_dimension_type: "timestamp without time zone",
+  range_start: 1999-12-30 00:00:00 +0000,
+  range_end: 2000-01-06 00:00:00 +0000,
+  range_start_integer: nil,
+  range_end_integer: nil,
+  is_compressed: false,
+  chunk_tablespace: nil,
+  data_nodes: nil>]
+```
+
+> Chunks are created by partitioning a hypertable's data into one
+> (or potentially multiple) dimensions. All hypertables are partitioned by the
+> values belonging to a time column, which may be in timestamp, date, or
+> various integer forms. If the time partitioning interval is one day,
+> for example, then rows with timestamps that belong to the same day are co-located
+> within the same chunk, while rows belonging to different days belong to different chunks.
+> Learn more [here](https://docs.timescale.com/timescaledb/latest/overview/core-concepts/hypertables-and-chunks/).
+
+Another core concept of TimescaleDB is compression. With data partitioned, it
+becomes very convenient to compress and decompress chunks independently.
+
+```ruby
+Tick.hypertable.chunks.first.compress!
+ActiveRecord::StatementInvalid: PG::FeatureNotSupported: ERROR:  compression not enabled on "ticks"
+DETAIL:  It is not possible to compress chunks on a hypertable that does not have compression enabled.
+HINT:  Enable compression using ALTER TABLE with the timescaledb.compress option.
+```
+
+As compression is not enabled, let's do it executing a plain SQL directly from
+the actual context. To borrow a connection, let's use the Tick object.
+
+```ruby
+Tick.connection.execute("ALTER TABLE ticks SET (timescaledb.compress)") # => PG_OK
+```
+
+And now, it's possible to compress and decompress:
+
+```ruby
+Tick.hypertable.chunks.first.compress!
+Tick.hypertable.chunks.first.decompress!
+```
+Learn more about TimescaleDB compression [here](https://docs.timescale.com/timescaledb/latest/overview/core-concepts/compression/).
+
+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)
+```
+
+And you can run any query as you do with regular active record queries.
+
+```ruby
+Ohlc1m.order(bucket: :desc).last
+=> #<Timescale::Ohlc1m:0x00007fe99c2c38e0
+ bucket: 2000-01-01 00:00:00 UTC,
+ symbol: "SYMBOL",
+ open: 0.13e2,
+ high: 0.3e2,
+ low: 0.1e1,
+ close: 0.1e2,
+ volume: 27600>
+```
 
 ## Installation
 
@@ -84,13 +208,14 @@ 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
+3. Run some queries
 4. Check chunk size per model
 5. Compress a chunk
 6. Check chunk status
@@ -140,7 +265,7 @@ end
 Tick = Class.new(ActiveRecord::Base) do
   self.table_name = 'ticks'
   self.primary_key = 'symbol'
-  include Timescale::HypertableHelpers
+  acts_as_hypertable
 end
 
 query = Tick.select(<<~QUERY)
@@ -167,14 +292,14 @@ create_continuous_aggregates('ohlc_1m', query, **options)
 
 ### Hypertable Helpers
 
-You can also use `HypertableHelpers` to get access to some basic scopes for your
+You can say `acts_as_hypertable` to get access to some basic scopes for your
 model:
 
 ```ruby
 class Event < ActiveRecord::Base
   self.primary_key = "identifier"
 
-  include Timescale::HypertableHelpers
+  acts_as_hypertable
 end
 ```
 
@@ -265,14 +390,17 @@ 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:
+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.
+
+Consider 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)}
+      .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}'."
@@ -291,13 +419,39 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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).
 
+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 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"
+```
+
+## More resources
+
+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).
+4. [the code to this repository](https://www.youtube.com/watch?v=CMdGAl_XlL4).
+5. [Working with Timescale continuous aggregates](https://youtu.be/co4HnBkHzVw).
+6. [Creating the command-line application in Ruby to explore the Timescale API](https://www.youtube.com/watch?v=I3vM_q2m7T0).
+
 ### 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
 

data/bin/tsdb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require "bundler/setup"
 require "timescale"
+require "pry"
 
 ActiveRecord::Base.establish_connection(ARGV[0])
 
@@ -8,17 +9,40 @@ 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
 
+Timescale::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)
+end
+
+def show(obj)
+  Pry::ColorPrinter.pp(obj)
+end
+
 if ARGV.index("--stats")
-  pp Timescale.show_stats
+  scope = Timescale::Hypertable.all
+
+  if (only = ARGV.index("--only"))
+    only_hypertables = ARGV[only+1].split(",")
+    scope = scope.where({hypertable_name: only_hypertables})
+  end
+
+  if (except = ARGV.index("--except"))
+    except_hypertables = ARGV[except+1].split(",")
+    scope = scope.where.not(hypertable_name: except_hypertables)
+  end
+
+  show(Timescale.stats(scope))
 end
 
 if ARGV.index("--console")
-  require "pry"
   Pry.start(Timescale)
 end

data/examples/Gemfile

@@ -1,7 +1,7 @@
 
 source 'https://rubygems.org'
 
-gem "timescale", path: "../"
+gem "timescaledb", path: "../"
 gem "pg"
 gem "activerecord"
 gem "composite_primary_keys", "~> 6.0"

data/examples/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    timescale (0.1.0)
+    timescaledb (0.1.2)
       activerecord
       pg (~> 1.2)
 
@@ -45,7 +45,7 @@ DEPENDENCIES
   dotenv (~> 2.7)
   pg
   pry
-  timescale!
+  timescaledb!
 
 BUNDLED WITH
    2.1.4

data/examples/all_in_one.rb

@@ -2,16 +2,13 @@ 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'])
+# ruby all_in_one.rb postgres://user:pass@host:port/db_name
+ActiveRecord::Base.establish_connection( ARGV.last)
 
 # Simple example
 class Event < ActiveRecord::Base
   self.primary_key = "identifier"
-
-  include Timescale::HypertableHelpers
+  acts_as_hypertable
 end
 
 # Setup Hypertable as in a migration

data/lib/timescale/chunk.rb

@@ -8,6 +8,14 @@ module Timescale
     scope :compressed, -> { where(is_compressed: true) }
     scope :uncompressed, -> { where(is_compressed: false) }
 
+    scope :resume, -> do
+      {
+        total: count,
+        compressed: compressed.count,
+        uncompressed: uncompressed.count
+      }
+    end
+
     def compress!
       execute("SELECT compress_chunk(#{chunk_relation})")
     end

data/lib/timescale/continuous_aggregates.rb

@@ -5,5 +5,14 @@ module Timescale
 
     has_many :jobs, foreign_key: "hypertable_name",
       class_name: "Timescale::Job"
+
+    has_many :chunks, foreign_key: "hypertable_name",
+      class_name: "Timescale::Chunk"
+
+    scope :resume, -> do
+      {
+        total: count
+      }
+    end
   end
 end

data/lib/timescale/dimensions.rb

@@ -0,0 +1,7 @@
+module Timescale
+  class Dimensions < ActiveRecord::Base
+    self.table_name = "timescaledb_information.dimensions"
+
+    attribute :time_interval, :interval
+  end
+end

data/lib/timescale/hypertable.rb

@@ -1,16 +1,19 @@
 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,
+    has_one :compression_settings,
       foreign_key: "hypertable_name",
       class_name: "Timescale::CompressionSettings"
 
+    has_one :dimensions,
+      foreign_key: "hypertable_name",
+      class_name: "Timescale::Dimensions"
+
     has_many :continuous_aggregates,
       foreign_key: "hypertable_name",
       class_name: "Timescale::ContinuousAggregates"
@@ -24,7 +27,8 @@ module Timescale
     end
 
     def compression_stats
-      struct_from("SELECT * from hypertable_compression_stats('#{self.hypertable_name}')").first || {}
+      @compression_stats ||=
+        struct_from("SELECT * from hypertable_compression_stats('#{self.hypertable_name}')").first || {}
     end
 
     def detailed_size

data/lib/timescale/migration_helpers.rb

@@ -21,12 +21,12 @@ module Timescale
     #  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)
+      create_hypertable(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,
+    def create_hypertable(table_name,
                                  time_column: 'created_at',
                                  chunk_time_interval: '1 week',
                                  compress_segmentby: nil,

data/lib/timescale/schema_dumper.rb

@@ -0,0 +1,24 @@
+ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.class_eval do
+  def table(table_name, stream)
+    super(table_name, stream)
+    if hypertable=Timescale::Hypertable.find_by(hypertable_name: table_name)
+      dim = hypertable.dimensions
+      # TODO Build compression settings for the template:
+      # #{build_compression_settings_for(hypertable)})
+      stream.puts <<TEMPLATE
+  create_hypertable('#{table_name}',
+                    time_column: '#{dim.column_name}',
+                    chunk_time_interval: '#{dim.time_interval.inspect}')
+TEMPLATE
+    end
+  end
+end
+
+=begin
+    def build_compression_settings_for(hypertable)
+      return if hypertable.compression_settings.nil?
+      hypertable.compression_settings.map do |settings|
+        ", compress_segmentby: #{settings.segmentby_column_index},
+                    compress_orderby: 'created_at',
+                    compression_interval: nil)
+=end

data/lib/timescale/stats_report.rb

@@ -1,28 +1,35 @@
 require "active_support/core_ext/numeric/conversions"
+
 module Timescale
   module StatsReport
     module_function
-    def resume
+    def resume(scope=Hypertable.all)
+      base_filter = {hypertable_name: scope.pluck(:hypertable_name)}
       {
         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)
-          }
+          count: scope.count,
+          uncompressed: scope.to_a.count { |h| h.compression_stats.empty? },
+          approximate_row_count: approximate_row_count(scope),
+          chunks: Chunk.where(base_filter).resume,
+          size: compression_resume(scope)
         },
-        continuous_aggregates: { count: ContinuousAggregates.count },
-        jobs_stats: JobStats.resume
+        continuous_aggregates: ContinuousAggregates.where(base_filter).resume,
+        jobs_stats: JobStats.where(base_filter).resume
       }
     end
+
+    def compression_resume(scope)
+      sum = -> (method) { (scope.map(&method).inject(:+) || 0).to_s(:human_size)}
+      {
+        uncompressed: sum[:before_total_bytes],
+        compressed: sum[:after_total_bytes]
+      }
+    end
+
+    def approximate_row_count(scope)
+      scope.to_a.map do |hypertable|
+        { hypertable.hypertable_name => hypertable.approximate_row_count }
+      end.inject(&:merge!)
+    end
   end
 end

data/lib/timescale/version.rb

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

data/lib/timescale.rb

@@ -4,6 +4,7 @@ require_relative 'timescale/acts_as_hypertable'
 require_relative 'timescale/chunk'
 require_relative 'timescale/compression_settings'
 require_relative 'timescale/continuous_aggregates'
+require_relative 'timescale/dimensions'
 require_relative 'timescale/hypertable'
 require_relative 'timescale/job'
 require_relative 'timescale/job_stats'
@@ -38,8 +39,8 @@ module Timescale
     JobStats.all
   end
 
-  def show_stats
-    StatsReport.resume
+  def stats(scope=Hypertable.all)
+    StatsReport.resume(scope)
   end
 
   def default_hypertable_options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -136,10 +136,12 @@ files:
 - lib/timescale/chunk.rb
 - lib/timescale/compression_settings.rb
 - lib/timescale/continuous_aggregates.rb
+- lib/timescale/dimensions.rb
 - lib/timescale/hypertable.rb
 - lib/timescale/job.rb
 - lib/timescale/job_stats.rb
 - lib/timescale/migration_helpers.rb
+- lib/timescale/schema_dumper.rb
 - lib/timescale/stats_report.rb
 - lib/timescale/version.rb
 - timescale.gemspec