elasticsearch_record 1.1.0 → 1.2.0

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/table_setting_definition.rb

@@ -10,7 +10,7 @@ module ActiveRecord
         include ActiveModel::Validations
 
         # exclude settings, that are provided through the API but are not part of the index-settings API
-        IGNORE_NAMES = ['provided_name', 'creation_date', 'uuid', 'version'].freeze
+        IGNORE_NAMES = ['provided_name', 'creation_date', 'uuid', 'version','routing.allocation.initial_recovery','resize'].freeze
 
         # available setting names
         # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html#index-modules-settings
@@ -33,7 +33,8 @@ module ActiveRecord
                          'max_docvalue_fields_search', 'max_script_fields', 'max_ngram_diff', 'max_shingle_diff',
                          'max_refresh_listeners', 'analyze.max_token_count', 'highlight.max_analyzed_offset',
                          'max_terms_count', 'max_regex_length', 'query.default_field', 'routing.allocation.enable',
-                         'routing.rebalance.enable', 'gc_deletes', 'default_pipeline', 'final_pipeline', 'hidden'].freeze
+                         'routing.rebalance.enable', 'gc_deletes', 'default_pipeline', 'final_pipeline',
+                         'hidden', 'blocks'].freeze
 
         VALID_NAMES = (FINAL_NAMES + STATIC_NAMES + DYNAMIC_NAMES).freeze
 
@@ -43,6 +44,9 @@ module ActiveRecord
 
         # validations
         validates_presence_of :name
+
+        # disable validation for name - maybe future updates of Elasticsearch have other names.
+        # To not be hooked on those possible changes we disable the validation
         validate :_validate_name
         validate :_validate_final_name
         validate :_validate_static_name
@@ -78,7 +82,8 @@ module ActiveRecord
         end
 
         def static?
-          !dynamic?
+          @static = flat_names.all? { |flat_name| self.class.match_static_names?(flat_name) } if @static.nil?
+          @static
         end
 
         def dynamic?
@@ -100,7 +105,7 @@ module ActiveRecord
         end
 
         def _validate_static_name
-          return true if dynamic?
+          return true unless static?
           return true if ['missing', 'close'].include?(_table_status)
 
           invalid!("is static - this setting can only be changed on a closed index!", :name)

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/update_table_definition.rb

@@ -14,7 +14,7 @@ module ActiveRecord
         COMPOSITE_DEFINITIONS = [
           AddMappingDefinition,
           ChangeMappingDefinition,
-
+          ChangeMetaDefinition,
           AddSettingDefinition,
           DeleteAliasDefinition
         ].freeze
@@ -29,10 +29,29 @@ module ActiveRecord
         alias :mapping :add_mapping
         alias :column :add_mapping
 
+        def change_meta(name, value, **options)
+          load_meta_definition!
+
+          define! ChangeMetaDefinition, new_meta_definition(name, value, **options)
+        end
+
+        def delete_meta(name, **options)
+          load_meta_definition!
+
+          define! ChangeMetaDefinition, new_meta_definition(name, nil, **options)
+        end
+
         def change_mapping(name, type, if_exists: false, **options, &block)
           return if if_exists && !mapping_exists?(self.name, name, type)
 
-          define! ChangeMappingDefinition, new_mapping_definition(name, type, **options, &block)
+          mapping = new_mapping_definition(name, type, **options, &block)
+          define! ChangeMappingDefinition, mapping
+
+          # check if the mapping is assigned as primary_key
+          if mapping.primary_key?
+            change_meta :primary_key, mapping.name
+            change_meta(:auto_increment, mapping.auto_increment) if mapping.auto_increment?
+          end
         end
 
         alias :change_column :change_mapping
@@ -56,6 +75,7 @@ module ActiveRecord
 
           define! ChangeMappingDefinition, new_mapping_definition(name, mapping['type'], **options, &block)
         end
+
         alias :change_mapping_attribute :change_mapping_attributes
 
         def add_setting(name, value, if_not_exists: false, **options, &block)
@@ -105,6 +125,17 @@ module ActiveRecord
 
         private
 
+        # loads existing meta definitions from table_mappings
+        def load_meta_definition!
+          return if @load_meta_definition
+          @load_meta_definition = true
+
+
+          table_metas(self.name).each do |name, value|
+            define! ChangeMetaDefinition, new_meta_definition(name, value)
+          end
+        end
+
         def define!(klass, item)
           @definitions        ||= {}
           @definitions[klass] ||= []
@@ -119,11 +150,6 @@ module ActiveRecord
           clear_state!
         end
 
-        def _after_assign
-          # run the same content as +_after_exec+, but only if the assignment failed
-          _after_exec if failed?
-        end
-
         def _after_exec
           # reopen the table again
           open_table(self.name) if _toggle_table_status?
@@ -131,6 +157,8 @@ module ActiveRecord
           # reset table state
           clear_state!
         end
+        alias :_rescue_assign :_after_exec
+        alias :_rescue_exec :_after_exec
 
         def _toggle_table_status?
           @toggle_table_status = (force? && state[:status] == 'open') if @toggle_table_status.nil?
@@ -141,9 +169,6 @@ module ActiveRecord
         def _exec
           return unless definitions.any?
 
-          # check, if the table should be closed before executing the queries
-          close_table(self.name) if opts[:close] == true
-
           definitions.each do |klass, items|
             # check if the provided definition klass is a composite definition
             executable_definitions = if COMPOSITE_DEFINITIONS.include?(klass)
@@ -159,10 +184,10 @@ module ActiveRecord
             end
           end
 
-          open_table(self.name) if opts[:close] == true
-
-          # cleanup definitions
+          # cleanup executed definitions
           @definitions = {}
+
+          true
         end
 
         def _to_composite_log(klass)

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions.rb

@@ -9,6 +9,7 @@ module ActiveRecord
       # mapping definitions
       AddMappingDefinition    = Struct.new(:items) # composite
       ChangeMappingDefinition = Struct.new(:items) # composite
+      ChangeMetaDefinition    = Struct.new(:items) # composite
 
       # setting definitions
       AddSettingDefinition    = Struct.new(:items) # composite
@@ -30,8 +31,10 @@ require 'active_record/connection_adapters/elasticsearch/schema_definitions/colu
 
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_alias_definition'
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_mapping_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_meta_definition'
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_setting_definition'
 
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_definition'
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/create_table_definition'
 require 'active_record/connection_adapters/elasticsearch/schema_definitions/update_table_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/clone_table_definition'

data/lib/active_record/connection_adapters/elasticsearch/schema_dumper.rb

@@ -6,8 +6,40 @@ module ActiveRecord
   module ConnectionAdapters
     module Elasticsearch
       class SchemaDumper < ActiveRecord::ConnectionAdapters::SchemaDumper # :nodoc:
+
+        def initialize(connection, options = {})
+          super
+
+          _expand_options!
+        end
+
         private
 
+        def _expand_options!
+          @options[:table_name_prefix] = @connection.table_name_prefix if @options[:table_name_prefix].blank?
+          @options[:table_name_suffix] = @connection.table_name_suffix if @options[:table_name_suffix].blank?
+        end
+
+        # overwrite the method to 'fix' a possible ActiveRecord bug:
+        # If a +table_name_prefix+ or +table_name_suffix+ was provided we also only want to dump those tables,
+        # which matches the prefix/suffix. So possible, environment-related tables will be ignored
+        # (e.g. if a '-development' as +table_name_suffix+ was provided ... )
+        def ignored?(table_name)
+          super(table_name) || ignored_table?(table_name)
+        end
+
+        # returns true if the provided table name does not match possible provided
+        # options +table_name_prefix+ or +table_name_suffix+.
+        def ignored_table?(table_name)
+          # if the table starts NOT with +prefix+ it must be ignored
+          return true if @options[:table_name_prefix].present? && !table_name.start_with?(@options[:table_name_prefix].to_s)
+
+          # if the table ends NOT with +suffix+ it must be ignored
+          return true if  @options[:table_name_suffix].present? && !table_name.end_with?(@options[:table_name_suffix].to_s)
+
+          false
+        end
+
         def table(table, stream, nested_blocks: false, **)
           begin
             self.table_name = table
@@ -21,6 +53,15 @@ module ActiveRecord
             tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
             tbl.print ", force: true do |t|"
 
+            # META
+            if (metas = definition.metas).present?
+              tbl.puts
+
+              metas.each do |meta|
+                tbl.puts "    t.meta #{meta.name.inspect}, #{format_attribute(meta.value)}"
+              end
+            end
+
             # ALIASES
             if (aliases = definition.aliases).present?
               tbl.puts

data/lib/active_record/connection_adapters/elasticsearch/schema_statements.rb

@@ -92,7 +92,7 @@ module ActiveRecord
                                     :dump_schema_information
 
           def assume_migrated_upto_version(version)
-            version = version.to_i
+            version  = version.to_i
             migrated = migration_context.get_all_versions
             versions = migration_context.migrations.map(&:version)
 
@@ -108,7 +108,7 @@ module ActiveRecord
               end
 
               # use a ActiveRecord syntax to create new versions
-              inserting.each {|iversion| schema_migration.create(version: iversion) }
+              inserting.each { |iversion| schema_migration.create(version: iversion) }
             end
 
             true
@@ -137,6 +137,14 @@ module ActiveRecord
             api(:indices, :get_mapping, { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA').dig(table_name, 'mappings')
           end
 
+          # returns a hash of all meta data by provided table_name (index).
+          # HINT: +_meta+ is resolved from the table mappings
+          # @param [String] table_name
+          # @return [Hash]
+          def table_metas(table_name)
+            table_mappings(table_name).dig('_meta').presence || {}
+          end
+
           # returns a hash of all settings by provided table_name
           # @param [String] table_name
           # @param [Boolean] flat_settings (default: true)
@@ -223,7 +231,8 @@ module ActiveRecord
               meta:       field['meta'],
               virtual:    field['virtual'],
               fields:     field['fields'],
-              properties: field['properties']
+              properties: field['properties'],
+              enabled:    field['enabled']
             )
           end
 
@@ -239,15 +248,18 @@ module ActiveRecord
           # Returns a array of tables primary keys.
           # PLEASE NOTE: Elasticsearch does not have a concept of primary key.
           # The only thing that uniquely identifies a document is the index together with the +_id+.
-          # To not break the "ConnectionAdapters" concept we simulate this through the +meta+ attribute.
+          # To support this concept we simulate this through the +_meta+ field (from the index).
+          #
+          # As a alternative, the primary_key can also be provided through the mappings +meta+ field.
+          #
+          # see @ https://www.elastic.co/guide/en/elasticsearch/reference/8.5/mapping-meta-field.html
           # @see ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#primary_keys
           # @param [String] table_name
           def primary_keys(table_name)
-            column_definitions(table_name)
-            # ActiveRecord::ConnectionAdapters::ElasticsearchAdapter::BASE_STRUCTURE
-              .select { |f| f['meta'] && f['meta']['primary_key'] == 'true' }
+            table_metas(table_name).dig('primary_key').presence || column_definitions(table_name).
+              select { |f| f['meta'] && f['meta']['primary_key'] == 'true' }.
               # only take the last found primary key (if no custom primary_key was provided this will return +_id+ )
-              .map { |f| f["name"] }[-1..-1]
+              map { |f| f["name"] }[-1..-1]
           end
 
           # Checks to see if the data source +name+ exists on the database.
@@ -307,6 +319,17 @@ module ActiveRecord
             column_exists?(table_name, mapping_name, type)
           end
 
+          # Checks to see if a meta +meta_name+ within a table +table_name+ exists on the database.
+          #
+          #   meta_exists?(:developers, 'class')
+          #
+          # @param [String] table_name
+          # @param [String,Symbol] meta_name
+          # @return [Boolean]
+          def meta_exists?(table_name, meta_name)
+            table_metas(table_name).keys.include?(meta_name.to_s)
+          end
+
           # overwrite original methods to provide a elasticsearch version
           def create_schema_dumper(options)
             ActiveRecord::ConnectionAdapters::Elasticsearch::SchemaDumper.create(self, options)
@@ -318,11 +341,14 @@ module ActiveRecord
           end
 
           # overwrite original methods to provide a elasticsearch version
-          def update_table_definition(name, base = self, **options)
-            # :nodoc:
+          def update_table_definition(name, base = self, **options) # :nodoc:
             ::ActiveRecord::ConnectionAdapters::Elasticsearch::UpdateTableDefinition.new(base, name, **options)
           end
 
+          def clone_table_definition(name, target, **options)
+            ::ActiveRecord::ConnectionAdapters::Elasticsearch::CloneTableDefinition.new(self, name, target, **options)
+          end
+
           # overwrite original methods to provide a elasticsearch version
           def schema_creation
             ::ActiveRecord::ConnectionAdapters::Elasticsearch::SchemaCreation.new(self)

data/lib/active_record/connection_adapters/elasticsearch/table_statements.rb

@@ -31,13 +31,17 @@ module ActiveRecord
           # - refresh
           # - rename_table
 
-          define_unsupported_method :rename_table
+          define_unsupported_method :create_join_table, :drop_join_table, :create_alter_table,
+                                    :change_column_default, :change_column_null, :rename_column, :rename_table
 
           # Opens a closed index.
           # @param [String] table_name
           # @return [Boolean] acknowledged status
           def open_table(table_name)
-            schema_cache.clear_data_source_cache!(table_name.to_s)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
+            schema_cache.clear_data_source_cache!(table_name)
             api(:indices, :open, { index: table_name }, 'OPEN TABLE').dig('acknowledged')
           end
 
@@ -55,7 +59,10 @@ module ActiveRecord
           # @param [String] table_name
           # @return [Boolean] acknowledged status
           def close_table(table_name)
-            schema_cache.clear_data_source_cache!(table_name.to_s)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
+            schema_cache.clear_data_source_cache!(table_name)
             api(:indices, :close, { index: table_name }, 'CLOSE TABLE').dig('acknowledged')
           end
 
@@ -77,6 +84,9 @@ module ActiveRecord
           # @param [String] table_name
           # @return [Boolean] acknowledged status
           def truncate_table(table_name)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
             # force: automatically drops an existing index
             create_table(table_name, force: true, **table_schema(table_name))
           end
@@ -98,11 +108,71 @@ module ActiveRecord
           #   Set to +true+ to only drop the table if it exists.
           #   Defaults to false.
           # @param [String] table_name
+          # @param [Boolean] if_exists
+          # @return [Array] acknowledged status
+          def drop_table(table_name, if_exists: false, **)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
+            schema_cache.clear_data_source_cache!(table_name)
+            api(:indices, :delete, { index: table_name, ignore: (if_exists ? 404 : nil) }, 'DROP TABLE').dig('acknowledged')
+          end
+
+          # blocks access to the provided table (index) and +block+ name.
+          # @param [String] table_name
+          # @param [Symbol] block_name The block to add (one of :read, :write, :read_only or :metadata)
+          # @return [Boolean] acknowledged status
+          def block_table(table_name, block_name = :write)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
+            api(:indices, :add_block, { index: table_name, block: block_name }, "BLOCK #{block_name.to_s.upcase} TABLE").dig('acknowledged')
+          end
+
+          # unblocks access to the provided table (index) and +block+ name.
+          # provide a nil-value to unblock all blocks, otherwise provide the blocked name.
+          # @param [String] table_name
+          # @param [Symbol] block_name The block to add (one of :read, :write, :read_only or :metadata)
+          # @return [Boolean] acknowledged status
+          def unblock_table(table_name, block_name = nil)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
+            if block_name.nil?
+              change_table(table_name) do |t|
+                t.change_setting('index.blocks.read', false)
+                t.change_setting('index.blocks.write', false)
+                t.change_setting('index.blocks.read_only', false)
+                t.change_setting('index.blocks.metadata', false)
+              end
+            else
+              change_setting(table_name, "index.blocks.#{block_name}", false)
+            end
+          end
+
+          # clones an entire table to the provided +target_name+.
+          # During cloning, the table will be automatically 'write'-blocked.
+          # @param [String] table_name
+          # @param [String] target_name
           # @param [Hash] options
-          # @return [Array] acknowledged status for provided table
-          def drop_table(table_name, **options)
-            schema_cache.clear_data_source_cache!(table_name.to_s)
-            api(:indices, :delete, { index: table_name, ignore: (options[:if_exists] ? 404 : nil) }, 'DROP TABLE').dig('acknowledged')
+          # @param [Proc] block
+          def clone_table(table_name, target_name, **options, &block)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+            target_name = _compute_table_name(target_name)
+
+            # create new definition
+            definition = clone_table_definition(table_name, target_name, **extract_table_options!(options), &block)
+
+            # yield optional block
+            if block_given?
+              definition.assign do |d|
+                yield d
+              end
+            end
+
+            # execute definition query(ies)
+            definition.exec!
           end
 
           # creates a new table (index).
@@ -120,6 +190,9 @@ module ActiveRecord
           # @param [Hash] options
           # @return [Boolean] acknowledged status
           def create_table(table_name, force: false, copy_from: nil, if_not_exists: false, **options)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
             return if if_not_exists && table_exists?(table_name)
 
             # copy schema from existing table
@@ -154,6 +227,9 @@ module ActiveRecord
           #     # Other column alterations here
           #   end
           def change_table(table_name, **options)
+            # IMPORTANT: compute will add possible configured prefix & suffix
+            table_name = _compute_table_name(table_name)
+
             definition = update_table_definition(table_name, self, **options)
 
             # yield optional block
@@ -185,11 +261,20 @@ module ActiveRecord
             _exec_change_table_with(:change_mapping_meta, table_name, name, **options)
           end
 
-          def change_mapping_attributes(table_name, name, **options,&block)
+          def change_mapping_attributes(table_name, name, **options, &block)
             _exec_change_table_with(:change_mapping_attributes, table_name, name, **options, &block)
           end
+
           alias :change_mapping_attribute :change_mapping_attributes
 
+          def change_meta(table_name, name, value, **options)
+            _exec_change_table_with(:change_meta, table_name, name, value, **options)
+          end
+
+          def delete_meta(table_name, name, **options)
+            _exec_change_table_with(:delete_meta, table_name, name, **options)
+          end
+
           # -- setting -------------------------------------------------------------------------------------------------
 
           def add_setting(table_name, name, value, **options, &block)
@@ -220,6 +305,15 @@ module ActiveRecord
 
           private
 
+          def _compute_table_name(table_name)
+            # HINT: +"" creates a new +unfrozen+ string!
+            str = +""
+            str << table_name_prefix unless table_name.to_s.start_with?(table_name_prefix)
+            str << table_name
+            str << table_name_suffix unless table_name.to_s.end_with?(table_name_suffix)
+            str
+          end
+
           def _exec_change_table_with(method, table_name, *args, **kwargs, &block)
             change_table(table_name) do |t|
               t.send(method, *args, **kwargs, &block)

data/lib/active_record/connection_adapters/elasticsearch_adapter.rb

@@ -45,10 +45,11 @@ module ActiveRecord # :nodoc:
 
       # defines the Elasticsearch 'base' structure, which is always included but cannot be resolved through mappings ...
       BASE_STRUCTURE = [
-        { 'name' => '_id', 'type' => 'keyword', 'virtual' => true, 'meta' => { 'primary_key' => 'true' } },
+        { 'name' => '_id', 'type' => 'keyword', 'virtual' => true, 'enabled' => true, 'meta' => { 'primary_key' => 'true' } },
         { 'name' => '_index', 'type' => 'keyword', 'virtual' => true },
         { 'name' => '_score', 'type' => 'float', 'virtual' => true },
-        { 'name' => '_type', 'type' => 'keyword', 'virtual' => true }
+        { 'name' => '_type', 'type' => 'keyword', 'virtual' => true },
+        { 'name' => '_ignored', 'type' => 'boolean', 'virtual' => true }
       ].freeze
 
       include Elasticsearch::UnsupportedImplementation
@@ -152,6 +153,20 @@ module ActiveRecord # :nodoc:
         @prepared_statements = false
       end
 
+      def schema_migration # :nodoc:
+        @schema_migration ||= ElasticsearchRecord::SchemaMigration
+      end
+
+      # provide a table_name_prefix from the configuration to create & restrict schema creation
+      def table_name_prefix
+        @config.fetch(:table_name_prefix, '')
+      end
+
+      # provide a table_name_suffix from the configuration to create & restrict schema creation
+      def table_name_suffix
+        @config.fetch(:table_name_suffix, '')
+      end
+
       # overwrite method to provide a Elasticsearch path
       def migrations_paths
         @config[:migrations_paths] || ['db/migrate_elasticsearch']

data/lib/arel/collectors/elasticsearch_query.rb

@@ -22,6 +22,9 @@ module Arel # :nodoc: all
       # @param [Array] args - args to claim
       def claim(action, *args)
         case action
+        when :refresh
+          # change the refresh state
+          @refresh = args[0]
         when :index
           # change the index name
           @index = args[0]

data/lib/arel/visitors/elasticsearch_query.rb

@@ -91,6 +91,7 @@ module Arel # :nodoc: all
         if o.relation.is_a?(::Arel::Table)
           # prepare query
           claim(:type, ::ElasticsearchRecord::Query::TYPE_CREATE)
+          claim(:refresh, true)
 
           # sets the index
           resolve(o.relation)

data/lib/arel/visitors/elasticsearch_schema.rb

@@ -23,11 +23,35 @@ module Arel # :nodoc: all
         # set the name of the index
         claim(:index, visit(o.name))
 
+        if o.metas.present? || o.mappings.present?
+          assign(:mappings, {}) do
+            # sets metas
+            resolve(o, :visit_TableMetas) if o.metas.present?
+
+            # sets mappings
+            resolve(o, :visit_TableMappings) if o.mappings.present?
+          end
+        end
+
         # sets settings
         resolve(o, :visit_TableSettings) if o.settings.present?
 
-        # sets mappings
-        resolve(o, :visit_TableMappings) if o.mappings.present?
+        # sets aliases
+        resolve(o, :visit_TableAliases) if o.aliases.present?
+      end
+
+      def visit_CloneTableDefinition(o)
+        # prepare query
+        claim(:type, ::ElasticsearchRecord::Query::TYPE_INDEX_CLONE)
+
+        # set the name of the index
+        claim(:index, visit(o.name))
+
+        # set the name of the target
+        claim(:argument, :target, visit(o.target))
+
+        # sets settings
+        resolve(o, :visit_TableSettings) if o.settings.present?
 
         # sets aliases
         resolve(o, :visit_TableAliases) if o.aliases.present?
@@ -41,6 +65,15 @@ module Arel # :nodoc: all
         visit(o.definition)
       end
 
+      def visit_ChangeMetaDefinition(o)
+        # prepare query
+        claim(:type, ::ElasticsearchRecord::Query::TYPE_INDEX_UPDATE_MAPPING)
+
+        assign(:_meta, {}) do
+          resolve(o.items, :visit_TableMetaDefinition)
+        end
+      end
+
       def visit_ChangeMappingDefinition(o)
         # prepare query
         claim(:type, ::ElasticsearchRecord::Query::TYPE_INDEX_UPDATE_MAPPING)
@@ -95,10 +128,14 @@ module Arel # :nodoc: all
       end
 
       def visit_TableMappings(o)
-        assign(:mappings, {}) do
-          assign(:properties, {}) do
-            resolve(o.mappings, :visit_TableMappingDefinition)
-          end
+        assign(:properties, {}) do
+          resolve(o.mappings, :visit_TableMappingDefinition)
+        end
+      end
+
+      def visit_TableMetas(o)
+        assign(:_meta, {}) do
+          resolve(o.metas, :visit_TableMetaDefinition)
         end
       end
 
@@ -112,8 +149,12 @@ module Arel # :nodoc: all
         assign(o.name, o.value, :__force__)
       end
 
+      def visit_TableMetaDefinition(o)
+        assign(o.name, o.value)
+      end
+
       def visit_TableMappingDefinition(o)
-        assign(o.name, o.attributes.merge({type: type_to_sql(o.type)}))
+        assign(o.name, o.attributes.merge({ type: type_to_sql(o.type) }))
       end
 
       def visit_TableAliasDefinition(o)