cassandra-driver 3.0.3 → 3.1.0

data/lib/cassandra/cluster/connector.rb

@@ -122,11 +122,8 @@ module Cassandra
                          ssl: @connection_options.ssl) do |connection|
           raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
 
-          if @connection_options.nodelay?
-            connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-          else
-            connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 0)
-          end
+          connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY,
+                                      @connection_options.nodelay? ? 1 : 0)
 
           Protocol::CqlProtocolHandler.new(connection,
                                            @reactor,
@@ -225,10 +222,12 @@ module Cassandra
             ::Ione::Future.resolved(connection)
           when Protocol::ErrorResponse
             ::Ione::Future.failed(
-              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0)
+            )
           else
             ::Ione::Future.failed(
-              Errors::InternalError.new("Unexpected response #{r.inspect}"))
+              Errors::InternalError.new("Unexpected response #{r.inspect}")
+            )
           end
         end
       end
@@ -244,7 +243,8 @@ module Cassandra
           VOID_OPTIONS,
           EMPTY_LIST,
           :one,
-          0)
+          0
+        )
       end
 
       def request_options(connection)
@@ -291,10 +291,12 @@ module Cassandra
             ::Ione::Future.resolved(connection)
           when Protocol::ErrorResponse
             ::Ione::Future.failed(
-              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0))
+              r.to_error(nil, VOID_STATEMENT, VOID_OPTIONS, EMPTY_LIST, :one, 0)
+            )
           else
             ::Ione::Future.failed(
-              Errors::InternalError.new("Unexpected response #{r.inspect}"))
+              Errors::InternalError.new("Unexpected response #{r.inspect}")
+            )
           end
         end
       end

data/lib/cassandra/cluster/control_connection.rb

@@ -36,8 +36,10 @@ module Cassandra
         @address_resolver      = address_resolution_policy
         @connector             = connector
         @connection_options    = connection_options
+        @connection            = nil
         @schema_fetcher        = schema_fetcher
         @refreshing_statuses   = ::Hash.new(false)
+        @refresh_schema_future = nil
         @status                = :closed
         @refreshing_hosts      = false
         @refreshing_host       = ::Hash.new(false)
@@ -88,7 +90,8 @@ module Cassandra
                  (@status == :closing || @status == :closed) ||
                  @load_balancing_policy.distance(host) == :ignore
             return connect_to_first_available(
-              @load_balancing_policy.plan(nil, VOID_STATEMENT, VOID_OPTIONS))
+              @load_balancing_policy.plan(nil, VOID_STATEMENT, VOID_OPTIONS)
+            )
           end
         end
 
@@ -146,18 +149,20 @@ module Cassandra
 
       private
 
-      SELECT_LOCAL  = Protocol::QueryRequest.new(
+      SELECT_LOCAL = Protocol::QueryRequest.new(
         'SELECT * ' \
           'FROM system.local',
         EMPTY_LIST,
         EMPTY_LIST,
-        :one)
-      SELECT_PEERS  = Protocol::QueryRequest.new(
+        :one
+      )
+      SELECT_PEERS = Protocol::QueryRequest.new(
         'SELECT * ' \
           'FROM system.peers',
         EMPTY_LIST,
         EMPTY_LIST,
-        :one)
+        :one
+      )
 
       SELECT_PEER_QUERY =
         'SELECT * ' \
@@ -229,7 +234,9 @@ module Cassandra
                   refresh_schema_async_wrapper
                 end
               when 'DOWN'
-                @registry.host_down(event.address)
+                # RUBY-164: Don't mark host down if there are active connections. We have
+                # logic in connector.rb to call host_down when all connections to a node are lost,
+                # so that covers the requirement.
               when 'NEW_NODE'
                 address = event.address
 
@@ -445,7 +452,7 @@ module Cassandra
 
           peers.shuffle!
           peers.each do |data|
-            ip = peer_ip(data)
+            ip = peer_ip(data, connection.host)
             next unless ip
             ips << ip
             @registry.host_found(ip, data)
@@ -665,9 +672,30 @@ Control connection failed and is unlikely to recover.
         @connector.connect(host)
       end
 
-      def peer_ip(data)
-        ip = data['rpc_address']
-        ip = data['peer'] if ip == '0.0.0.0'
+      def peer_ip(data, host_address)
+        peer = data['peer']
+
+        return nil unless peer && data['host_id'] && data['data_center'] && data['rack'] && data['tokens']
+
+        rpc_address = data['rpc_address']
+
+        if rpc_address.nil?
+          @logger.info("The system.peers row for '#{data['peer']}' has no rpc_address. This is likely " \
+                           'a gossip or snitch issue. This host will be ignored.')
+          return nil
+        end
+
+        if peer == host_address || rpc_address == host_address
+          # Some DSE versions were inserting a line for the local node in peers (with mostly null values).
+          # This has been fixed, but if we detect that's the case, ignore it as it's not really a big deal.
+
+          @logger.debug("System.peers on node #{host_address} has a line for itself. This is not normal but is a " \
+                            'known problem of some DSE versions. Ignoring the entry.')
+          return nil
+        end
+
+        ip = rpc_address
+        ip = peer if ip == '0.0.0.0'
 
         @address_resolver.resolve(ip)
       end

data/lib/cassandra/cluster/options.rb

@@ -25,7 +25,7 @@ module Cassandra
       attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
                   :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
                   :schema_refresh_timeout, :ssl, :custom_type_handlers
-      attr_boolean :protocol_negotiable, :synchronize_schema, :nodelay
+      attr_boolean :protocol_negotiable, :synchronize_schema, :nodelay, :allow_beta_protocol
 
       attr_accessor :protocol_version
 
@@ -46,7 +46,8 @@ module Cassandra
                      schema_refresh_timeout,
                      nodelay,
                      requests_per_connection,
-                     custom_types)
+                     custom_types,
+                     allow_beta_protocol)
         @logger                 = logger
         @protocol_version       = protocol_version
         @credentials            = credentials
@@ -61,6 +62,7 @@ module Cassandra
         @schema_refresh_delay   = schema_refresh_delay
         @schema_refresh_timeout = schema_refresh_timeout
         @nodelay                = nodelay
+        @allow_beta_protocol    = allow_beta_protocol
         @custom_type_handlers   = {}
         custom_types.each do |type_klass|
           @custom_type_handlers[type_klass.type] = type_klass
@@ -71,12 +73,14 @@ module Cassandra
         @requests_per_connection = requests_per_connection
 
         # If @protocol_version is nil, it means we want the driver to negotiate the
-        # protocol starting with our known max (4). If @protocol_version is not nil,
+        # protocol starting with our known max. If @protocol_version is not nil,
         # it means the user wants us to use a particular version, so we should not
         # support negotiation.
 
         @protocol_negotiable = @protocol_version.nil?
-        @protocol_version ||= 4
+        @protocol_version ||= allow_beta_protocol ?
+            Cassandra::Protocol::Versions::BETA_VERSION :
+            Cassandra::Protocol::Versions::MAX_SUPPORTED_VERSION
       end
 
       def compression

data/lib/cassandra/cluster/registry.rb

@@ -170,8 +170,7 @@ module Cassandra
                  Array(data['tokens']).freeze,
                  :up,
                  data['broadcast_address'],
-                 data['listen_address']
-                )
+                 data['listen_address'])
       end
 
       def toggle_up(host)

data/lib/cassandra/cluster/schema/fetchers.rb

@@ -34,8 +34,9 @@ module Cassandra
                            select_functions(connection),
                            select_aggregates(connection),
                            select_materialized_views(connection),
-                           select_indexes(connection))
-                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes|
+                           select_indexes(connection),
+                           select_triggers(connection))
+                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes, rows_triggers|
                         lookup_tables     = map_rows_by(rows_tables, 'keyspace_name')
                         lookup_columns    = map_rows_by(rows_columns, 'keyspace_name')
                         lookup_types      = map_rows_by(rows_types, 'keyspace_name')
@@ -43,6 +44,7 @@ module Cassandra
                         lookup_aggregates = map_rows_by(rows_aggregates, 'keyspace_name')
                         lookup_views      = map_rows_by(rows_views, 'keyspace_name')
                         lookup_indexes    = map_rows_by(rows_indexes, 'keyspace_name')
+                        lookup_triggers   = map_rows_by(rows_triggers, 'keyspace_name')
 
                         rows_keyspaces.map do |keyspace_data|
                           name = keyspace_data['keyspace_name']
@@ -54,7 +56,8 @@ module Cassandra
                                           lookup_functions[name],
                                           lookup_aggregates[name],
                                           lookup_views[name],
-                                          lookup_indexes[name])
+                                          lookup_indexes[name],
+                                          lookup_triggers[name])
                         end
                       end
         end
@@ -67,8 +70,9 @@ module Cassandra
                            select_keyspace_functions(connection, keyspace_name),
                            select_keyspace_aggregates(connection, keyspace_name),
                            select_keyspace_materialized_views(connection, keyspace_name),
-                           select_keyspace_indexes(connection, keyspace_name))
-                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes|
+                           select_keyspace_indexes(connection, keyspace_name),
+                           select_keyspace_triggers(connection, keyspace_name))
+                      .map do |rows_keyspaces, rows_tables, rows_columns, rows_types, rows_functions, rows_aggregates, rows_views, rows_indexes, rows_triggers|
                         if rows_keyspaces.empty?
                           nil
                         else
@@ -79,7 +83,8 @@ module Cassandra
                                           rows_functions,
                                           rows_aggregates,
                                           rows_views,
-                                          rows_indexes)
+                                          rows_indexes,
+                                          rows_triggers)
                         end
                       end
         end
@@ -87,14 +92,16 @@ module Cassandra
         def fetch_table(connection, keyspace_name, table_name)
           Ione::Future.all(select_table(connection, keyspace_name, table_name),
                            select_table_columns(connection, keyspace_name, table_name),
-                           select_table_indexes(connection, keyspace_name, table_name))
-                      .map do |(rows_tables, rows_columns, rows_indexes)|
+                           select_table_indexes(connection, keyspace_name, table_name),
+                           select_table_triggers(connection, keyspace_name, table_name))
+                      .map do |(rows_tables, rows_columns, rows_indexes, rows_triggers)|
             if rows_tables.empty?
               nil
             else
               create_table(rows_tables.first,
                            rows_columns,
-                           rows_indexes)
+                           rows_indexes,
+                           rows_triggers)
             end
           end
         end
@@ -168,6 +175,10 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_triggers(connection)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_types(connection)
           FUTURE_EMPTY_LIST
         end
@@ -200,6 +211,10 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_keyspace_triggers(connection, keyspace_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_keyspace_types(connection, keyspace_name)
           FUTURE_EMPTY_LIST
         end
@@ -228,6 +243,10 @@ module Cassandra
           FUTURE_EMPTY_LIST
         end
 
+        def select_table_triggers(connection, keyspace_name, table_name)
+          FUTURE_EMPTY_LIST
+        end
+
         def select_type(connection, keyspace_name, type_name)
           FUTURE_EMPTY_LIST
         end
@@ -243,7 +262,8 @@ module Cassandra
         def send_select_request(connection, cql, params = EMPTY_LIST, types = EMPTY_LIST)
           backtrace = caller
           connection.send_request(
-            Protocol::QueryRequest.new(cql, params, types, :one)).map do |r|
+            Protocol::QueryRequest.new(cql, params, types, :one)
+          ).map do |r|
             case r
             when Protocol::RowsResultResponse
               r.rows
@@ -348,7 +368,7 @@ module Cassandra
 
           def create_keyspace(keyspace_data, rows_tables, rows_columns,
                               rows_types, rows_functions, rows_aggregates,
-                              rows_views, rows_indexes)
+                              rows_views, rows_indexes, rows_triggers)
             keyspace_name = keyspace_data['keyspace_name']
             replication   = create_replication(keyspace_data)
             types = rows_types.each_with_object({}) do |row, h|
@@ -367,10 +387,14 @@ module Cassandra
             end
 
             lookup_columns = map_rows_by(rows_columns, 'columnfamily_name')
+            lookup_indexes = map_rows_by(rows_indexes, 'columnfamily_name')
+            lookup_triggers = map_rows_by(rows_triggers, 'columnfamily_name')
             tables = rows_tables.each_with_object({}) do |row, h|
               table_name = row['columnfamily_name']
-              # rows_indexes is nil for C* < 3.0.
-              h[table_name] = create_table(row, lookup_columns[table_name], nil)
+              h[table_name] = create_table(row,
+                                           lookup_columns[table_name],
+                                           lookup_indexes[table_name],
+                                           lookup_triggers[table_name])
             end
 
             Keyspace.new(keyspace_name,
@@ -383,7 +407,7 @@ module Cassandra
                          {})
           end
 
-          def create_table(table_data, rows_columns, rows_indexes)
+          def create_table(table_data, rows_columns, rows_indexes, rows_triggers)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['columnfamily_name']
             key_validator   = @type_parser.parse(table_data['key_validator'])
@@ -461,7 +485,7 @@ module Cassandra
               column = create_column(row)
               other_columns << column
 
-              # In C* 1.2.x, index info is in the column metadata; rows_indexes is nil.
+              # In C* 1.2.x, index info is in the column metadata; rows_indexes is [].
               index_rows << [column, row] unless row['index_type'].nil?
             end
 
@@ -485,7 +509,8 @@ module Cassandra
             # Most of this logic was taken from the Java driver.
             options = {}
             # For some versions of C*, this field could have a literal string 'null' value.
-            if !row_column['index_options'].nil? && row_column['index_options'] != 'null' && !row_column['index_options'].empty?
+            if !row_column['index_options'].nil? && row_column['index_options'] != 'null' &&
+               !row_column['index_options'].empty?
               options = ::JSON.load(row_column['index_options'])
             end
             column_name = Util.escape_name(column.name)
@@ -548,18 +573,24 @@ module Cassandra
               compression_parameters,
               is_compact,
               table_data['crc_check_chance'],
-              table_data['extensions']
+              table_data['extensions'],
+              nil
             )
           end
         end
 
         class V2_0_x < V1_2_x
+          SELECT_TRIGGERS = 'SELECT * FROM system.schema_triggers'.freeze
+
           SELECT_KEYSPACE           =
             'SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_TABLES    =
             'SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_COLUMNS   =
             'SELECT * FROM system.schema_columns WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_TRIGGERS =
+            'SELECT * FROM system.schema_triggers WHERE keyspace_name = ?'.freeze
+
           SELECT_TABLE              =
             'SELECT * ' \
             'FROM system.schema_columnfamilies ' \
@@ -568,10 +599,14 @@ module Cassandra
             'SELECT * ' \
             'FROM system.schema_columns ' \
             'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
+          SELECT_TABLE_TRIGGERS =
+            'SELECT * ' \
+            'FROM system.schema_triggers ' \
+            'WHERE keyspace_name = ? AND columnfamily_name = ?'.freeze
 
           private
 
-          def create_table(table_data, rows_columns, rows_indexes)
+          def create_table(table_data, rows_columns, rows_indexes, rows_triggers)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['columnfamily_name']
             comparator      = @type_parser.parse(table_data['comparator'])
@@ -598,7 +633,7 @@ module Cassandra
                 clustering_columns[ind] = column
                 clustering_order[ind]   = column.order
 
-                clustering_size = ind + 1 if clustering_size.zero? || ind == clustering_size
+                clustering_size += 1
               else
                 other_columns << column
               end
@@ -626,9 +661,21 @@ module Cassandra
             index_rows.each do |column, row|
               create_index(table, column, row)
             end
+
+            # Create Trigger objects and add them to the table.
+            rows_triggers.each do |row_trigger|
+              table.add_trigger(Cassandra::Trigger.new(table,
+                                                       row_trigger['trigger_name'],
+                                                       row_trigger['trigger_options']))
+            end
+
             table
           end
 
+          def select_triggers(connection)
+            send_select_request(connection, SELECT_TRIGGERS)
+          end
+
           def select_keyspace(connection, keyspace_name)
             params = [keyspace_name]
             hints  = [Types.varchar]
@@ -647,6 +694,12 @@ module Cassandra
             send_select_request(connection, SELECT_KEYSPACE_COLUMNS, params, hints)
           end
 
+          def select_keyspace_triggers(connection, keyspace_name)
+            params = [keyspace_name]
+            hints  = [Types.varchar]
+            send_select_request(connection, SELECT_KEYSPACE_TRIGGERS, params, hints)
+          end
+
           def select_table(connection, keyspace_name, table_name)
             params         = [keyspace_name, table_name]
             hints          = [Types.varchar, Types.varchar]
@@ -659,6 +712,12 @@ module Cassandra
             send_select_request(connection, SELECT_TABLE_COLUMNS, params, hints)
           end
 
+          def select_table_triggers(connection, keyspace_name, table_name)
+            params         = [keyspace_name, table_name]
+            hints          = [Types.varchar, Types.varchar]
+            send_select_request(connection, SELECT_TABLE_TRIGGERS, params, hints)
+          end
+
           def create_table_options(table_data, compaction_strategy, is_compact)
             compression_parameters = ::JSON.load(table_data['compression_parameters'])
             if compression_parameters['sstable_compression']
@@ -684,7 +743,8 @@ module Cassandra
               compression_parameters,
               is_compact,
               table_data['crc_check_chance'],
-              table_data['extensions']
+              table_data['extensions'],
+              nil
             )
           end
         end
@@ -758,7 +818,8 @@ module Cassandra
               compression_parameters,
               is_compact,
               table_data['crc_check_chance'],
-              table_data['extensions']
+              table_data['extensions'],
+              nil
             )
           end
         end
@@ -834,7 +895,9 @@ module Cassandra
             initial_state  = Util.encode_object(
               Protocol::Coder.read_value_v4(
                 Protocol::CqlByteBuffer.new.append_bytes(aggregate_data['initcond']),
-                state_type, nil))
+                state_type, nil
+              )
+            )
 
             # The state-function takes arguments: first the stype, then the args of the aggregate.
             state_function = functions.get(aggregate_data['state_func'],
@@ -896,6 +959,7 @@ module Cassandra
           SELECT_AGGREGATES = 'SELECT * FROM system_schema.aggregates'.freeze
           SELECT_INDEXES    = 'SELECT * FROM system_schema.indexes'.freeze
           SELECT_VIEWS      = 'SELECT * FROM system_schema.views'.freeze
+          SELECT_TRIGGERS   = 'SELECT * FROM system_schema.triggers'.freeze
 
           SELECT_KEYSPACE            =
             'SELECT * FROM system_schema.keyspaces WHERE keyspace_name = ?'.freeze
@@ -913,6 +977,8 @@ module Cassandra
             'SELECT * FROM system_schema.functions WHERE keyspace_name = ?'.freeze
           SELECT_KEYSPACE_AGGREGATES =
             'SELECT * FROM system_schema.aggregates WHERE keyspace_name = ?'.freeze
+          SELECT_KEYSPACE_TRIGGERS   =
+            'SELECT * FROM system_schema.triggers WHERE keyspace_name = ?'.freeze
 
           SELECT_TABLE         =
             'SELECT * ' \
@@ -926,6 +992,10 @@ module Cassandra
             'SELECT * ' \
             'FROM system_schema.indexes ' \
             'WHERE keyspace_name = ? AND table_name = ?'.freeze
+          SELECT_TABLE_TRIGGERS =
+            'SELECT * ' \
+            'FROM system_schema.triggers ' \
+            'WHERE keyspace_name = ? AND table_name = ?'.freeze
 
           SELECT_VIEW =
             'SELECT * ' \
@@ -984,6 +1054,10 @@ module Cassandra
             send_select_request(connection, SELECT_COLUMNS)
           end
 
+          def select_triggers(connection)
+            send_select_request(connection, SELECT_TRIGGERS)
+          end
+
           def select_types(connection)
             send_select_request(connection, SELECT_TYPES)
           end
@@ -1026,6 +1100,12 @@ module Cassandra
             send_select_request(connection, SELECT_KEYSPACE_VIEWS, params, hints)
           end
 
+          def select_keyspace_triggers(connection, keyspace_name)
+            params = [keyspace_name]
+            hints  = [Types.varchar]
+            send_select_request(connection, SELECT_KEYSPACE_TRIGGERS, params, hints)
+          end
+
           def select_keyspace_types(connection, keyspace_name)
             params = [keyspace_name]
             hints  = [Types.varchar]
@@ -1071,6 +1151,12 @@ module Cassandra
             send_select_request(connection, SELECT_VIEW, params, hints)
           end
 
+          def select_table_triggers(connection, keyspace_name, table_name)
+            params         = [keyspace_name, table_name]
+            hints          = [Types.varchar, Types.varchar]
+            send_select_request(connection, SELECT_TABLE_TRIGGERS, params, hints)
+          end
+
           def select_type(connection, keyspace_name, type_name)
             params = [keyspace_name, type_name]
             hints  = [Types.varchar, Types.varchar]
@@ -1182,7 +1268,7 @@ module Cassandra
           end
 
           def create_keyspace(keyspace_data, rows_tables, rows_columns, rows_types,
-                              rows_functions, rows_aggregates, rows_views, rows_indexes)
+                              rows_functions, rows_aggregates, rows_views, rows_indexes, rows_triggers)
             keyspace_name = keyspace_data['keyspace_name']
             replication   = create_replication(keyspace_data)
 
@@ -1206,10 +1292,11 @@ module Cassandra
 
             lookup_columns = map_rows_by(rows_columns, 'table_name')
             lookup_indexes = map_rows_by(rows_indexes, 'table_name')
+            lookup_triggers = map_rows_by(rows_triggers, 'table_name')
             tables = rows_tables.each_with_object({}) do |row, h|
               table_name = row['table_name']
               h[table_name] = create_table(row, lookup_columns[table_name],
-                                           lookup_indexes[table_name], types)
+                                           lookup_indexes[table_name], lookup_triggers[table_name], types)
             end
 
             views = rows_views.each_with_object({}) do |row, h|
@@ -1266,7 +1353,8 @@ module Cassandra
               compression,
               is_compact,
               table_data['crc_check_chance'],
-              table_data['extensions']
+              table_data['extensions'],
+              table_data['cdc']
             )
           end
 
@@ -1285,7 +1373,7 @@ module Cassandra
             Column.new(name, type, order, is_static, is_frozen)
           end
 
-          def create_table(table_data, rows_columns, rows_indexes, types = nil)
+          def create_table(table_data, rows_columns, rows_indexes, rows_triggers, types = nil)
             keyspace_name   = table_data['keyspace_name']
             table_name      = table_data['table_name']
             table_flags     = table_data['flags']
@@ -1352,6 +1440,14 @@ module Cassandra
             rows_indexes.each do |row|
               create_index(table, row)
             end
+
+            # Create Trigger objects and add them to the table.
+            rows_triggers.each do |row_trigger|
+              table.add_trigger(Cassandra::Trigger.new(table,
+                                                       row_trigger['trigger_name'],
+                                                       row_trigger['options']))
+            end
+
             table
           end