cassandra-driver 0.1.0.alpha1 → 1.0.0.beta.1

data/lib/cassandra/statements/bound.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  module Statements
+    # a Bound statement is created using {Cassandra::Statements::Prepared#bind}
+    class Bound
+      include Statement
+
+      # @return [String] original cql used to prepare this statement
+      attr_reader :cql
+      # @return [Array<Object>] a list of positional parameters for the cql
+      attr_reader :params
+      # @private
+      attr_reader :params_metadata, :result_metadata
+
+      # @private
+      def initialize(cql, params_metadata, result_metadata, params)
+        @cql             = cql
+        @params_metadata = params_metadata
+        @result_metadata = result_metadata
+        @params          = params
+      end
+
+      # @return [String] a CLI-friendly bound statement representation
+      def inspect
+        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @cql=#{@cql.inspect} @params=#{@params}>"
+      end
+    end
+  end
+end

data/lib/cassandra/statements/prepared.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  module Statements
+    class Prepared
+      include Statement
+
+      # @return [String] original cql used to prepare this statement
+      attr_reader :cql
+      # @return [Cassandra::Execution::Info] execution info for PREPARE request
+      attr_reader :execution_info
+
+      # @private
+      attr_reader :params_metadata
+      # @private
+      attr_reader :result_metadata
+
+      # @private
+      def initialize(cql, params_metadata, result_metadata, execution_info)
+        @cql             = cql
+        @params_metadata = params_metadata
+        @result_metadata = result_metadata
+        @execution_info  = execution_info
+      end
+
+      # Creates a statement bound with specific arguments
+      # @param args [*Object] arguments to bind, must contain the same number
+      #   of parameters as the number of positional arguments (`?`) in the
+      #   original cql passed to {Cassandra::Session#prepare}
+      # @return [Cassandra::Statements::Bound] bound statement
+      def bind(*args)
+        raise ::ArgumentError, "expecting exactly #{@params_metadata.size} bind parameters, #{args.size} given" if args.size != @params_metadata.size
+
+        Bound.new(@cql, @params_metadata, @result_metadata, args)
+      end
+
+      # @return [String] a CLI-friendly prepared statement representation
+      def inspect
+        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @cql=#{@cql.inspect}>"
+      end
+    end
+  end
+end

data/lib/cassandra/statements/simple.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  module Statements
+    class Simple
+      include Statement
+
+      # @return [String] original cql used to prepare this statement
+      attr_reader :cql
+      # @return [Array<Object>] a list of positional parameters for the cql
+      attr_reader :params
+
+      # @param cql [String] a cql statement
+      # @param params [*Object] positional arguments for the query
+      #
+      # @raise [ArgumentError] if cql statement given is not a String
+      def initialize(cql, *params)
+        unless cql.is_a?(::String)
+          raise ::ArgumentError, "cql must be a string, #{cql.inspect} given"
+        end
+
+        @cql    = cql
+        @params = params
+      end
+
+      # @return [String] a CLI-friendly simple statement representation
+      def inspect
+        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @cql=#{@cql.inspect} @params=#{@params.inspect}>"
+      end
+
+      # @param other [Object, Cassandra::Statements::Simple] object to compare
+      # @return [Boolean] whether the statements are equal
+      def eql?(other)
+        other.is_a?(Simple) &&
+          @cql == other.cql &&
+          @params == other.params
+      end
+
+      alias :== :eql?
+    end
+  end
+end

data/lib/cassandra/statements/void.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  module Statements
+    # This statement is passed to {Cassandra::LoadBalancing::Policy#plan} when
+    # establishing connections and preparing statements
+    class Void
+      include Statement
+
+      # Returns nothing
+      # @return [nil] there is no cql for the void statement
+      def cql
+        nil
+      end
+    end
+  end
+end

data/lib/cassandra/table.rb

@@ -0,0 +1,254 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 table
+  # @see Cassandra::Keyspace#each_table
+  # @see Cassandra::Keyspace#table
+  class Table
+    # @private
+    class Options
+      attr_reader :comment, :read_repair_chance, :local_read_repair_chance,
+                  :gc_grace_seconds, :caching, :bloom_filter_fp_chance,
+                  :populate_io_cache_on_flush, :memtable_flush_period_in_ms,
+                  :default_time_to_live, :speculative_retry, :index_interval,
+                  :replicate_on_write, :compaction_strategy, :compact_storage,
+                  :compression_parameters
+
+      def initialize(data, compaction_strategy, compression_parameters, compact_storage, cassandra_version)
+        @comment                     = data['comment']
+        @read_repair_chance          = data['read_repair_chance']
+        @local_read_repair_chance    = data['local_read_repair_chance']
+        @gc_grace_seconds            = data['gc_grace_seconds']
+        @caching                     = data['caching']
+        @bloom_filter_fp_chance      = data['bloom_filter_fp_chance']      || 0.01
+        @populate_io_cache_on_flush  = data['populate_io_cache_on_flush']  || false
+        @memtable_flush_period_in_ms = data['memtable_flush_period_in_ms'] || 0
+        @default_time_to_live        = data['default_time_to_live']        || 0
+        @speculative_retry           = data['speculative_retry']           || 'NONE'
+        @index_interval              = data['index_interval']              || 128
+        @replicate_on_write          = data['replicate_on_write']          || true
+        @compaction_strategy         = compaction_strategy
+        @compression_parameters      = compression_parameters
+        @compact_storage             = compact_storage
+        @cassandra_version           = cassandra_version
+      end
+
+      def replicate_on_write?
+        @replicate_on_write
+      end
+
+      def populate_io_cache_on_flush?
+        @populate_io_cache_on_flush
+      end
+
+      def compact_storage?
+        @compact_storage
+      end
+
+      def to_cql
+        options = []
+
+        options << 'COMPACT STORAGE' if @compact_storage
+        options << "bloom_filter_fp_chance = #{@bloom_filter_fp_chance}"
+        options << "caching = '#{@caching}'"
+        options << "comment = '#{@comment}'" if @comment
+        options << "compaction = #{@compaction_strategy.to_cql}"
+        options << "compression = #{Util.encode_hash(@compression_parameters)}"
+        options << "dclocal_read_repair_chance = #{@local_read_repair_chance}"
+        options << "default_time_to_live = #{@default_time_to_live}" if !@cassandra_version.start_with?('1')
+        options << "gc_grace_seconds = #{@gc_grace_seconds}"
+        options << "index_interval = #{@index_interval}" if !@cassandra_version.start_with?('1')
+        options << "populate_io_cache_on_flush = '#{@populate_io_cache_on_flush}'"
+        options << "read_repair_chance = #{@read_repair_chance}"
+        options << "replicate_on_write = '#{@replicate_on_write}'" if @cassandra_version.start_with?('1') || @cassandra_version.start_with?('2.0')
+        options << "speculative_retry = '#{@speculative_retry}'" if !@cassandra_version.start_with?('1')
+
+        options.join("\nAND ")
+      end
+
+      def eql?(other)
+        other.is_a?(Options) &&
+          @comment == other.comment &&
+          @read_repair_chance == other.read_repair_chance &&
+          @local_read_repair_chance == other.local_read_repair_chance &&
+          @gc_grace_seconds == other.gc_grace_seconds &&
+          @caching == other.caching &&
+          @bloom_filter_fp_chance == other.bloom_filter_fp_chance &&
+          @populate_io_cache_on_flush == other.populate_io_cache_on_flush &&
+          @memtable_flush_period_in_ms == other.memtable_flush_period_in_ms &&
+          @default_time_to_live == other.default_time_to_live &&
+          @speculative_retry == other.speculative_retry &&
+          @index_interval == other.index_interval &&
+          @replicate_on_write == other.replicate_on_write &&
+          @compaction_strategy == other.compaction_strategy &&
+          @compression_parameters == other.compression_parameters &&
+          @compact_storage == other.compact_storage &&
+          @cassandra_version == other.cassandra_version
+      end
+      alias :== :eql?
+
+      attr_reader :cassandra_version
+      protected :cassandra_version
+    end
+
+    # @private
+    class Compaction
+      attr_reader :klass, :options
+
+      def initialize(klass, options)
+        @klass   = klass
+        @options = options
+      end
+
+      def to_cql
+        compaction = {'class' => @klass}
+        compaction.merge!(@options)
+
+        Util.encode_hash(compaction)
+      end
+
+      def eql?(other)
+        other.is_a?(Compaction) &&
+          @klass == other.klass &&
+          @options == other.options
+      end
+      alias :== :eql?
+    end
+
+    # @private
+    attr_reader :keyspace
+    # @return [String] table name
+    attr_reader :name
+    # @private
+    attr_reader :options
+
+    # @private
+    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order)
+      @keyspace           = keyspace
+      @name               = name
+      @partition_key      = partition_key
+      @clustering_columns = clustering_columns
+      @columns            = columns
+      @options            = options
+      @clustering_order   = clustering_order
+    end
+
+    # @param name [String] column name
+    # @return [Boolean] whether this table has a given column
+    def has_column?(name)
+      @columns.has_key?(name)
+    end
+
+    # @param name [String] column name
+    # @return [Cassandra::Column, nil] a column or nil
+    def column(name)
+      @columns[name]
+    end
+
+    # Yield or enumerate each column defined in this table
+    # @overload each_column
+    #   @yieldparam column [Cassandra::Column] current column
+    #   @return [Array<Cassandra::Column>] a list of columns
+    # @overload each_column
+    #   @return [Enumerator<Cassandra::Column>] an enumerator
+    def each_column(&block)
+      @columns.values.each(&block)
+    end
+    alias :columns :each_column
+
+    # @return [String] a cql representation of this table
+    def to_cql
+      cql   = "CREATE TABLE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+      first = true
+      @columns.each do |(_, column)|
+        next if column.name.empty?
+        if first
+          first = false
+        else
+          cql << ",\n" unless first
+        end
+        cql << "  #{column.to_cql}"
+      end
+      cql << ",\n  PRIMARY KEY ("
+      if @partition_key.one?
+        cql << @partition_key.first.name
+      else
+        cql << '('
+        first = true
+        @partition_key.each do |column|
+          if first
+            first = false
+          else
+            cql << ', '
+          end
+          cql << column.name
+        end
+        cql << ')'
+      end
+      @clustering_columns.each do |column|
+        cql << ", #{column.name}"
+      end
+      cql << ')'
+
+      cql << "\n)\nWITH "
+
+      if @clustering_order.any? {|o| o != :asc}
+        cql << "CLUSTERING ORDER BY ("
+        first = true
+        @clustering_columns.zip(@clustering_order) do |column, order|
+          if first
+            first = false
+          else
+            cql << ', '
+          end
+          cql << "#{column.name} #{order.to_s.upcase}"
+        end
+        cql << ")\n AND "
+      end
+
+      cql << @options.to_cql.split("\n").join("\n ")
+
+      cql << ';'
+    end
+
+    # @return [Boolean] whether this table is equal to the other
+    def eql?(other)
+      other.is_a?(Table) &&
+        @keyspace == other.keyspace &&
+        @name == other.name &&
+        @partition_key == other.partition_key &&
+        @clustering_columns == other.clustering_columns &&
+        @columns == other.raw_columns &&
+        @options == other.options &&
+        @clustering_order == other.clustering_order
+    end
+    alias :== :eql?
+
+    # @private
+    attr_reader :partition_key, :clustering_columns, :clustering_order
+    protected :partition_key, :clustering_columns, :clustering_order
+
+    protected
+
+    # @private
+    def raw_columns
+      @columns
+    end
+  end
+end