timescaledb 0.2.7 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9281749307a9161088f45af47b26ac9577d693e03958c351eee257467b706428
-  data.tar.gz: 5a3ef9e484416b56091d62eaff9c3063ca19d441a893e022c10ebe17d4997241
+  metadata.gz: 89553264709636b53e3d56174f3e244561c10f2c4801b922ba25adb8bf32aca7
+  data.tar.gz: f254f76133d13d6854f8f7dee865a0f3bb4adc57617c200ee276d1408541475a
 SHA512:
-  metadata.gz: 37f96329e32067e2d891f1ea8c40f3b2af4e6b4422f1a6a47593013b70092f95207e9d1b6ddc8708f342fede9395e92951b52a04d57bafb1eb4bdeecd29c481b
-  data.tar.gz: 4fdb61ef0fae73b217c2f14791f29bfb1dfe0b447c3a26c95f2a78d2ecf9ed97de2f14b8c3af0741dab91dac3746430a5281e0f98c4a97279fd62506fb2ceba7
+  metadata.gz: b30bbba9b0da08b3cad42fbc80e73c7aed2e37763d01cfd2b93d569e4bd65768a507fc6e25a757c7b83bd4f9ad3e7e18d98090b7a2f2e8bebcb5d16fb3a63d7c
+  data.tar.gz: bb0ba7379e86631d71256cf66cc506eb42511145f17e343e749bc10e28b7c394a482e9d4a3380ff9ee2af511be51d44529556566fe08421aa92b924755d492c8

data/bin/tsdb

@@ -1,48 +1,49 @@
 #!/usr/bin/env ruby
+
 require "bundler/setup"
 require "timescaledb"
 require "pry"
 
-ActiveRecord::Base.establish_connection(ARGV[0])
-
-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 time_column: hypertable.main_dimension.column_name
-  end
-  Timescaledb.const_set(class_name, model)
-end
-
-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
-  Timescaledb.const_set(class_name, model)
-end
+Timescaledb.establish_connection(ARGV[0])
 
-def show(obj)
-  Pry::ColorPrinter.pp(obj)
-end
+hypertables = Timescaledb.connection.query('SELECT * FROM timescaledb_information.hypertables')
 
 if ARGV.index("--stats")
-  scope = Timescaledb::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"))
+    hypertables.select! { |hypertable| only_hypertables.includes?(hypertable.hypertable_name) }
+  elsif (except = ARGV.index("--except"))
     except_hypertables = ARGV[except+1].split(",")
-    scope = scope.where.not(hypertable_name: except_hypertables)
+
+    hypertables.select! { |hypertable| except_hypertables.includes?(hypertable.hypertable_name) }
   end
 
-  show(Timescaledb.stats(scope))
+  stats = Timescaledb::Stats.new(hypertables).to_h
+
+  Pry::ColorPrinter.pp(stats)
 end
 
 if ARGV.index("--console")
+  ActiveRecord::Base.establish_connection(ARGV[0])
+
+  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 time_column: hypertable.main_dimension.column_name
+    end
+    Timescaledb.const_set(class_name, model)
+  end
+
+  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
+    Timescaledb.const_set(class_name, model)
+  end
+
   Pry.start(Timescaledb)
 end

data/lib/timescaledb/acts_as_hypertable.rb

@@ -42,6 +42,9 @@ module Timescaledb
     #     acts_as_hypertable time_column: :timestamp
     #   end
     #
+    # @param [Hash] options The options to initialize your macro with.
+    # @option options [Boolean] :skip_association_scopes to avoid `.hypertable`, `.chunks` and other scopes related to metadata.
+    # @option options [Boolean] :skip_default_scopes to avoid the generation of default time related scopes like `last_hour`, `last_week`, `yesterday` and so on...
     def acts_as_hypertable(options = {})
       return if acts_as_hypertable?
 
@@ -53,8 +56,8 @@ module Timescaledb
       hypertable_options.merge!(options)
       normalize_hypertable_options
 
-      define_association_scopes
-      define_default_scopes
+      define_association_scopes unless options[:skip_association_scopes]
+      define_default_scopes unless options[:skip_default_scopes]
     end
   end
 end

data/lib/timescaledb/connection.rb

@@ -0,0 +1,54 @@
+require 'singleton'
+
+module Timescaledb
+  # Minimal connection setup for Timescaledb directly with the PG.
+  # The concept is use a singleton component that can query
+  # independently of the ActiveRecord::Base connections.
+  # This is useful for the extension and hypertable metadata.
+  # It can also #use_connection from active record if needed.
+  class Connection
+    include Singleton
+
+    attr_writer :config
+
+    # @param [String] query The SQL raw query.
+    # @param [Array] params The SQL query parameters.
+    # @return [Array<OpenStruct>] The SQL result.
+    def query(query, params = [])
+      query = params.empty? ? connection.exec(query) : connection.exec_params(query, params)
+
+      query.map(&OpenStruct.method(:new))
+    end
+
+    # @param [String] query The SQL raw query.
+    # @param [Array] params The SQL query parameters.
+    # @return [OpenStruct] The first SQL result.
+    def query_first(query, params = [])
+      query(query, params).first
+    end
+
+    # @param [String] query The SQL raw query.
+    # @param [Array] params The SQL query parameters.
+    # @return [Integr] The count value from SQL result.
+    def query_count(query, params = [])
+      query_first(query, params).count.to_i
+    end
+
+    # @param [Boolean] True if the connection singleton was configured, otherwise returns false.
+    def connected?
+      !@config.nil?
+    end
+
+    # Override the connection with a raw PG connection.
+    # @param [PG::Connection] connection The raw PG connection.
+    def use_connection connection
+      @connection = connection
+    end
+
+    private
+
+    def connection
+      @connection ||= PG.connect(@config)
+    end
+  end
+end

data/lib/timescaledb/connection_handling.rb

@@ -0,0 +1,21 @@
+module Timescaledb
+  class ConnectionNotEstablishedError < StandardError; end
+
+  module_function
+  
+  # @param [String] config with the postgres connection string.
+  def establish_connection(config)
+    Connection.instance.config = config
+  end
+
+  # @param [PG::Connection] to use it directly from a raw connection
+  def use_connection conn
+    Connection.instance.use_connection conn
+  end
+
+  def connection
+    raise ConnectionNotEstablishedError.new unless Connection.instance.connected?
+
+    Connection.instance
+  end
+end

data/lib/timescaledb/database/chunk_statements.rb

@@ -0,0 +1,21 @@
+module Timescaledb
+  class Database
+    module ChunkStatements
+      # @see https://docs.timescale.com/api/latest/compression/compress_chunk/
+      #
+      # @param [String] chunk_name The name of the chunk to be compressed
+      # @return [String] The compress_chunk SQL statement
+      def compress_chunk_sql(chunk_name)
+        "SELECT compress_chunk(#{quote(chunk_name)});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/compression/decompress_chunk/
+      #
+      # @param [String] chunk_name The name of the chunk to be decompressed
+      # @return [String] The decompress_chunk SQL statement
+      def decompress_chunk_sql(chunk_name)
+        "SELECT decompress_chunk(#{quote(chunk_name)});"
+      end
+    end
+  end
+end

data/lib/timescaledb/database/hypertable_statements.rb

@@ -0,0 +1,37 @@
+module Timescaledb
+  class Database
+    module HypertableStatements
+      # @see https://docs.timescale.com/api/latest/hypertable/hypertable_size/
+      #
+      # @param [String] hypertable The hypertable to show size of
+      # @return [String] The hypertable_size SQL statement
+      def hypertable_size_sql(hypertable)
+        "SELECT hypertable_size(#{quote(hypertable)});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/hypertable/hypertable_detailed_size/
+      #
+      # @param [String] hypertable The hypertable to show detailed size of
+      # @return [String] The hypertable_detailed_size SQL statementh
+      def hypertable_detailed_size_sql(hypertable)
+        "SELECT * FROM hypertable_detailed_size(#{quote(hypertable)});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/hypertable/hypertable_index_size/
+      #
+      # @param [String] index_name The name of the index on a hypertable
+      # @return [String] The hypertable_detailed_size SQL statementh
+      def hypertable_index_size_sql(index_name)
+        "SELECT hypertable_index_size(#{quote(index_name)});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/hypertable/chunks_detailed_size/
+      #
+      # @param [String] hypertable The name of the hypertable
+      # @return [String] The chunks_detailed_size SQL statementh
+      def chunks_detailed_size_sql(hypertable)
+        "SELECT * FROM chunks_detailed_size(#{quote(hypertable)});"
+      end
+    end
+  end
+end

data/lib/timescaledb/database/schema_statements.rb

@@ -15,7 +15,7 @@ module Timescaledb
 
         arguments  = [quote(relation), quote(time_column_name)]
         arguments += [quote(partitioning_column), number_partitions] if partitioning_column && number_partitions
-        arguments += cast_create_hypertable_optional_arguments(options)
+        arguments += create_hypertable_options_to_named_notation_sql(options)
 
         "SELECT create_hypertable(#{arguments.join(', ')});"
       end
@@ -56,7 +56,7 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable), interval_to_sql(compress_after)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT add_compression_policy(#{arguments.join(', ')});"
       end
@@ -70,7 +70,7 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT remove_compression_policy(#{arguments.join(', ')});"
       end
@@ -85,7 +85,7 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable), interval_to_sql(drop_after)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT add_retention_policy(#{arguments.join(', ')});"
       end
@@ -99,7 +99,7 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT remove_retention_policy(#{arguments.join(', ')});"
       end
@@ -114,7 +114,7 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable), quote(index_name)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT add_reorder_policy(#{arguments.join(', ')});"
       end
@@ -128,41 +128,119 @@ module Timescaledb
         options.transform_keys!(&:to_sym)
 
         arguments = [quote(hypertable)]
-        arguments += cast_policy_optional_arguments(options)
+        arguments += policy_options_to_named_notation_sql(options)
 
         "SELECT remove_reorder_policy(#{arguments.join(', ')});"
       end
 
+      # @see https://docs.timescale.com/api/latest/continuous-aggregates/create_materialized_view
+      #
+      # @param [String] continuous_aggregate The name of the continuous aggregate view to be created
+      # @param [Hash] options The optional arguments
+      # @return [String] The create materialized view SQL statement
+      def create_continuous_aggregate_sql(continuous_aggregate, sql, **options)
+        options.transform_keys!(&:to_sym)
+
+        with_data_opts = %w[WITH DATA]
+        with_data_opts.insert(1, 'NO') if options.key?(:with_no_data)
+
+        <<~SQL
+          CREATE MATERIALIZED VIEW #{continuous_aggregate}
+          WITH (timescaledb.continuous) AS
+          #{sql.strip}
+          #{with_data_opts.join(' ')};
+        SQL
+      end
+
+      # @see https://docs.timescale.com/api/latest/continuous-aggregates/drop_materialized_view
+      #
+      # @param [String] continuous_aggregate The name of the continuous aggregate view to be dropped
+      # @param [Boolean] cascade A boolean to drop objects that depend on the continuous aggregate view
+      # @return [String] The drop materialized view SQL statement
+      def drop_continuous_aggregate_sql(continuous_aggregate, cascade: false)
+        arguments = [continuous_aggregate]
+        arguments << 'CASCADE' if cascade
+
+        "DROP MATERIALIZED VIEW #{arguments.join(' ')};"
+      end
+
+      # @see https://docs.timescale.com/api/latest/continuous-aggregates/add_continuous_aggregate_policy
+      #
+      # @param [String] continuous_aggregate The name of the continuous aggregate to add the policy for
+      # @param [String] start_offset The start of the refresh window as an interval relative to the time when the policy is executed
+      # @param [String] end_offset The end of the refresh window as an interval relative to the time when the policy is executed
+      # @param [String] schedule_interval The interval between refresh executions in wall-clock time
+      # @param [Hash] options The optional arguments
+      # @return [String] The add_continuous_aggregate_policy SQL statement
+      def add_continuous_aggregate_policy_sql(continuous_aggregate, start_offset: nil, end_offset: nil, schedule_interval:, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(continuous_aggregate)]
+        arguments << named_notation_sql(name: :start_offset, value: interval_to_sql(start_offset))
+        arguments << named_notation_sql(name: :end_offset, value: interval_to_sql(end_offset))
+        arguments << named_notation_sql(name: :schedule_interval, value: interval_to_sql(schedule_interval))
+        arguments += continuous_aggregate_policy_options_to_named_notation_sql(options)
+
+        "SELECT add_continuous_aggregate_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/continuous-aggregates/remove_continuous_aggregate_policy
+      #
+      # @param [String] continuous_aggregate The name of the continuous aggregate the policy should be removed from
+      # @param [Hash] options The optional arguments
+      # @return [String] The remove_continuous_aggregate_policy SQL statement
+      def remove_continuous_aggregate_policy_sql(continuous_aggregate, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(continuous_aggregate)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT remove_continuous_aggregate_policy(#{arguments.join(', ')});"
+      end
+
       private
 
       # @param [Array<Hash<Symbol, Object>>] options The policy optional arguments.
       # @return [Array<String>]
-      def cast_policy_optional_arguments(options)
+      def policy_options_to_named_notation_sql(options)
         options.map do |option, value|
           case option
-          when :if_not_exists, :if_exists then "#{option} => #{boolean_to_sql(value)}"
-          when :initial_start, :timezone then "#{option} => #{quote(value)}"
+          when :if_not_exists, :if_exists then named_notation_sql(name: option, value: boolean_to_sql(value))
+          when :initial_start, :timezone then named_notation_sql(name: option, value: quote(value))
           end
         end.compact
       end
 
       # @param [Array<Hash<Symbol, Object>>] options The create_hypertable optional arguments.
       # @return [Array<String>]
-      def cast_create_hypertable_optional_arguments(options)
+      def create_hypertable_options_to_named_notation_sql(options)
         options.map do |option, value|
           case option
           when :chunk_time_interval
-            "#{option} => #{interval_to_sql(value)}"
+            named_notation_sql(name: option, value: interval_to_sql(value))
           when :if_not_exists, :create_default_indexes, :migrate_data, :distributed
-            "#{option} => #{boolean_to_sql(value)}"
+            named_notation_sql(name: option, value: boolean_to_sql(value))
           when :partitioning_func, :associated_schema_name,
                :associated_table_prefix, :time_partitioning_func
-            "#{option} => #{quote(value)}"
-          when :replication_factor
-            "#{option} => #{value}"
+            named_notation_sql(name: option, value: quote(value))
+          end
+        end.compact
+      end
+
+      # @param [Array<Hash<Symbol, Object>>] options The continuous aggregate policy arguments.
+      # @return [Array<String>]
+      def continuous_aggregate_policy_options_to_named_notation_sql(options)
+        options.map do |option, value|
+          case option
+          when :if_not_exists then named_notation_sql(name: option, value: boolean_to_sql(value))
+          when :initial_start, :timezone then named_notation_sql(name: option, value: quote(value))
           end
         end.compact
       end
+
+      def named_notation_sql(name:, value:)
+        "#{name} => #{value}"
+      end
     end
   end
 end

data/lib/timescaledb/database/types.rb

@@ -1,9 +1,12 @@
 module Timescaledb
   class Database
     module Types
-      # @param [String] interval The interval value
+      # @param [String, Integer] interval The interval value
       # @return [String]
       def interval_to_sql(interval)
+        return 'NULL' if interval.nil?
+        return interval if interval.kind_of?(Integer)
+
         "INTERVAL #{quote(interval)}"
       end
 

data/lib/timescaledb/database.rb

@@ -1,9 +1,13 @@
+require_relative 'database/chunk_statements'
+require_relative 'database/hypertable_statements'
 require_relative 'database/quoting'
 require_relative 'database/schema_statements'
 require_relative 'database/types'
 
 module Timescaledb
   class Database
+    extend ChunkStatements
+    extend HypertableStatements
     extend Quoting
     extend SchemaStatements
     extend Types

data/lib/timescaledb/extension.rb

@@ -0,0 +1,23 @@
+module Timescaledb
+
+  # Provides metadata around the extension in the database
+  module Extension
+    module_function
+    # @return String version of the timescaledb extension
+    def version
+      @version ||= Timescaledb.connection.query_first(<<~SQL)&.version
+        SELECT extversion as version
+        FROM pg_extension
+        WHERE extname = 'timescaledb'
+      SQL
+    end
+
+    def installed?
+      version.present?
+    end
+
+    def update!
+      Timescaledb.connection.execute('ALTER EXTENSION timescaledb UPDATE')
+    end
+  end
+end

data/lib/timescaledb/migration_helpers.rb

@@ -29,6 +29,11 @@ module Timescaledb
       create_hypertable(table_name, **options[:hypertable]) if options.key?(:hypertable)
     end
 
+    # Override the valid_table_definition_options to include hypertable.
+    def valid_table_definition_options # :nodoc:
+      super + [:hypertable]
+    end
+
     # Setup hypertable from options
     # @see create_table with the hypertable options.
     def create_hypertable(table_name,
@@ -41,6 +46,7 @@ module Timescaledb
                           number_partitions: nil,
                           **hypertable_options)
 
+      original_logger = ActiveRecord::Base.logger
       ActiveRecord::Base.logger = Logger.new(STDOUT)
 
       options = ["chunk_time_interval => INTERVAL '#{chunk_time_interval}'"]
@@ -58,16 +64,18 @@ module Timescaledb
 
       if compress_segmentby
         execute <<~SQL
-        ALTER TABLE #{table_name} SET (
-          timescaledb.compress,
-          timescaledb.compress_orderby = '#{compress_orderby}',
-          timescaledb.compress_segmentby = '#{compress_segmentby}'
-        )
+          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
+    ensure
+      ActiveRecord::Base.logger = original_logger if original_logger
     end
 
     # Create a new continuous aggregate
@@ -79,7 +87,11 @@ module Timescaledb
     # @option refresh_policies [String] start_offset: INTERVAL or integer
     # @option refresh_policies [String] end_offset: INTERVAL or integer
     # @option refresh_policies [String] schedule_interval: INTERVAL
+    # @option materialized_only [Boolean] Override the WITH clause 'timescaledb.materialized_only'
+    # @option create_group_indexes [Boolean] Override the WITH clause 'timescaledb.create_group_indexes'
+    # @option finalized [Boolean] Override the WITH clause 'timescaledb.finalized'
     #
+    # @see https://docs.timescale.com/api/latest/continuous-aggregates/create_materialized_view/
     # @see https://docs.timescale.com/api/latest/continuous-aggregates/add_continuous_aggregate_policy/
     #
     # @example
@@ -94,15 +106,19 @@ module Timescaledb
     def create_continuous_aggregate(table_name, query, **options)
       execute <<~SQL
         CREATE MATERIALIZED VIEW #{table_name}
-        WITH (timescaledb.continuous) AS
+        WITH (
+          timescaledb.continuous
+          #{build_with_clause_option_string(:materialized_only, options)}
+          #{build_with_clause_option_string(:create_group_indexes, options)}
+          #{build_with_clause_option_string(:finalized, options)}
+        ) AS
         #{query.respond_to?(:to_sql) ? query.to_sql : query}
-        WITH #{"NO" unless options[:with_data]} DATA;
+        WITH #{'NO' unless options[:with_data]} DATA;
       SQL
 
       create_continuous_aggregate_policy(table_name, **(options[:refresh_policies] || {}))
     end
 
-
     #  Drop a new continuous aggregate.
     #
     #  It basically DROP MATERIALIZED VIEW for a given @name.
@@ -137,6 +153,18 @@ module Timescaledb
     def remove_retention_policy(table_name)
       execute "SELECT remove_retention_policy('#{table_name}')"
     end
+
+    private
+
+    # Build a string for the WITH clause of the CREATE MATERIALIZED VIEW statement.
+    # When the option is omitted, this method returns an empty string, which allows this gem to use the
+    # defaults provided by TimescaleDB.
+    def build_with_clause_option_string(option_key, options)
+      return '' unless options.key?(option_key)
+
+      value = options[option_key] ? 'true' : 'false'
+      ",timescaledb.#{option_key}=#{value}"
+    end
   end
 end
 

data/lib/timescaledb/scenic/extension.rb

@@ -25,7 +25,6 @@ module Timescaledb
 
       # @override Scenic::Adapters::Postgres#create_view
       # to add the `with: ` keyword that can be used for such option.
-      #
       def create_view(name, version: nil, with: nil, sql_definition: nil, materialized: false, no_data: false)
         if version.present? && sql_definition.present?
           raise(
@@ -69,4 +68,4 @@ end
 
 
 Scenic::Adapters::Postgres.include(Timescaledb::Scenic::Extension)
-ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Timescaledb::Scenic::MigrationHelpers)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(Timescaledb::Scenic::MigrationHelpers)

data/lib/timescaledb/schema_dumper.rb

@@ -2,15 +2,57 @@ require 'active_record/connection_adapters/postgresql_adapter'
 require 'active_support/core_ext/string/indent'
 
 module Timescaledb
+  # Schema dumper overrides default schema dumper to include:
+  # * hypertables
+  # * retention policies
+  # * continuous aggregates
+  # * compression settings
+  # It also ignores Timescale related schemas when dumping the schema.
+  # It also ignores dumping options as extension is not installed or no hypertables are available.
   module SchemaDumper
     def tables(stream)
       super # This will call #table for each table in the database
 
-      return unless Timescaledb::Hypertable.table_exists?
+      if exports_timescaledb_metadata?
+        timescale_hypertables(stream)
+        timescale_retention_policies(stream)
+        timescale_continuous_aggregates(stream) # Define these before any Scenic views that might use them
+      end
+    end
+
+    # Ignore dumps in case DB is not eligible for TimescaleDB metadata.
+    # @return [Boolean] true if the extension is installed and hypertables are available, otherwise false.
+    private def exports_timescaledb_metadata?
+      # Note it's safe to use the raw connection here because we're only reading from the database
+      # and not modifying it. We're also on the same connection pool as ActiveRecord::Base.
+      # The dump process also runs standalone, so we don't need to worry about the connection being
+      # used elsewhere.
+      Timescaledb.use_connection @connection.raw_connection
 
-      timescale_hypertables(stream)
-      timescale_retention_policies(stream)
-      timescale_continuous_aggregates(stream) # Define these before any Scenic views that might use them
+      Timescaledb.extension.installed? && Timescaledb.hypertables.any?
+    end
+
+    # Ignores Timescale related schemas when dumping the schema
+    IGNORE_SCHEMAS = %w[
+      _timescaledb_cache
+      _timescaledb_config
+      _timescaledb_catalog
+      _timescaledb_debug
+      _timescaledb_functions
+      _timescaledb_internal
+      timescaledb_experimental
+      timescaledb_information
+      toolkit_experimental
+    ]
+
+    def schemas(stream)
+      schema_names = @connection.schema_names - ["public", *IGNORE_SCHEMAS]
+      if schema_names.any?
+        schema_names.sort.each do |name|
+          stream.puts "  create_schema #{name.inspect}"
+        end
+        stream.puts
+      end
     end
 
     def timescale_hypertables(stream)
@@ -112,19 +154,20 @@ module Timescaledb
     def timescale_continuous_aggregates(stream)
       return unless Timescaledb::ContinuousAggregates.table_exists?
 
-      Timescaledb::ContinuousAggregates.all.each do |aggregate|
-        opts = if (refresh_policy = aggregate.jobs.refresh_continuous_aggregate.first)
-                 interval = timescale_interval(refresh_policy.schedule_interval)
-                 end_offset = timescale_interval(refresh_policy.config["end_offset"])
-                 start_offset = timescale_interval(refresh_policy.config["start_offset"])
-                 %Q[, refresh_policies: { start_offset: "#{start_offset}", end_offset: "#{end_offset}", schedule_interval: "#{interval}"}]
-               else
-                 ""
-               end
+      Timescaledb::ContinuousAggregates.all.find_each do |aggregate|
+        refresh_policies_opts = if (refresh_policy = aggregate.jobs.refresh_continuous_aggregate.first)
+          interval = timescale_interval(refresh_policy.schedule_interval)
+          end_offset = timescale_interval(refresh_policy.config["end_offset"])
+          start_offset = timescale_interval(refresh_policy.config["start_offset"])
+          %(refresh_policies: { start_offset: "#{start_offset}", end_offset: "#{end_offset}", schedule_interval: "#{interval}"})
+        else
+          ""
+        end
 
+        with_clause_opts = "materialized_only: #{aggregate[:materialized_only]}, finalized: #{aggregate[:finalized]}"
         stream.puts <<~AGG.indent(2)
-          create_continuous_aggregate("#{aggregate.view_name}", <<-SQL#{opts})
-            #{aggregate.view_definition.strip.gsub(/;$/, "")}
+          create_continuous_aggregate("#{aggregate.view_name}", <<-SQL, #{refresh_policies_opts}, #{with_clause_opts})
+            #{aggregate.view_definition.strip.gsub(/;$/, '')}
           SQL
         AGG
         stream.puts

data/lib/timescaledb/stats/chunks.rb

@@ -0,0 +1,41 @@
+module Timescaledb
+  class Stats
+    class Chunks
+      # @param [Array<String>] hypertables The list of hypertable names.
+      # @param [Timescaledb:Connection] connection The PG connection.
+      def initialize(hypertables = [], connection = Timescaledb.connection)
+        @connection = connection
+        @hypertables = hypertables
+      end
+
+      delegate :query_count, to: :@connection
+
+      # @return [Hash] The chunks stats
+      def to_h
+        { total: total, compressed: compressed, uncompressed: uncompressed }
+      end
+
+      private
+
+      def total
+        query_count(base_query, [@hypertables])
+      end
+
+      def compressed
+        compressed_query = [base_query, 'is_compressed'].join(' AND ')
+
+        query_count(compressed_query, [@hypertables])
+      end
+
+      def uncompressed
+        uncompressed_query = [base_query, 'NOT is_compressed'].join(' AND ')
+
+        query_count(uncompressed_query, [@hypertables])
+      end
+
+      def base_query
+        "SELECT COUNT(1) FROM timescaledb_information.chunks WHERE hypertable_name IN ($1)"
+      end
+    end
+  end
+end

data/lib/timescaledb/stats/continuous_aggregates.rb

@@ -0,0 +1,24 @@
+
+module Timescaledb
+  class Stats
+    class ContinuousAggregates
+      # @param [Timescaledb:Connection] connection The PG connection.
+      def initialize(connection = Timescaledb.connection)
+        @connection = connection
+      end
+
+      delegate :query_count, to: :@connection
+
+      # @return [Hash] The continuous_aggregates stats
+      def to_h
+        { total: total }
+      end
+
+      private
+
+      def total
+        query_count('SELECT COUNT(1) FROM timescaledb_information.continuous_aggregates')
+      end
+    end
+  end
+end

data/lib/timescaledb/stats/hypertables.rb

@@ -0,0 +1,102 @@
+require_relative './chunks'
+
+module Timescaledb
+  class Stats
+    class Hypertables
+      # @param [Timescaledb:Connection] connection The PG connection.
+      # @param [Array<String>] hypertables The list of hypertable names.
+      def initialize(hypertables = [], connection = Timescaledb.connection)
+        @connection = connection
+        @hypertables = hypertables.map(&method('hypertable_name_with_schema'))
+      end
+
+      delegate :query, :query_first, :query_count, to: :@connection
+
+      # @return [Hash] The hypertables stats
+      def to_h
+        {
+          count: @hypertables.count,
+          uncompressed_count: uncompressed_count,
+          approximate_row_count: approximate_row_count,
+          chunks: Timescaledb::Stats::Chunks.new(@hypertables).to_h,
+          size: size
+        }
+      end
+
+      private
+
+      def uncompressed_count
+        @hypertables.count do |hypertable|
+          query("SELECT * from hypertable_compression_stats('#{hypertable}')").empty?
+        end
+      end
+
+      def approximate_row_count
+        @hypertables.each_with_object(Hash.new) do |hypertable, summary|
+          row_count = query_first("SELECT * FROM approximate_row_count('#{hypertable}')").approximate_row_count.to_i
+
+          summary[hypertable] = row_count
+        end
+      end
+
+      def size
+        sum = -> (method_name) { (@hypertables.map(&method(method_name)).inject(:+) || 0) }
+
+        {
+          uncompressed: humanize_bytes(sum[:before_total_bytes]),
+          compressed: humanize_bytes(sum[:after_total_bytes])
+        }
+      end
+
+      def before_total_bytes(hypertable)
+        (compression_stats[hypertable]&.before_compression_total_bytes || detailed_size[hypertable]).to_i
+      end
+
+      def after_total_bytes(hypertable)
+        (compression_stats[hypertable]&.after_compression_total_bytes || 0).to_i
+      end
+
+      def compression_stats
+        @compression_stats ||=
+          @hypertables.each_with_object(Hash.new) do |hypertable, stats|
+            stats[hypertable] = query_first(compression_stats_query, [hypertable])
+            stats
+          end
+      end
+
+      def compression_stats_query
+        'SELECT * FROM hypertable_compression_stats($1)'
+      end
+
+      def detailed_size
+        @detailed_size ||=
+          @hypertables.each_with_object(Hash.new) do |hypertable, size|
+            size[hypertable] = query_first(detailed_size_query, [hypertable]).total_bytes
+            size
+          end
+      end
+
+      def detailed_size_query
+        'SELECT * FROM hypertable_detailed_size($1)'
+      end
+
+      def hypertable_name_with_schema(hypertable)
+        [hypertable.hypertable_schema, hypertable.hypertable_name].compact.join('.')
+      end
+
+      def humanize_bytes(bytes)
+        units = %w(B KiB MiB GiB TiB PiB EiB)
+
+        return '0 B' if bytes == 0
+
+        exp = (Math.log2(bytes) / 10).floor
+        max_exp = units.size - 1
+        exp = max_exp if exp > max_exp
+
+        value = (bytes.to_f / (1 << (exp * 10))).round(1)
+
+        "#{value} #{units[exp]}"
+      end
+    end
+  end
+end

data/lib/timescaledb/stats/job_stats.rb

@@ -0,0 +1,29 @@
+
+module Timescaledb
+  class Stats
+    class JobStats
+      # @param [Timescaledb:Connection] connection The PG connection.
+      def initialize(connection = Timescaledb.connection)
+        @connection = connection
+      end
+
+      delegate :query_first, to: :@connection
+
+      # @return [Hash] The job_stats stats
+      def to_h
+        query_first(job_stats_query).to_h.transform_values(&:to_i)
+      end
+
+      private
+
+      def job_stats_query
+        <<-SQL
+          SELECT SUM(total_successes)::INT AS success,
+                 SUM(total_runs)::INT AS runs,
+                 SUM(total_failures)::INT AS failures
+          FROM timescaledb_information.job_stats
+        SQL
+      end
+    end
+  end
+end

data/lib/timescaledb/stats.rb

@@ -0,0 +1,22 @@
+require_relative './stats/continuous_aggregates'
+require_relative './stats/hypertables'
+require_relative './stats/job_stats'
+
+module Timescaledb
+  class Stats
+    # @param [Array<OpenStruct>] hypertables The list of hypertables.
+    # @param [Timescaledb:Connection] connection The PG connection.
+    def initialize(hypertables = [], connection = Timescaledb.connection)
+      @hypertables = hypertables
+      @connection = connection
+    end
+
+    def to_h
+      {
+        hypertables: Hypertables.new(@hypertables).to_h,
+        continuous_aggregates: ContinuousAggregates.new.to_h,
+        jobs_stats: JobStats.new.to_h
+      }
+    end
+  end
+end

data/lib/timescaledb/toolkit/time_vector.rb

@@ -67,7 +67,7 @@ module Timescaledb
 
              select(  %|time_bucket('#{timeframe}', "#{time}")|,
                  *segment_by,
-                "toolkit_experimental.candlestick_agg(#{time}, #{value}, #{volume}) as candlestick")
+                "candlestick_agg(#{time}, #{value}, #{volume}) as candlestick")
               .order(1)
               .group(*(segment_by ? [1,2] : 1))
           end
@@ -82,49 +82,16 @@ module Timescaledb
             unscoped
               .from("(#{raw.to_sql}) AS candlestick")
               .select("time_bucket",*segment_by,
-               "toolkit_experimental.open(candlestick),
-                toolkit_experimental.high(candlestick),
-                toolkit_experimental.low(candlestick),
-                toolkit_experimental.close(candlestick),
-                toolkit_experimental.open_time(candlestick),
-                toolkit_experimental.high_time(candlestick),
-                toolkit_experimental.low_time(candlestick),
-                toolkit_experimental.close_time(candlestick),
-                toolkit_experimental.volume(candlestick),
-                toolkit_experimental.vwap(candlestick)")
-          end
-
-          scope :_ohlc, -> (timeframe: '1h',
-                           segment_by: segment_by_column,
-                           time: time_column,
-                           value: value_column) do
-
-             select( *segment_by,
-                  %|time_bucket('#{timeframe}', #{time}) as "#{time}"|,
-                  "toolkit_experimental.ohlc(#{time}, #{value})")
-              .order(1)
-              .group(*(segment_by ? [1,2] : 1))
-          end
-
-
-
-          scope :ohlc, -> (timeframe: '1h',
-                           segment_by: segment_by_column,
-                           time: time_column,
-                           value: value_column) do
-
-            raw = _ohlc(timeframe: timeframe, segment_by: segment_by, time: time, value: value)
-            unscoped
-              .from("(#{raw.to_sql}) AS ohlc")
-              .select(*segment_by, time,
-               "toolkit_experimental.open(ohlc),
-                toolkit_experimental.high(ohlc),
-                toolkit_experimental.low(ohlc),
-                toolkit_experimental.close(ohlc),
-                toolkit_experimental.open_time(ohlc),
-                toolkit_experimental.high_time(ohlc),
-                toolkit_experimental.low_time(ohlc),
-                toolkit_experimental.close_time(ohlc)")
+               "open(candlestick),
+                high(candlestick),
+                low(candlestick),
+                close(candlestick),
+                open_time(candlestick),
+                high_time(candlestick),
+                low_time(candlestick),
+                close_time(candlestick),
+                volume(candlestick),
+                vwap(candlestick)")
           end
         end
       end

data/lib/timescaledb/version.rb

@@ -1,3 +1,3 @@
 module Timescaledb
-  VERSION = '0.2.7'
+  VERSION = '0.2.9'
 end

data/lib/timescaledb.rb

@@ -3,22 +3,34 @@ require 'active_record'
 require_relative 'timescaledb/application_record'
 require_relative 'timescaledb/acts_as_hypertable'
 require_relative 'timescaledb/acts_as_hypertable/core'
+require_relative 'timescaledb/connection'
 require_relative 'timescaledb/toolkit'
 require_relative 'timescaledb/chunk'
 require_relative 'timescaledb/compression_settings'
+require_relative 'timescaledb/connection_handling'
 require_relative 'timescaledb/continuous_aggregates'
 require_relative 'timescaledb/dimensions'
 require_relative 'timescaledb/hypertable'
 require_relative 'timescaledb/job'
 require_relative 'timescaledb/job_stats'
 require_relative 'timescaledb/schema_dumper'
+require_relative 'timescaledb/stats'
 require_relative 'timescaledb/stats_report'
 require_relative 'timescaledb/migration_helpers'
+require_relative 'timescaledb/extension'
 require_relative 'timescaledb/version'
 
 module Timescaledb
   module_function
 
+  def connection
+    Connection.instance
+  end
+
+  def extension
+    Extension
+  end
+
   def chunks
     Chunk.all
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timescaledb
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.9
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-06 00:00:00.000000000 Z
+date: 2024-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -153,12 +153,17 @@ files:
 - lib/timescaledb/application_record.rb
 - lib/timescaledb/chunk.rb
 - lib/timescaledb/compression_settings.rb
+- lib/timescaledb/connection.rb
+- lib/timescaledb/connection_handling.rb
 - lib/timescaledb/continuous_aggregates.rb
 - lib/timescaledb/database.rb
+- lib/timescaledb/database/chunk_statements.rb
+- lib/timescaledb/database/hypertable_statements.rb
 - lib/timescaledb/database/quoting.rb
 - lib/timescaledb/database/schema_statements.rb
 - lib/timescaledb/database/types.rb
 - lib/timescaledb/dimensions.rb
+- lib/timescaledb/extension.rb
 - lib/timescaledb/hypertable.rb
 - lib/timescaledb/job.rb
 - lib/timescaledb/job_stats.rb
@@ -166,6 +171,11 @@ files:
 - lib/timescaledb/scenic/adapter.rb
 - lib/timescaledb/scenic/extension.rb
 - lib/timescaledb/schema_dumper.rb
+- lib/timescaledb/stats.rb
+- lib/timescaledb/stats/chunks.rb
+- lib/timescaledb/stats/continuous_aggregates.rb
+- lib/timescaledb/stats/hypertables.rb
+- lib/timescaledb/stats/job_stats.rb
 - lib/timescaledb/stats_report.rb
 - lib/timescaledb/toolkit.rb
 - lib/timescaledb/toolkit/helpers.rb