activerecord-materialized 0.1.0 → 0.2.0

data/lib/activerecord/materialized/registry.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -9,64 +8,75 @@ module ActiveRecord
     # @api private
     class Registry
       class << self
-        extend T::Sig
-
-        sig { params(view_class: ViewClass).void }
         def register(view_class)
           views[view_class.view_key] = view_class
         end
 
-        sig { params(view_class: ViewClass).void }
         def unregister(view_class)
           views.delete(view_class.view_key)
         end
 
-        sig { params(key: T.any(String, Symbol)).returns(T.nilable(ViewClass)) }
         def find(key)
           views[key.to_s]
         end
 
-        sig { params(class_name: String).returns(T.nilable(ViewClass)) }
         def for_class_name(class_name)
           all.find { |view| view.name == class_name }
         end
 
-        sig { returns(T::Array[ViewClass]) }
         def all
           views.values
         end
 
         # Incremental pass over every registered view; rebuild_all! for a full one.
-        sig { returns(T::Array[RefreshResult]) }
         def refresh_all!
           all.map(&:refresh!)
         end
 
-        sig { returns(T::Array[RefreshResult]) }
+        # Registered views that need maintenance — dirty, never refreshed, or past max_staleness.
+        # The single stale-view selection shared by the periodic refresh/reconcile paths, their
+        # rake tasks, and the job fan-out (ActiveRecord::Materialized.enqueue_stale_*!).
+        def stale_views
+          all.select(&:stale?)
+        end
+
         def refresh_stale!
-          all.select(&:stale?).map(&:refresh!)
+          stale_views.map(&:refresh!)
         end
 
-        sig { returns(T::Array[RefreshResult]) }
         def rebuild_all!
           all.map { |view| view.rebuild!(confirm: true) }
         end
 
-        sig { returns(T::Array[T.nilable(RefreshResult)]) }
+        def reconcile_all!(mode: :checksum, sample: nil)
+          all.map { |view| reconcile_view(view, mode: mode, sample: sample) }
+        end
+
+        def reconcile_stale!(mode: :checksum, sample: nil)
+          stale_views.map { |view| reconcile_view(view, mode: mode, sample: sample) }
+        end
+
         def warm_up_all!
           all.map(&:warm_up!)
         end
 
-        sig { void }
         def reset!
           @views = {}
         end
 
         private
 
-        sig { returns(T::Hash[String, ViewClass]) }
+        # Reconcile one view, isolating a failure so a single unhealthy view (e.g. a
+        # transiently broken source relation) can't abort the scheduled backstop for
+        # the rest of the fleet; the error is reported on the result, not swallowed.
+        def reconcile_view(view, mode:, sample:)
+          view.reconcile!(mode: mode, sample: sample)
+        rescue StandardError => e
+          ReconcileResult.new(view_name: view.view_key, mode: mode, repaired_keys: [], error: e.message)
+        end
+
         def views
-          @views ||= T.let({}, T.nilable(T::Hash[String, ViewClass]))
+          @views ||= {}
         end
       end
     end

data/lib/activerecord/materialized/relation_cache_writer.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,20 +6,15 @@ module ActiveRecord
     #
     # @api private
     class RelationCacheWriter
-      extend T::Sig
-
-      sig { params(view_class: T.class_of(::ActiveRecord::Base)).void }
       def initialize(view_class)
         @view_class = view_class
       end
 
-      sig { params(relation: ::ActiveRecord::Relation).returns(Integer) }
       def bootstrap!(relation)
         CacheTableSchema.ensure_table!(view_class, relation)
         replace_all!(relation)
       end
 
-      sig { params(relation: ::ActiveRecord::Relation).returns(Integer) }
       def replace_all!(relation)
         view_class.transaction do
           view_class.delete_all
@@ -29,107 +23,79 @@ module ActiveRecord
         cache_row_count
       end
 
-      sig do
-        params(
-          relation: ::ActiveRecord::Relation,
-          key_tuples: T::Array[T::Array[String]],
-          full_partition: T::Boolean
-        ).returns(Integer)
-      end
-      def replace_partitions!(relation, key_tuples:, full_partition:)
+      # Scoped in-place maintenance: delete + re-insert only the affected partitions. A full recompute
+      # goes through +atomic_swap!+ instead (see IncrementalMaintainer#recompute_all!), so this only
+      # ever handles a bounded set of partition keys.
+      def replace_partitions!(relation, key_tuples:)
         view_class.transaction do
-          if full_partition
-            view_class.delete_all
-          else
-            delete_partitions!(key_tuples)
-          end
+          delete_partitions!(key_tuples)
           insert_rows!(relation)
         end
         cache_row_count
       end
 
-      sig { params(relation: ::ActiveRecord::Relation).returns(Integer) }
       def atomic_swap!(relation)
-        connection = view_class.connection
         temp_table = refresh_temp_table_name
         old_table = refresh_old_table_name
 
         populate_temp_table!(temp_table, relation)
-        swap_tables!(connection, temp_table, old_table)
+        TableSwap.new(view_class).swap!(temp_table, old_table)
 
         view_class.reset_column_information
         cache_row_count
       end
 
-      sig { params(temp_table: String, relation: ::ActiveRecord::Relation).void }
       def populate_temp_table!(temp_table, relation)
-        CacheTableSchema.create_table!(T.cast(view_class, ViewClass), temp_table, relation)
+        CacheTableSchema.create_table!(view_class, temp_table, relation)
         temp_model = temporary_model(temp_table)
         self.class.new(temp_model).replace_all!(relation)
       end
 
-      sig { params(connection: Connection, temp_table: String, old_table: String).void }
-      def swap_tables!(connection, temp_table, old_table)
-        connection.transaction do
-          connection.rename_table(view_class.table_name, old_table) if view_class.table_exists?
-          connection.rename_table(temp_table, view_class.table_name)
-          connection.drop_table(old_table, if_exists: true)
-        end
-      end
-
-      sig { returns(String) }
       def refresh_temp_table_name
         "#{view_class.table_name}_refresh_#{SecureRandom.hex(4)}"
       end
 
-      sig { returns(String) }
       def refresh_old_table_name
         "#{view_class.table_name}_old_#{SecureRandom.hex(4)}"
       end
 
       private
 
-      sig { returns(T.class_of(::ActiveRecord::Base)) }
       attr_reader :view_class
 
       # Count straight from the cache table, bypassing the View read routing
       # (during a rebuild the view is not warm yet, so a routed count would read
       # through to the source).
-      sig { returns(Integer) }
       def cache_row_count
-        T.unsafe(view_class).unscoped.count
+        view_class.unscoped.count
       end
 
-      sig { params(key_tuples: T::Array[T::Array[String]]).void }
       def delete_partitions!(key_tuples)
-        materialized_view = T.cast(view_class, ViewClass)
+        materialized_view = view_class
         materialized_view.view_definition.partition_scope_on(view_class, key_tuples).delete_all
       end
 
       # INSERT ... SELECT entirely in the database; the result set never crosses
       # into Ruby. Cache columns share the relation's projection order, so the
       # SELECT list maps onto them positionally.
-      sig { params(relation: ::ActiveRecord::Relation).void }
       def insert_rows!(relation)
         columns = view_class.column_names - ["id"]
         return if columns.empty?
 
-        T.unsafe(view_class.connection).execute(insert_select_sql(relation, columns))
+        view_class.connection.execute(insert_select_sql(relation, columns))
       end
 
-      sig { params(relation: ::ActiveRecord::Relation, columns: T::Array[String]).returns(String) }
       def insert_select_sql(relation, columns)
         manager = Arel::InsertManager.new
         manager.into(view_class.arel_table)
-        T.unsafe(manager).columns.concat(columns.map { |name| view_class.arel_table[name] })
+        manager.columns.concat(columns.map { |name| view_class.arel_table[name] })
         manager.select(Arel.sql(relation.to_sql))
         manager.to_sql
       end
 
-      sig { params(table_name: String).returns(T.class_of(::ActiveRecord::Base)) }
       def temporary_model(table_name)
         klass = Class.new(::ActiveRecord::Base)
-        T.unsafe(klass).table_name = table_name
+        klass.table_name = table_name
         klass
       end
     end

data/lib/activerecord/materialized/schema_verifier.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -6,18 +5,14 @@ module ActiveRecord
     # Raises when a provisioned cache table no longer matches the columns its
     # source relation projects (drift); never alters the table or rebuilds data.
     class SchemaVerifier
-      extend T::Sig
-
       # Raised when a cache table no longer matches the columns its source relation projects.
       class SchemaDriftError < StandardError; end
 
-      sig { params(view_class: ViewClass).void }
       def initialize(view_class)
         @view_class = view_class
       end
 
       # An unprovisioned cache table is absent, not drifted, so this is a no-op.
-      sig { void }
       def verify!
         return unless @view_class.table_exists?
 
@@ -28,7 +23,6 @@ module ActiveRecord
         Kernel.raise SchemaDriftError, drift_message(missing, extra)
       end
 
-      sig { returns(T::Boolean) }
       def drifted?
         verify!
         false
@@ -38,19 +32,16 @@ module ActiveRecord
 
       private
 
-      sig { returns(T::Array[String]) }
       def expected_columns
         CacheTableSchema
           .column_definitions(@view_class.connection, @view_class.resolved_source)
           .map(&:name).sort
       end
 
-      sig { returns(T::Array[String]) }
       def actual_columns
         @view_class.connection.columns(@view_class.table_name).map(&:name).reject { |name| name == "id" }.sort
       end
 
-      sig { params(missing: T::Array[String], extra: T::Array[String]).returns(String) }
       def drift_message(missing, extra)
         details = []
         details << "missing columns: #{missing.join(', ')}" if missing.any?

data/lib/activerecord/materialized/source_watermark.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Per-partition CDC source watermarks: the max applied +source_ts+ for each (view, partition).
+    # Two jobs, both opt-in via a +source_ts+ on {Materialized.ingest_change}:
+    #
+    # - **Suppression** — a redelivered or out-of-order change whose watermark is `<` the partition's
+    #   applied watermark is provably redundant (the cache already reflects a strictly-newer state), so
+    #   its recompute is skipped. A change at the *same* watermark still applies: a coarse (e.g.
+    #   second-granular) +source_ts+ such as Debezium's MySQL +source.ts_ms+ can tie two distinct
+    #   commits, so an equal value is not treated as a redelivery. Best-effort and **reconcile-backed**:
+    #   the watermark advances at ingest, so a crash before the recompute can over-suppress a partition
+    #   until reconciliation (#64) heals it — an optimization over always-recompute, never a correctness
+    #   substitute.
+    # - **Observability** — {#oldest} reports the view's most-behind partition watermark, so a caller can
+    #   compute freshness/lag against its own source clock (in the same unit as +source_ts+).
+    #
+    # Only the scoped-recompute path (a +change_source :none+ CDC-fed view) carries a watermark; a full
+    # recompute (no partition key) is never suppressed. +source_ts+ must be monotonic (non-decreasing)
+    # per partition (e.g. a Debezium +source.ts_ms+ or a per-key Kafka offset); ties are safe (only a
+    # strictly-older value is suppressed). Mirrors {PartitionState}'s per-partition store.
+    #
+    # @api private
+    class SourceWatermark < PartitionKeyedStore
+      # Drop the delta's partitions that already applied a strictly-newer +source_ts+, and advance the
+      # watermark for the survivors — a change at the same +source_ts+ still applies, so a distinct write
+      # sharing a coarse (e.g. second-granular) timestamp is never suppressed. A full-partition delta
+      # (no key) is returned unchanged — it can't be scoped.
+      #
+      # @return [MaintenanceDelta, nil] the surviving partitions, or nil when every one was suppressed
+      def suppress(source_ts, delta)
+        return delta if delta.full_partition?
+
+        ensure_table!
+        current = current_watermarks(delta.key_tuples) # one read for the whole decision
+        fresh = delta.key_tuples.reject { |tuple| (ts = current[serialize(tuple)]) && ts > source_ts }
+        return nil if fresh.empty?
+
+        advance!(fresh, source_ts)
+        MaintenanceDelta.scoped(fresh)
+      end
+
+      # The oldest applied watermark across the view's partitions that have received a watermarked
+      # change (its most-behind such partition), or nil when none have. Subtract from the source clock
+      # (same unit as +source_ts+) for lag. A partition maintained only via widen-to-full changes records
+      # no watermark and so is not reflected here; a stalled *stream* (no events arriving) is a
+      # pipeline-level concern, monitored at the consumer. A read only — never provisions the table.
+      #
+      # @return [Integer, nil]
+      def oldest
+        return nil unless record_class.table_exists?
+
+        scope.minimum(:source_ts)
+      end
+
+      private
+
+      # The stored watermark for each of +tuples+, in one query, as { serialized_key => source_ts }.
+      def current_watermarks(tuples)
+        scope.where(partition_key: tuples.map { |tuple| serialize(tuple) }).pluck(:partition_key, :source_ts).to_h
+      end
+
+      # Advance each partition's watermark to source_ts. +create_or_find_by+ absorbs a concurrent
+      # first-insert (the unique index would otherwise raise RecordNotUnique); the guarded +update!+ only
+      # moves a watermark forward. Advancement is best-effort (like the feature): a concurrent advance
+      # read as stale could briefly regress a watermark, at worst causing a later redundant recompute
+      # (never wrong data) — reconciliation is the backstop.
+      def advance!(tuples, source_ts)
+        tuples.each do |tuple|
+          key = serialize(tuple)
+          row = record_class.create_or_find_by(view_name: view_key, partition_key: key) do |record|
+            record.source_ts = source_ts
+          end
+          row.update!(source_ts: source_ts) if row.source_ts < source_ts
+        end
+      end
+
+      def record_class
+        SourceWatermarkRecord
+      end
+
+      def table_name
+        ::ActiveRecord::Materialized.configuration.source_watermark_table_name
+      end
+
+      def define_columns(table)
+        table.bigint :source_ts, null: false
+        table.timestamps
+      end
+    end
+  end
+end

data/lib/activerecord/materialized/source_watermark_record.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # ActiveRecord model backing the CDC source-watermark table — the max applied +source_ts+ per
+    # (view, partition). Used to suppress stale/out-of-order CDC events and to report a view's
+    # freshness. Uses {ConfigurableTableName}'s dynamic resolution so a host app can rename the table.
+    #
+    # @api private
+    class SourceWatermarkRecord < ::ActiveRecord::Base
+      include ConfigurableTableName
+
+      configurable_table_name { ::ActiveRecord::Materialized.configuration.source_watermark_table_name }
+    end
+  end
+end

data/lib/activerecord/materialized/summary_delta.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -8,46 +7,33 @@ module ActiveRecord
     #
     # @api private
     class SummaryDelta
-      extend T::Sig
-
-      KeyTuple = T.type_alias { T::Array[T.untyped] }
-      Columns = T.type_alias { T::Hash[String, Numeric] }
-      Buckets = T.type_alias { T::Hash[KeyTuple, Columns] }
-
-      sig { returns(Buckets) }
       attr_reader :buckets
 
-      sig { params(buckets: Buckets).void }
       def initialize(buckets = {})
         @buckets = buckets
       end
 
-      sig { params(key_tuple: KeyTuple, column: String, amount: Numeric).void }
       def add(key_tuple, column, amount)
         bucket = (@buckets[key_tuple] ||= {})
         bucket[column] = (bucket[column] || 0) + amount
       end
 
-      sig { returns(T::Boolean) }
       def empty?
         @buckets.empty?
       end
 
       # Number of distinct partitions (buckets) accumulated so far.
-      sig { returns(Integer) }
       def tracked_partition_count
         @buckets.size
       end
 
       # Drops net-zero columns (no-op changes) and the partitions left empty.
-      sig { returns(SummaryDelta) }
       def prune!
         @buckets.each_value { |columns| columns.reject! { |_column, amount| amount.zero? } }
         @buckets.reject! { |_key_tuple, columns| columns.empty? }
         self
       end
 
-      sig { params(other: SummaryDelta).returns(SummaryDelta) }
       def merge(other)
         merged = SummaryDelta.new(@buckets.transform_values(&:dup))
         other.buckets.each do |key_tuple, columns|
@@ -57,17 +43,15 @@ module ActiveRecord
       end
 
       # A list of `"key" => tuple, "columns" => …` entries so array keys survive JSON.
-      sig { returns(T::Hash[String, T.untyped]) }
       def serialize
         { "summary" => @buckets.map { |key_tuple, columns| { "key" => key_tuple, "columns" => columns } } }
       end
 
-      sig { params(payload: T.nilable(T::Hash[String, T.untyped])).returns(T.nilable(SummaryDelta)) }
       def self.deserialize(payload)
         rows = payload && payload["summary"]
         return nil if rows.nil?
 
-        buckets = T.let({}, Buckets)
+        buckets = {}
         rows.each { |row| buckets[row.fetch("key")] = row.fetch("columns") }
         new(buckets)
       end

data/lib/activerecord/materialized/summary_delta_builder.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,16 +6,12 @@ module ActiveRecord
     # snapshot and adding the "after" uniformly handles inserts, deletes, in-place
     # updates, and group-key changes (a move between partitions).
     class SummaryDeltaBuilder
-      extend T::Sig
-
-      sig { params(change: WriteChange, analysis: AggregateAnalysis, group_columns: T::Array[String]).void }
       def initialize(change, analysis, group_columns)
         @change = change
         @analysis = analysis
         @group_columns = group_columns
       end
 
-      sig { returns(SummaryDelta) }
       def build
         delta = SummaryDelta.new
         apply!(delta, @change.before, -1) unless @change.before.empty?
@@ -26,7 +21,6 @@ module ActiveRecord
 
       private
 
-      sig { params(delta: SummaryDelta, snapshot: T::Hash[String, T.untyped], sign: Integer).void }
       def apply!(delta, snapshot, sign)
         key_tuple = key_tuple(snapshot)
         return if key_tuple.nil?
@@ -37,17 +31,15 @@ module ActiveRecord
         end
       end
 
-      sig { params(column: AggregateAnalysis::Column, snapshot: T::Hash[String, T.untyped]).returns(Numeric) }
       def contribution_for(column, snapshot)
         case column.function
         when :count_star then 1
-        when :count then snapshot[T.must(column.attribute)].nil? ? 0 : 1
-        when :sum then snapshot.fetch(T.must(column.attribute), 0) || 0
+        when :count then snapshot[column.attribute].nil? ? 0 : 1
+        when :sum then snapshot.fetch(column.attribute, 0) || 0
         else 0
         end
       end
 
-      sig { params(snapshot: T::Hash[String, T.untyped]).returns(T.nilable(SummaryDelta::KeyTuple)) }
       def key_tuple(snapshot)
         return nil unless @group_columns.all? { |column| snapshot.key?(column) }
 

data/lib/activerecord/materialized/table_model_registry.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -8,28 +7,22 @@ module ActiveRecord
     # @api private
     class TableModelRegistry
       class << self
-        extend T::Sig
-
-        sig { params(model_class: T.class_of(::ActiveRecord::Base)).void }
         def register(model_class)
           return if model_class.abstract_class?
 
           explicit[model_class.table_name] = model_class
         end
 
-        sig { params(table_name: String).returns(T.nilable(T.class_of(::ActiveRecord::Base))) }
         def resolve(table_name)
           explicit[table_name] || find_descendant(table_name)
         end
 
         private
 
-        sig { returns(T::Hash[String, T.class_of(::ActiveRecord::Base)]) }
         def explicit
-          @explicit ||= T.let({}, T.nilable(T::Hash[String, T.class_of(::ActiveRecord::Base)]))
+          @explicit ||= {}
         end
 
-        sig { params(table_name: String).returns(T.nilable(T.class_of(::ActiveRecord::Base))) }
         def find_descendant(table_name)
           ::ActiveRecord::Base.descendants.find do |model_class|
             !model_class.abstract_class? && model_class.table_name == table_name

data/lib/activerecord/materialized/table_swap.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Swaps a view's cache table for a freshly-built temp table, atomically per the
+    # engine's DDL semantics: a transaction on SQLite/Postgres (transactional DDL),
+    # or a single multi-table RENAME TABLE on MySQL — whose DDL auto-commits, so a
+    # transaction could not make two separate renames atomic. Extracted from
+    # RelationCacheWriter, which builds the temp table and delegates the swap here.
+    #
+    # @api private
+    class TableSwap
+      def initialize(view_class)
+        @view_class = view_class
+      end
+
+      # Replace the view table with temp_table; the displaced view table becomes
+      # old_table and is dropped. Indexes on the displaced table are preserved: the freshly built
+      # temp table only carries the schema-default index, so any index a user added to the cache table
+      # (or the default one, on a table built before it existed) would otherwise be lost with the
+      # dropped old table — unlike PostgreSQL's REFRESH MATERIALIZED VIEW, which keeps them.
+      def swap!(temp_table, old_table)
+        preserved = current_indexes
+        if connection.supports_ddl_transactions?
+          # SQLite/Postgres: rename + index restore commit together, so readers only ever see the old
+          # table or the fully-indexed new one.
+          connection.transaction do
+            rename_in_place!(temp_table, old_table)
+            restore_missing_indexes!(preserved)
+          end
+        else
+          # MySQL/MariaDB: RENAME TABLE auto-commits (a transaction can't make it atomic with the
+          # index rebuild), so the restore runs after. A crash in this window leaves the new table live
+          # but missing the preserved indexes until the next rebuild! — degraded read/maintenance
+          # performance, never data loss or an empty table (the rename itself is atomic).
+          atomic_rename!(temp_table, old_table)
+          restore_missing_indexes!(preserved)
+        end
+      end
+
+      private
+
+      attr_reader :view_class
+
+      def connection = view_class.connection
+
+      # The indexes on the current live cache table (empty on first build, when there is none), captured
+      # before the swap so they can be re-created on the table that replaces it.
+      def current_indexes
+        return [] unless view_class.table_exists?
+
+        connection.indexes(view_class.table_name)
+      end
+
+      # Re-create every preserved index the swapped-in table does not already carry (matched on full
+      # signature, so the temp table's default index isn't duplicated). Index names are free again now
+      # that the old table is dropped, so each keeps its original name.
+      def restore_missing_indexes!(preserved)
+        existing = connection.indexes(view_class.table_name)
+        preserved.each do |index|
+          next if existing.any? { |candidate| same_index?(candidate, index) }
+
+          connection.add_index(view_class.table_name, index.columns, **index_options(index))
+        end
+      end
+
+      def same_index?(one, other)
+        one.columns == other.columns && one.unique == other.unique && one.where == other.where &&
+          one.orders == other.orders && one.using == other.using
+      end
+
+      def index_options(index)
+        options = { name: index.name, unique: index.unique }
+        options[:where] = index.where if index.where
+        options[:using] = index.using if index.using
+        options[:order] = index.orders if index.orders.present?
+        options
+      end
+
+      def rename_in_place!(temp_table, old_table)
+        connection.rename_table(view_class.table_name, old_table) if view_class.table_exists?
+        connection.rename_table(temp_table, view_class.table_name)
+        connection.drop_table(old_table, if_exists: true)
+      end
+
+      # MySQL: `RENAME TABLE current TO old, temp TO current` swaps in one atomic
+      # statement (a single metadata lock over all tables), then the old table is
+      # dropped. On first build there is no current table, so just rename temp in.
+      def atomic_rename!(temp_table, old_table)
+        view = view_class.table_name
+        unless view_class.table_exists?
+          connection.rename_table(temp_table, view)
+          return
+        end
+
+        connection.execute(rename_sql(view => old_table, temp_table => view))
+        connection.drop_table(old_table, if_exists: true)
+      end
+
+      def rename_sql(pairs)
+        clauses = pairs.map { |from, to| "#{connection.quote_table_name(from)} TO #{connection.quote_table_name(to)}" }
+        "RENAME TABLE #{clauses.join(', ')}"
+      end
+    end
+  end
+end