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

data/lib/cassandra/load_balancing/policies/round_robin.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -128,6 +128,13 @@ module Cassandra
 
           Plan.new(hosts, position)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "hosts=#{@hosts.inspect}, " \
+          "position=#{@position.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/load_balancing/policies/token_aware.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,11 +35,10 @@ module Cassandra
             until @hosts.empty?
               host = @hosts.shift
 
-              if @policy.distance(host) == :local
-                @seen[host] = true
-                @next = host
-                break
-              end
+              next unless @policy.distance(host) == :local
+              @seen[host] = true
+              @next = host
+              break
             end
 
             return true if @next
@@ -100,9 +99,12 @@ module Cassandra
         #   under-utilizes read caching and forces multiple replicas to cache
         #   the same read statements.
         def initialize(wrapped_policy, shuffle = true)
-          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
 
-          Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
+          Util.assert_responds_to_all(methods, wrapped_policy) do
+            "supplied policy must respond to #{methods.inspect}, but doesn't"
+          end
 
           @policy  = wrapped_policy
           @shuffle = !!shuffle
@@ -126,14 +128,21 @@ module Cassandra
           replicas = @cluster.find_replicas(keyspace, statement)
           return @policy.plan(keyspace, statement, options) if replicas.empty?
 
-          if @shuffle
-            replicas = replicas.shuffle
-          else
-            replicas = replicas.dup
-          end
+          replicas = if @shuffle
+                       replicas.shuffle
+                     else
+                       replicas.dup
+                     end
 
           Plan.new(replicas, @policy, keyspace, statement, options)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "shuffle=#{@shuffle.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/load_balancing/policies/white_list.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,9 +35,14 @@ module Cassandra
         # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
         # @raise [ArgumentError] if arguments are of unexpected types
         def initialize(ips, wrapped_policy)
-          Util.assert_instance_of(::Enumerable, ips) { "ips must be an Enumerable, #{ips.inspect} given" }
-          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
-          Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
+          Util.assert_instance_of(::Enumerable, ips) do
+            "ips must be an Enumerable, #{ips.inspect} given"
+          end
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
+          Util.assert_responds_to_all(methods, wrapped_policy) do
+            "supplied policy must respond to #{methods.inspect}, but doesn't"
+          end
 
           @ips    = ::Set.new
           @policy = wrapped_policy
@@ -49,7 +54,8 @@ module Cassandra
             when ::String
               @ips << ::IPAddr.new(ip)
             else
-              raise ::ArgumentError, "each ip must be a String or IPAddr, #{ip.inspect} given"
+              raise ::ArgumentError, 'each ip must be a String or IPAddr, ' \
+                  "#{ip.inspect} given"
             end
           end
         end
@@ -81,6 +87,13 @@ module Cassandra
         def host_down(host)
           @policy.host_down(host) if @ips.include?(host.ip)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "ips=#{@ips.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/materialized_view.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2016 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # Represents a cassandra materialized view
+  # @see Cassandra::Keyspace#each_materialized_view
+  # @see Cassandra::Keyspace#materialized_view
+  class MaterializedView < ColumnContainer
+    # @return [Table] the table that this materialized view applies to.
+    attr_reader :base_table
+
+    # @private
+    def initialize(keyspace,
+                   name,
+                   partition_key,
+                   clustering_columns,
+                   other_columns,
+                   options,
+                   include_all_columns,
+                   where_clause,
+                   base_table,
+                   id)
+      super(keyspace, name, partition_key, clustering_columns, other_columns, options, id)
+      @include_all_columns = include_all_columns
+      @where_clause = where_clause
+      @base_table = base_table
+    end
+
+    # @return [String] a cql representation of this materialized view
+    def to_cql
+      keyspace_name = Util.escape_name(@keyspace.name)
+      cql = "CREATE MATERIALIZED VIEW #{keyspace_name}.#{Util.escape_name(@name)} AS\nSELECT "
+      cql << if @include_all_columns
+               '*'
+             else
+               @columns.map do |column|
+                 Util.escape_name(column.name)
+               end.join(', ')
+             end
+      cql << "\nFROM #{keyspace_name}.#{Util.escape_name(@base_table.name)}"
+      cql << "\nWHERE #{@where_clause}" if @where_clause
+      cql << "\nPRIMARY KEY (("
+      cql << @partition_key.map do |column|
+        Util.escape_name(column.name)
+      end.join(', ')
+      cql << ')'
+      unless @clustering_columns.empty?
+        cql << ', '
+        cql << @clustering_columns.map do |column|
+          Util.escape_name(column.name)
+        end.join(', ')
+      end
+      cql << ")\nWITH #{@options.to_cql.split("\n").join("\n ")};"
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(MaterializedView) &&
+        super.eql?(other) &&
+        @include_all_columns == other.include_all_columns &&
+        @where_clause == other.where_clause &&
+        @base_table == other.base_table
+    end
+    alias == eql?
+
+    private
+
+    # We need these accessors for eql? to work, but we don't want random users to
+    # get these.
+
+    # @private
+    attr_reader :include_all_columns, :where_clause
+    protected :include_all_columns, :where_clause
+  end
+end

data/lib/cassandra/null_logger.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,16 +20,37 @@ module Cassandra
   # @private
   class NullLogger
     def close(*); end
+
     def debug(*); end
-    def debug?; false end
+
+    def debug?
+      false
+    end
+
     def error(*); end
-    def error?; false end
+
+    def error?
+      false
+    end
+
     def fatal(*); end
-    def fatal?; false end
+
+    def fatal?
+      false
+    end
+
     def info(*); end
-    def info?; false end
+
+    def info?
+      false
+    end
+
     def unknown(*); end
+
     def warn(*); end
-    def warn?; false end
+
+    def warn?
+      false
+    end
   end
 end

data/lib/cassandra/protocol.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cassandra/protocol/coder.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,13 +18,15 @@
 
 module Cassandra
   module Protocol
-    module Coder; extend self
+    module Coder
+      module_function
+
       GLOBAL_TABLES_SPEC_FLAG = 0x01
       HAS_MORE_PAGES_FLAG     = 0x02
       NO_METADATA_FLAG        = 0x04
 
       def write_values_v4(buffer, values, types, names = EMPTY_LIST)
-        if values && values.size > 0
+        if values && !values.empty?
           buffer.append_short(values.size)
           values.zip(types, names) do |(value, type, name)|
             buffer.append_string(name) if name
@@ -109,7 +111,9 @@ module Cassandra
         when :time             then write_time(buffer, value)
         when :date             then write_date(buffer, value)
         when :list, :set       then write_list_v4(buffer, value, type.value_type)
-        when :map              then write_map_v4(buffer, value, type.key_type, type.value_type)
+        when :map              then write_map_v4(buffer, value,
+                                                 type.key_type,
+                                                 type.value_type)
         when :udt              then write_udt_v4(buffer, value, type.fields)
         when :tuple            then write_tuple_v4(buffer, value, type.members)
         else
@@ -121,18 +125,23 @@ module Cassandra
         flags         = buffer.read_int
         columns_count = buffer.read_int
         pk_count      = buffer.read_int
-        pk_specs      = ::Array.new(pk_count) {|i| buffer.read_short}
+        pk_specs      = ::Array.new(pk_count) {|_i| buffer.read_short}
 
         if flags & GLOBAL_TABLES_SPEC_FLAG == GLOBAL_TABLES_SPEC_FLAG
           keyspace_name = buffer.read_string
           table_name    = buffer.read_string
 
-          column_specs = ::Array.new(columns_count) do |i|
+          column_specs = ::Array.new(columns_count) do |_i|
             [keyspace_name, table_name, buffer.read_string, read_type_v4(buffer)]
           end
         else
-          column_specs = ::Array.new(columns_count) do |i|
-            [buffer.read_string, buffer.read_string, buffer.read_string, read_type_v4(buffer)]
+          column_specs = ::Array.new(columns_count) do |_i|
+            [
+              buffer.read_string,
+              buffer.read_string,
+              buffer.read_string,
+              read_type_v4(buffer)
+            ]
           end
         end
 
@@ -152,12 +161,17 @@ module Cassandra
             keyspace_name = buffer.read_string
             table_name    = buffer.read_string
 
-            column_specs = ::Array.new(count) do |i|
+            column_specs = ::Array.new(count) do |_i|
               [keyspace_name, table_name, buffer.read_string, read_type_v4(buffer)]
             end
           else
-            column_specs = ::Array.new(count) do |i|
-              [buffer.read_string, buffer.read_string, buffer.read_string, read_type_v4(buffer)]
+            column_specs = ::Array.new(count) do |_i|
+              [
+                buffer.read_string,
+                buffer.read_string,
+                buffer.read_string,
+                read_type_v4(buffer)
+              ]
             end
           end
         end
@@ -194,17 +208,21 @@ module Cassandra
         when 0x0030
           keyspace = buffer.read_string
           name     = buffer.read_string
-          fields   = ::Array.new(buffer.read_short) { [buffer.read_string, read_type_v4(buffer)] }
+          fields   = ::Array.new(buffer.read_short) do
+            [buffer.read_string, read_type_v4(buffer)]
+          end
 
           Types.udt(keyspace, name, fields)
-        when 0x0031 then Types.tuple(*::Array.new(buffer.read_short) { read_type_v4(buffer) })
+        when 0x0031 then Types.tuple(
+          *::Array.new(buffer.read_short) { read_type_v4(buffer) }
+        )
         else
           raise Errors::DecodingError, %(Unsupported column type: #{id})
         end
       end
 
       def read_values_v4(buffer, column_metadata)
-        ::Array.new(buffer.read_int) do |i|
+        ::Array.new(buffer.read_int) do |_i|
           row = ::Hash.new
 
           column_metadata.each do |(_, _, column, type)|
@@ -274,11 +292,11 @@ module Cassandra
           values   = ::Hash.new
 
           fields.each do |field|
-            if length - buffer.length >= size
-              values[field.name] = nil
-            else
-              values[field.name] = read_value_v4(buffer, field.type)
-            end
+            values[field.name] = if length - buffer.length >= size
+                                   nil
+                                 else
+                                   read_value_v4(buffer, field.type)
+                                 end
           end
 
           Cassandra::UDT::Strict.new(keyspace, name, fields, values)
@@ -302,7 +320,7 @@ module Cassandra
       end
 
       def write_values_v3(buffer, values, types, names = EMPTY_LIST)
-        if values && values.size > 0
+        if values && !values.empty?
           buffer.append_short(values.size)
           values.zip(types, names) do |(value, type, name)|
             buffer.append_string(name) if name
@@ -378,7 +396,10 @@ module Cassandra
         when :text             then write_text(buffer, value)
         when :varint           then write_varint(buffer, value)
         when :list, :set       then write_list_v3(buffer, value, type.value_type)
-        when :map              then write_map_v3(buffer, value, type.key_type, type.value_type)
+        when :map              then write_map_v3(buffer,
+                                                 value,
+                                                 type.key_type,
+                                                 type.value_type)
         when :udt              then write_udt_v3(buffer, value, type.fields)
         when :tuple            then write_tuple_v3(buffer, value, type.members)
         else
@@ -387,7 +408,7 @@ module Cassandra
       end
 
       def read_values_v3(buffer, column_metadata)
-        ::Array.new(buffer.read_int) do |i|
+        ::Array.new(buffer.read_int) do |_i|
           row = ::Hash.new
 
           column_metadata.each do |(_, _, column, type)|
@@ -453,11 +474,11 @@ module Cassandra
           values   = ::Hash.new
 
           fields.each do |field|
-            if length - buffer.length >= size
-              values[field.name] = nil
-            else
-              values[field.name] = read_value_v3(buffer, field.type)
-            end
+            values[field.name] = if length - buffer.length >= size
+                                   nil
+                                 else
+                                   read_value_v3(buffer, field.type)
+                                 end
           end
 
           Cassandra::UDT::Strict.new(keyspace, name, fields, values)
@@ -493,12 +514,17 @@ module Cassandra
             keyspace_name = buffer.read_string
             table_name    = buffer.read_string
 
-            column_specs = ::Array.new(count) do |i|
+            column_specs = ::Array.new(count) do |_i|
               [keyspace_name, table_name, buffer.read_string, read_type_v3(buffer)]
             end
           else
-            column_specs = ::Array.new(count) do |i|
-              [buffer.read_string, buffer.read_string, buffer.read_string, read_type_v3(buffer)]
+            column_specs = ::Array.new(count) do |_i|
+              [
+                buffer.read_string,
+                buffer.read_string,
+                buffer.read_string,
+                read_type_v3(buffer)
+              ]
             end
           end
         end
@@ -531,17 +557,21 @@ module Cassandra
         when 0x0030
           keyspace = buffer.read_string
           name     = buffer.read_string
-          fields   = ::Array.new(buffer.read_short) { [buffer.read_string, read_type_v3(buffer)] }
+          fields   = ::Array.new(buffer.read_short) do
+            [buffer.read_string, read_type_v3(buffer)]
+          end
 
           Types.udt(keyspace, name, fields)
-        when 0x0031 then Types.tuple(*::Array.new(buffer.read_short) { read_type_v3(buffer) })
+        when 0x0031 then Types.tuple(
+          *::Array.new(buffer.read_short) { read_type_v3(buffer) }
+        )
         else
           raise Errors::DecodingError, %(Unsupported column type: #{id})
         end
       end
 
       def write_values_v1(buffer, values, types)
-        if values && values.size > 0
+        if values && !values.empty?
           buffer.append_short(values.size)
           values.each_with_index do |value, index|
             write_value_v1(buffer, value, types[index])
@@ -596,14 +626,17 @@ module Cassandra
         when :timeuuid, :uuid  then write_uuid(buffer, value)
         when :varint           then write_varint(buffer, value)
         when :list, :set       then write_list_v1(buffer, value, type.value_type)
-        when :map              then write_map_v1(buffer, value, type.key_type, type.value_type)
+        when :map              then write_map_v1(buffer,
+                                                 value,
+                                                 type.key_type,
+                                                 type.value_type)
         else
           raise Errors::EncodingError, %(Unsupported value type: #{type})
         end
       end
 
       def read_values_v1(buffer, column_metadata)
-        ::Array.new(buffer.read_int) do |i|
+        ::Array.new(buffer.read_int) do |_i|
           row = ::Hash.new
 
           column_metadata.each do |(_, _, column, type)|
@@ -644,7 +677,8 @@ module Cassandra
           value = ::Hash.new
 
           buffer.read_short.times do
-            value[read_short_value(buffer, key_type)] = read_short_value(buffer, value_type)
+            value[read_short_value(buffer, key_type)] =
+              read_short_value(buffer, value_type)
           end
 
           value
@@ -678,12 +712,17 @@ module Cassandra
             keyspace_name = buffer.read_string
             table_name    = buffer.read_string
 
-            column_specs = ::Array.new(count) do |i|
+            column_specs = ::Array.new(count) do |_i|
               [keyspace_name, table_name, buffer.read_string, read_type_v1(buffer)]
             end
           else
-            column_specs = ::Array.new(count) do |i|
-              [buffer.read_string, buffer.read_string, buffer.read_string, read_type_v1(buffer)]
+            column_specs = ::Array.new(count) do |_i|
+              [
+                buffer.read_string,
+                buffer.read_string,
+                buffer.read_string,
+                read_type_v1(buffer)
+              ]
             end
           end
         end
@@ -721,7 +760,7 @@ module Cassandra
       end
 
       def read_ascii(buffer)
-        value  = buffer.read_bytes
+        value = buffer.read_bytes
         value && value.force_encoding(::Encoding::ASCII)
       end
 
@@ -729,7 +768,7 @@ module Cassandra
         read_size(buffer) && buffer.read_long
       end
 
-      alias :read_counter :read_bigint
+      alias read_counter read_bigint
 
       def read_boolean(buffer)
         read_size(buffer) && buffer.read(1) == Constants::TRUE_BYTE
@@ -810,7 +849,7 @@ module Cassandra
         buffer.append_long(value)
       end
 
-      alias :write_counter :write_bigint
+      alias write_counter write_bigint
 
       def write_blob(buffer, value)
         buffer.append_bytes(value.encode(::Encoding::BINARY))