cql-model 0.3.0

data/lib/cql/model/query/statement.rb

@@ -0,0 +1,44 @@
+module Cql::Model::Query
+
+  class Statement
+
+    # Initialize instance variables common to all statements
+    #
+    # @param [Class] klass Model class
+    # @param [Cql::Client] client used to connect to Cassandra
+    def initialize(klass, client)
+      @klass       = klass
+      @client      = client || klass.cql_client
+      @consistency = nil
+    end
+
+    # Build a string representation of this CQL statement, suitable for execution by a CQL client.
+    # @return [String]
+    def to_s
+      raise NotImplementedError, "Subclass responsibility"
+    end
+
+    # Execute this CQL statement. Return value and parameters vary for each derived class.
+    # @see SelectStatement#execute
+    # @see InsertStatement#execute
+    # @see UpdateStatement#execute
+    def execute
+      raise NotImplementedError, "Subclass responsibility"
+    end
+
+    # Specify consistency level to use when executing statemnt
+    # See http://www.datastax.com/docs/1.0/dml/data_consistency
+    # Defaults to :local_quorum
+    #
+    # @param [String] consistency One of 'ANY', 'ONE', 'QUORUM', 'LOCAL_QUORUM', 'EACH_QUORUM', 'ALL' as of Cassandra 1.0
+    # @return [String] consistency value
+    def consistency(consist)
+      raise ArgumentError, "Cannot specify USING CONSISTENCY twice" unless @consistency.nil?
+      @consistency = consist
+      self
+    end
+
+    alias using_consistency consistency
+  end
+
+end

data/lib/cql/model/query/update_expression.rb

@@ -0,0 +1,104 @@
+require 'set'
+
+module Cql::Model::Query
+  # @TODO docs
+  class UpdateExpression < Expression
+    # Operators allowed in an update lambda
+    OPERATORS = {
+      :+   => '+',
+      :-   => '-',
+      :[]= => true # special treatment in #__build__
+    }.freeze
+
+    # @TODO docs
+    def initialize(&block)
+      @left     = nil
+      @operator = nil
+      @right    = nil
+
+      instance_exec(&block) if block
+    end
+
+    # @TODO docs
+    def to_s
+      __build__
+    end
+
+    # @TODO docs
+    def inspect
+      __build__
+    end
+
+    # This is where the magic happens. Ensure all of our operators are overloaded so they call
+    # #apply and contribute to the CQL expression that will be built.
+    OPERATORS.keys.each do |op|
+      define_method(op) do |*args|
+        __apply__(op, args)
+      end
+    end
+
+    # @TODO docs
+    def method_missing(token, *args)
+      __apply__(token, args)
+    end
+
+    private
+
+    # @TODO docs
+    def __apply__(token, args)
+      if @left.nil?
+        if args.empty?
+          # A well-behaved CQL identifier (column name that is a valid Ruby method name)
+          @left = token
+        elsif args.length == 1
+          # A CQL typecast (column name that is an integer, float, etc and must be wrapped in a decorator)
+          @left = args.first
+        else
+          ::Kernel.raise ::Cql::Model::SyntaxError.new(
+                           "Unacceptable token '#{token}'; expected a CQL identifier or typecast")
+        end
+      elsif @operator.nil?
+        # Looking for an operator + right operand
+        if OPERATORS.keys.include?(token)
+          @operator = token
+
+          if (token == :[]=)
+            @right = args # the right-hand argument of []= is a (key, value) pair
+          else
+            @right = args.first
+          end
+        else
+          ::Kernel.raise ::Cql::Model::SyntaxError.new(
+                           "Unacceptable token '#{token}'; expected a CQL-compatible operator")
+        end
+      else
+        ::Kernel.raise ::Cql::Model::SyntaxError.new(
+                         "Unacceptable token '#{token}'; the expression is " +
+                           "already complete")
+      end
+
+      self
+    end
+
+    # @TODO docs
+    def __build__
+      if @left.nil? || @operator.nil? || @right.nil?
+        ::Kernel.raise ::Cql::Model::SyntaxError.new(
+                         "Cannot build a CQL expression; the Ruby expression is incomplete " +
+                           "(#{@left.inspect}, #{@operator.inspect}, #{@right.inspect})")
+      else
+        left = ::Cql::Model::Query.cql_identifier(@left)
+        case @operator
+        when :[]=
+          key = ::Cql::Model::Query.cql_value(@right[0], context=:update)
+          val = ::Cql::Model::Query.cql_value(@right[1], context=:update)
+          "#{left}[#{key}] = #{val}"
+        else
+          op    = OPERATORS[@operator]
+          right = ::Cql::Model::Query.cql_value(@right, context=:update)
+          "#{left} #{op} #{right}"
+        end
+      end
+    end
+  end
+end

data/lib/cql/model/query/update_statement.rb

@@ -0,0 +1,91 @@
+module Cql::Model::Query
+
+  # UPDATE statement DSL
+  # << An UPDATE writes one or more columns to a record in a Cassandra column family. No results are returned.
+  #    Row/column records are created if they do not exist, or overwritten if they do exist >>
+  # (from http://www.datastax.com/docs/1.1/references/cql/UPDATE)
+  #
+  # Note: user a hash with a single key :value to update counter columns using the existing counter value:
+  #   update(:id => 12, :counter => { :value => 'counter + 1' })
+  #
+  # E.g.:
+  # Model.update(:id => '123', :col => 'value', :counter => { :value => 'counter + 2' })
+  # Model.update(:id => ['123', '456'], :col => 'value')
+  # Model.update(:id => '123', :col => 'value').ttl(3600)
+  # Model.update(:id => '123', :col => 'value').timestamp(1366057256324)
+  # Model.update(:id => '123', :col => 'value').timestamp('2013-04-15 13:21:48')
+  # Model.update(:id => '123', :col => 'value').consistency('ONE')
+  # Model.update(:id => ['123', '456'], :col => 'value', :counter => 'counter + 2').ttl(3600).timestamp(1366057256324).consistency('ONE')
+  #
+  # Can also be used on Model instances, e.g.:
+  # @model.update(:col => 'value', :counter => 'counter + 2')
+  # @model.update_all_by('name', :col => 'value') # 'name' must be part of the table composite key
+  class UpdateStatement < MutationStatement
+    def initialize(klass, client=nil)
+      super(klass, client)
+      @where = []
+    end
+
+    # Create or append to the WHERE clause for this statement. The block that you pass will define the constraint
+    # and any where() parameters will be forwarded to the block as yield parameters. This allows late binding of
+    # variables in the WHERE clause, e.g. for prepared statements.
+    # TODO examples
+    # @see Expression
+    def where(*params, &block)
+      @where << ComparisonExpression.new(*params, &block)
+      self
+    end
+
+    alias and where
+
+    # DSL for setting UPDATE values
+    #
+    # @param [Hash] values Hash of column values or column update expression indexed by column name
+    def update(values)
+      raise ArgumentError, "Cannot specify UPDATE values twice" unless @values.nil?
+      @values = values
+      self
+    end
+
+    # @return [String] a CQL UPDATE statement with suitable constraints and options
+    def to_s
+      s = "UPDATE #{@klass.table_name}"
+
+      options = []
+      options << "CONSISTENCY #{@consistency || @klass.write_consistency}"
+      options << "TIMESTAMP #{@timestamp}" unless @timestamp.nil?
+      options << "TTL #{@ttl}" unless @ttl.nil?
+      s << " USING #{options.join(' AND ')}"
+
+      if @values.respond_to?(:map)
+        if @values.respond_to?(:each_pair)
+          # List of column names and values (or lambdas containing list/set/counter operations)
+          pairs = @values.map do |n, v|
+            if v.respond_to?(:call)
+              "#{n} = #{UpdateExpression.new(&v).to_s}"
+            else
+              "#{n} = #{::Cql::Model::Query.cql_value(v)}"
+            end
+          end
+          s << " SET #{pairs.join(', ')}"
+        elsif @values.all? { |v| v.respond_to?(:call) }
+          # Array of hash assignments
+          assigns = @values.map { |v| "#{UpdateExpression.new(&v).to_s}" }
+          s << " SET #{assigns.join(', ')}"
+        end
+      elsif @values.respond_to?(:call)
+        # Simple hash assignment
+        assign = UpdateExpression.new(&@values).to_s
+        s << " SET #{assign}"
+      end
+
+      unless @where.empty?
+        s << " WHERE " << @where.map { |w| w.to_s }.join(' AND ')
+      end
+
+      s << ';'
+
+      s
+    end
+  end
+end

metadata

@@ -0,0 +1,227 @@
+--- !ruby/object:Gem::Specification
+name: cql-model
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Tony Spataro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cql-rb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: syntax
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Lightweight, performant OOP wrapper for Cassandra tables; inspired by
+  DataMapper.
+email: gemspec@tracker.xeger.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- cql-model.gemspec
+- cql_model.rconf
+- lib/cql/model.rb
+- lib/cql/model/class_methods.rb
+- lib/cql/model/instance_methods.rb
+- lib/cql/model/query.rb
+- lib/cql/model/query/comparison_expression.rb
+- lib/cql/model/query/expression.rb
+- lib/cql/model/query/insert_statement.rb
+- lib/cql/model/query/mutation_statement.rb
+- lib/cql/model/query/select_statement.rb
+- lib/cql/model/query/statement.rb
+- lib/cql/model/query/update_expression.rb
+- lib/cql/model/query/update_statement.rb
+homepage: https://github.com/xeger/cql-model
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Cassandra CQL model.
+test_files: []