cassandra-driver 2.1.7-java → 3.0.0.beta.1-java

data/lib/cassandra/cluster/metadata.rb

@@ -30,6 +30,8 @@ module Cassandra
         @partitioners     = schema_partitioners
         @strategies       = replication_strategies
         @default_strategy = default_replication_strategy
+        @token_replicas   = ::Hash.new
+        @token_ring       = ::Array.new
       end
 
       def find_replicas(keyspace, statement)

data/lib/cassandra/cluster/schema.rb

@@ -22,17 +22,33 @@ module Cassandra
     class Schema
       include MonitorMixin
 
-      def initialize(schema_type_parser)
-        @type_parser = schema_type_parser
-        @keyspaces   = ::Hash.new
-        @listeners   = ::Set.new
+      def initialize
+        @keyspaces = ::Hash.new
+        @listeners = ::Set.new
 
         mon_initialize
       end
 
-      def create_partition_key(keyspace, table, values)
-        keyspace = @keyspaces[keyspace]
-        keyspace && keyspace.create_partition_key(table, values)
+      def get_pk_idx(metadata)
+        return EMPTY_LIST unless metadata
+
+        keyspace_name, table_name, _ = metadata.first
+        return EMPTY_LIST unless keyspace_name && table_name
+
+        keyspace = @keyspaces[keyspace_name]
+        return EMPTY_LIST unless keyspace
+
+        table = keyspace.table(table_name)
+        return EMPTY_LIST unless table
+
+        partition_key = table.partition_key
+        return EMPTY_LIST unless partition_key && partition_key.size <= metadata.size
+
+        partition_key.map do |column|
+          i = metadata.index {|(_, _, name, _)| name == column.name}
+          return EMPTY_LIST if i.nil?
+          i
+        end
       end
 
       def add_listener(listener)
@@ -51,25 +67,13 @@ module Cassandra
         self
       end
 
-      def update_keyspaces(host, keyspaces, tables, columns, types)
-        columns = columns.each_with_object(deephash { [] }) do |row, index|
-          index[row['keyspace_name']] << row
-        end
-
-        tables = tables.each_with_object(deephash { [] }) do |row, index|
-          index[row['keyspace_name']] << row
-        end
-
-        types = types.each_with_object(deephash { [] }) do |row, index|
-          index[row['keyspace_name']] << row
-        end
-
+      def replace(keyspaces)
         current_keyspaces = ::Set.new
 
-        keyspaces.each do |row|
-          current_keyspaces << keyspace = row['keyspace_name']
+        keyspaces.each do |keyspace|
+          current_keyspaces << keyspace.name
 
-          update_keyspace(host, row, tables[keyspace], columns[keyspace], types[keyspace])
+          replace_keyspace(keyspace)
         end
 
         @keyspaces.each do |name, keyspace|
@@ -79,40 +83,21 @@ module Cassandra
         self
       end
 
-      def update_keyspace(host, keyspace, tables, columns, types)
-        keyspace_name = keyspace['keyspace_name']
+      def replace_keyspace(keyspace)
+        old_keyspace = @keyspaces[keyspace.name]
 
-        columns = columns.each_with_object(deephash { ::Hash.new }) do |row, index|
-          index[row['columnfamily_name']][row['column_name']] = row
-        end
-
-        tables = tables.each_with_object(Hash.new) do |row, index|
-          name = row['columnfamily_name']
-          index[name] = create_table(row, columns[name], host.release_version)
-        end
-
-        types = types.each_with_object(Hash.new) do |row, index|
-          name = row['type_name']
-          index[name] = create_type(row, host.release_version)
-        end
-
-        replication = Keyspace::Replication.new(keyspace['strategy_class'], ::JSON.load(keyspace['strategy_options']))
-        keyspace = Keyspace.new(keyspace_name, keyspace['durable_writes'], replication, tables, types)
-
-        return self if keyspace == @keyspaces[keyspace_name]
-
-        created = !@keyspaces.include?(keyspace_name)
+        return self if old_keyspace == keyspace
 
         synchronize do
           keyspaces = @keyspaces.dup
-          keyspaces[keyspace_name] = keyspace
+          keyspaces[keyspace.name] = keyspace
           @keyspaces = keyspaces
         end
 
-        if created
-          keyspace_created(keyspace)
-        else
+        if old_keyspace
           keyspace_changed(keyspace)
+        else
+          keyspace_created(keyspace)
         end
 
         self
@@ -134,20 +119,20 @@ module Cassandra
         self
       end
 
-      def update_table(host, keyspace_name, table, columns)
-        keyspace = @keyspaces[keyspace_name]
+      def replace_table(table)
+        keyspace = @keyspaces[table.keyspace]
 
         return self unless keyspace
 
-        columns  = columns.each_with_object(::Hash.new) do |row, index|
-          index[row['column_name']] = row
-        end
-        table    = create_table(table, columns, host.release_version)
+        old_table = keyspace.table(table.name)
+
+        return self if old_table == table
+
         keyspace = keyspace.update_table(table)
 
         synchronize do
           keyspaces = @keyspaces.dup
-          keyspaces[keyspace_name] = keyspace
+          keyspaces[keyspace.name] = keyspace
           @keyspaces = keyspaces
         end
 
@@ -161,6 +146,10 @@ module Cassandra
 
         return self unless keyspace
 
+        table = keyspace.table(table_name)
+
+        return self unless table
+
         keyspace = keyspace.delete_table(table_name)
 
         synchronize do
@@ -174,17 +163,20 @@ module Cassandra
         self
       end
 
-      def update_type(host, keyspace_name, type)
-        keyspace = @keyspaces[keyspace_name]
+      def replace_type(type)
+        keyspace = @keyspaces[type.keyspace]
 
         return self unless keyspace
 
-        type     = create_type(type, host.release_version)
+        old_type = keyspace.type(type.name)
+
+        return self if old_type == type
+
         keyspace = keyspace.update_type(type)
 
         synchronize do
           keyspaces = @keyspaces.dup
-          keyspaces[keyspace_name] = keyspace
+          keyspaces[keyspace.name] = keyspace
           @keyspaces = keyspaces
         end
 
@@ -198,6 +190,10 @@ module Cassandra
 
         return self unless keyspace
 
+        type = keyspace.type(type_name)
+
+        return self unless type
+
         keyspace = keyspace.delete_type(type_name)
 
         synchronize do
@@ -211,189 +207,113 @@ module Cassandra
         self
       end
 
-      def has_keyspace?(name)
-        @keyspaces.include?(name)
-      end
+      def replace_function(function)
+        keyspace = @keyspaces[function.keyspace]
 
-      def keyspace(name)
-        @keyspaces[name]
-      end
-
-      def each_keyspace(&block)
-        if block_given?
-          @keyspaces.each_value(&block)
-          self
-        else
-          @keyspaces.values
-        end
-      end
-      alias :keyspaces :each_keyspace
+        return self unless keyspace
 
-      private
+        old_function = keyspace.function(function.name, *function.argument_types)
 
-      def create_type(type, version)
-        keyspace        = type['keyspace_name']
-        name            = type['type_name']
-        fields          = ::Array.new
+        return self if old_function == function
 
-        type['field_names'].zip(type['field_types']) do |(field_name, field_type)|
-          field_type = @type_parser.parse(field_type).results.first.first
+        keyspace = keyspace.update_function(function)
 
-          fields << [field_name, field_type]
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace.name] = keyspace
+          @keyspaces = keyspaces
         end
 
-        Types.udt(keyspace, name, fields)
+        keyspace_changed(keyspace)
+
+        self
       end
 
-      def create_table(table, columns, version)
-        keyspace        = table['keyspace_name']
-        name            = table['columnfamily_name']
-        key_validator   = @type_parser.parse(table['key_validator'])
-        comparator      = @type_parser.parse(table['comparator'])
-        column_aliases  = ::JSON.load(table['column_aliases'])
+      def delete_function(keyspace_name, function_name, function_arg_types)
+        keyspace = @keyspaces[keyspace_name]
+
+        return self unless keyspace
 
-        clustering_size = find_clustering_size(comparator, columns.values,
-                                               column_aliases, version)
+        function = keyspace.function(function_name, *function_arg_types)
 
-        is_dense           = clustering_size != comparator.results.size - 1
-        is_compact         = is_dense || !comparator.collections
-        partition_key      = []
-        clustering_columns = []
-        clustering_order   = []
+        return self unless function
 
-        compaction_strategy = Table::Compaction.new(
-          table['compaction_strategy_class'],
-          ::JSON.load(table['compaction_strategy_options'])
-        )
-        compression_parameters = ::JSON.load(table['compression_parameters'])
+        keyspace = keyspace.delete_function(function_name, function_arg_types)
 
-        options = Table::Options.new(table, compaction_strategy, compression_parameters, is_compact, version)
-        columns = create_columns(key_validator, comparator, column_aliases, is_dense, clustering_size, table, columns, version, partition_key, clustering_columns, clustering_order)
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace_name] = keyspace
+          @keyspaces = keyspaces
+        end
+
+        keyspace_changed(keyspace)
 
-        Table.new(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order, version)
+        self
       end
 
-      def find_clustering_size(comparator, columns, aliases, cassandra_version)
-        if cassandra_version.start_with?('1')
-          if comparator.collections
-            size = comparator.results.size
-            (!comparator.collections.empty? || aliases.size == size - 1 && comparator.results.last.first == :text) ? size - 1 : size
-          else
-            (!aliases.empty? || columns.empty?) ? 1 : 0
-          end
-        else
-          max_index = nil
+      def replace_aggregate(aggregate)
+        keyspace = @keyspaces[aggregate.keyspace]
+
+        return self unless keyspace
 
-          columns.each do |cl|
-            if cl['type'].to_s.upcase == 'CLUSTERING_KEY'
-              index = cl['component_index'] || 0
+        old_aggregate = keyspace.aggregate(aggregate.name, *aggregate.argument_types)
 
-              if max_index.nil? || index > max_index
-                max_index = index
-              end
-            end
-          end
+        return self if old_aggregate == aggregate
 
-          return 0 if max_index.nil?
+        keyspace = keyspace.update_aggregate(aggregate)
 
-          max_index + 1
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace.name] = keyspace
+          @keyspaces = keyspaces
         end
+
+        keyspace_changed(keyspace)
+
+        self
       end
 
-      def create_columns(key_validator, comparator, column_aliases, is_dense, clustering_size, table, columns, cassandra_version, partition_key, clustering_columns, clustering_order)
-        table_columns      = {}
-        other_columns      = []
-
-        if cassandra_version.start_with?('1')
-          key_aliases = ::JSON.load(table['key_aliases'])
-
-          key_validator.results.each_with_index do |(type, order, is_frozen), i|
-            key_alias = key_aliases.fetch(i) { i.zero? ? "key" : "key#{i + 1}" }
-
-            partition_key[i] = Column.new(key_alias, type, order, nil, false, is_frozen)
-          end
-
-          if comparator.results.size > 1
-            clustering_size.times do |i|
-              column_alias = column_aliases.fetch(i) { "column#{i + 1}" }
-              type, order, is_frozen = comparator.results.fetch(i)
-
-              clustering_columns[i] = Column.new(column_alias, type, order, nil, false, is_frozen)
-              clustering_order[i]   = order
-            end
-          else
-            column_alias = column_aliases.first || "column1"
-            type, order, is_frozen = comparator.results.first
-
-            clustering_columns[0] = Column.new(column_alias, type, order, nil, false, is_frozen)
-            clustering_order[0]   = order
-          end
-
-          if is_dense
-            value_alias = table['value_alias']
-            value_alias = 'value' if value_alias.nil? || value_alias.empty?
-            type, order, is_frozen = @type_parser.parse(table['default_validator']).results.first
-            other_columns << Column.new(value_alias, type, order, nil, false, is_frozen)
-          end
-
-          columns.each do |name, row|
-            other_columns << create_column(row)
-          end
-        else
-          columns.each do |name, row|
-            next if row['column_name'].empty?
-
-            column = create_column(row)
-            type   = row['type'].to_s
-            index  = row['component_index'] || 0
-
-            case type.upcase
-            when 'PARTITION_KEY'
-              partition_key[index] = column
-            when 'CLUSTERING_KEY'
-              clustering_columns[index] = column
-              clustering_order[index]   = column.order
-            else
-              other_columns << column
-            end
-          end
-        end
+      def delete_aggregate(keyspace_name, aggregate_name, aggregate_arg_types)
+        keyspace = @keyspaces[keyspace_name]
 
-        partition_key.each do |column|
-          table_columns[column.name] = column
-        end
+        return self unless keyspace
 
-        clustering_columns.each do |column|
-          table_columns[column.name] = column
-        end
+        aggregate = keyspace.aggregate(aggregate_name, *aggregate_arg_types)
+
+        return self unless aggregate
 
-        other_columns.each do |column|
-          table_columns[column.name] = column
+        keyspace = keyspace.delete_aggregate(aggregate_name, aggregate_arg_types)
+
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace_name] = keyspace
+          @keyspaces = keyspaces
         end
 
-        table_columns
+        keyspace_changed(keyspace)
+
+        self
+      end
+
+      def has_keyspace?(name)
+        @keyspaces.include?(name)
       end
 
-      def create_column(column)
-        name        = column['column_name']
-        type, order, is_frozen = @type_parser.parse(column['validator']).results.first
-        is_static   = (column['type'] == 'STATIC')
+      def keyspace(name)
+        @keyspaces[name]
+      end
 
-        if column['index_type'].nil?
-          index   = nil
-        elsif column['index_type'].to_s.upcase == 'CUSTOM' || !column['index_options']
-          index   = Column::Index.new(column['index_name'])
+      def each_keyspace(&block)
+        if block_given?
+          @keyspaces.each_value(&block)
+          self
         else
-          options = ::JSON.load(column['index_options'])
-          index   = Column::Index.new(column['index_name'], options && options['class_name'])
+          @keyspaces.values
         end
-
-        Column.new(name, type, order, index, is_static, is_frozen)
       end
+      alias :keyspaces :each_keyspace
 
-      def deephash
-        ::Hash.new {|hash, key| hash[key] = yield}
-      end
+      private
 
       def keyspace_created(keyspace)
         @listeners.each do |listener|
@@ -416,6 +336,8 @@ module Cassandra
   end
 end
 
+require 'cassandra/cluster/schema/cql_type_parser'
+require 'cassandra/cluster/schema/fetchers'
 require 'cassandra/cluster/schema/partitioners'
 require 'cassandra/cluster/schema/replication_strategies'
-require 'cassandra/cluster/schema/type_parser'
+require 'cassandra/cluster/schema/fqcn_type_parser'