timescaledb 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06f324ce8793264ad6acb6a0f0f8f107511be08ecf2952e2fab285aeac366d35
-  data.tar.gz: d95da2805b53dafd174bb83fce7cf29cc2f13b5e8543bfa144d424e679aba701
+  metadata.gz: 240bc1a55d3955c734d79946868b5e878cacfa354f7b0a843b72f78c26a85c83
+  data.tar.gz: 23ccc7e91c0da1ea522e5c8a71cd4522478aa1c73ff0e9ee6f61e42b26f9955c
 SHA512:
-  metadata.gz: 14ce31badc6ae1eae1f51161a806354fcaea6b2d39197498766b4cefa2022565410f7fc745adfbaf0d51b68d67454460f3aabab2a94444dd377a93193d0465b2
-  data.tar.gz: 573dd6b5ae3bcfa0948176a86561c080a860d72634e1800b750554a694e17a17890a31492e2702b38ced8444b5725586bfcca6cb23109c968748edeb509bcf12
+  metadata.gz: 3ae2cda69cc099ad24a47aa4125ee10db96eb8186e261125f1e56ad6f4f2d805888d02d9eee92d48d18eab49d628918fef4e33234edc48ddb4ecb402d4518207
+  data.tar.gz: 65ee70a4b17944880979e71d1abee756a5f398f48cb048b575afbe4a0412f91d993ec97723c2b10d472ceafd405d7d013480824702c2a5db11e23f6eacb7f69a

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/core.rb

@@ -75,7 +75,7 @@ module Timescaledb
 
           scope :yesterday, -> { where("DATE(#{time_column}) = ?", Date.yesterday.in_time_zone.to_date) }
           scope :today, -> { where("DATE(#{time_column}) = ?", Date.today.in_time_zone.to_date) }
-          scope :last_hour, -> { where("#{time_column} > ?", 1.hour.ago.in_time_zone) }
+          scope :last_hour, -> { where("#{time_column} between ? and ?", 1.hour.ago.in_time_zone, Time.now.end_of_hour.in_time_zone) }
         end
 
         def normalize_hypertable_options

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,43 @@
+require 'singleton'
+
+module Timescaledb
+  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
+
+    private
+
+    def connection
+      @connection ||= PG.connect(@config)
+    end
+  end
+end

data/lib/timescaledb/connection_handling.rb

@@ -0,0 +1,16 @@
+module Timescaledb
+  class ConnectionNotEstablishedError < StandardError; end
+
+  # @param [String] config The postgres connection string.
+  def establish_connection(config)
+    Connection.instance.config = config
+  end
+  module_function :establish_connection
+
+  def connection
+    raise ConnectionNotEstablishedError.new unless Connection.instance.connected?
+
+    Connection.instance
+  end
+  module_function :connection
+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/quoting.rb

@@ -0,0 +1,12 @@
+module Timescaledb
+  class Database
+    module Quoting
+      # Quotes given value and escapes single quote and backslash characters.
+      #
+      # @return [String] The given value between quotes
+      def quote(value)
+        "'#{value.gsub("\\", '\&\&').gsub("'", "''")}'"
+      end
+    end
+  end
+end

data/lib/timescaledb/database/schema_statements.rb

@@ -0,0 +1,246 @@
+module Timescaledb
+  class Database
+    module SchemaStatements
+      # @see https://docs.timescale.com/api/latest/hypertable/create_hypertable/#create_hypertable
+      #
+      # @param [String] relation The identifier of the table to convert to hypertable
+      # @param [String] time_column_name The name of the column containing time values as well as the primary column to partition by
+      # @param [Hash] options The optional arguments
+      # @return [String] The create_hypertable SQL statement
+      def create_hypertable_sql(relation, time_column_name, **options)
+        options.transform_keys!(&:to_sym)
+
+        partitioning_column = options.delete(:partitioning_column)
+        number_partitions = options.delete(:number_partitions)
+
+        arguments  = [quote(relation), quote(time_column_name)]
+        arguments += [quote(partitioning_column), number_partitions] if partitioning_column && number_partitions
+        arguments += create_hypertable_options_to_named_notation_sql(options)
+
+        "SELECT create_hypertable(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/compression/alter_table_compression/#alter-table-compression
+      #
+      # @param [String] hypertable The name of the hypertable to enable compression
+      # @param [Hash] options The optional arguments
+      # @return [String] The ALTER TABLE SQL to enable compression
+      def enable_hypertable_compression_sql(hypertable, **options)
+        options.transform_keys!(&:to_sym)
+
+        compress_orderby = options.delete(:compress_orderby)
+        compress_segmentby = options.delete(:compress_segmentby)
+
+        arguments = ['timescaledb.compress']
+        arguments << "timescaledb.compress_orderby = #{quote(compress_orderby)}" if compress_orderby
+        arguments << "timescaledb.compress_segmentby = #{quote(compress_segmentby)}" if compress_segmentby
+
+        "ALTER TABLE #{hypertable} SET (#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/compression/alter_table_compression/#alter-table-compression
+      #
+      # @param [String] hypertable The name of the hypertable to disable compression
+      # @return [String] The ALTER TABLE SQL to disable compression
+      def disable_hypertable_compression_sql(hypertable)
+        "ALTER TABLE #{hypertable} SET (timescaledb.compress = FALSE);"
+      end
+
+      # @see https://docs.timescale.com/api/latest/compression/add_compression_policy/#add_compression_policy
+      #
+      # @param [String] hypertable The name of the hypertable or continuous aggregate to create the policy for
+      # @param [String] compress_after The age after which the policy job compresses chunks
+      # @param [Hash] options The optional arguments
+      # @return [String] The add_compression_policy SQL statement
+      def add_compression_policy_sql(hypertable, compress_after, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable), interval_to_sql(compress_after)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT add_compression_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/compression/remove_compression_policy/#remove_compression_policy
+      #
+      # @param [String] hypertable The name of the hypertable to remove the policy from
+      # @param [Hash] options The optional arguments
+      # @return [String] The remove_compression_policy SQL statement
+      def remove_compression_policy_sql(hypertable, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT remove_compression_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/data-retention/add_retention_policy/#add_retention_policy
+      #
+      # @param [String] hypertable The name of the hypertable to create the policy for
+      # @param [String] drop_after The age after which the policy job drops chunks
+      # @param [Hash] options The optional arguments
+      # @return [String] The add_retention_policy SQL statement
+      def add_retention_policy_sql(hypertable, drop_after, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable), interval_to_sql(drop_after)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT add_retention_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/data-retention/remove_retention_policy/#remove_retention_policy
+      #
+      # @param [String] hypertable The name of the hypertable to remove the policy from
+      # @param [Hash] options The optional arguments
+      # @return [String] The remove_retention_policy SQL statement
+      def remove_retention_policy_sql(hypertable, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT remove_retention_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/hypertable/add_reorder_policy/#add_reorder_policy
+      #
+      # @param [String] hypertable The name of the hypertable to create the policy for
+      # @param [String] index_name The existing index by which to order rows on disk
+      # @param [Hash] options The optional arguments
+      # @return [String] The add_reorder_policy SQL statement
+      def add_reorder_policy_sql(hypertable, index_name, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable), quote(index_name)]
+        arguments += policy_options_to_named_notation_sql(options)
+
+        "SELECT add_reorder_policy(#{arguments.join(', ')});"
+      end
+
+      # @see https://docs.timescale.com/api/latest/hypertable/remove_reorder_policy/#remove_reorder_policy
+      #
+      # @param [String] hypertable The name of the hypertable to remove the policy from
+      # @param [Hash] options The optional arguments
+      # @return [String] The remove_retention_policy SQL statement
+      def remove_reorder_policy_sql(hypertable, **options)
+        options.transform_keys!(&:to_sym)
+
+        arguments = [quote(hypertable)]
+        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 policy_options_to_named_notation_sql(options)
+        options.map do |option, value|
+          case option
+          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 create_hypertable_options_to_named_notation_sql(options)
+        options.map do |option, value|
+          case option
+          when :chunk_time_interval
+            named_notation_sql(name: option, value: interval_to_sql(value))
+          when :if_not_exists, :create_default_indexes, :migrate_data, :distributed
+            named_notation_sql(name: option, value: boolean_to_sql(value))
+          when :partitioning_func, :associated_schema_name,
+               :associated_table_prefix, :time_partitioning_func
+            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

@@ -0,0 +1,20 @@
+module Timescaledb
+  class Database
+    module Types
+      # @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
+
+      # @param [String] boolean The boolean value
+      # @return [String]
+      def boolean_to_sql(boolean)
+        quote(boolean ? 'TRUE' : 'FALSE')
+      end
+    end
+  end
+end

data/lib/timescaledb/database.rb

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