believer 0.2.5 → 0.2.6

data/README.md

@@ -47,9 +47,36 @@ This is the class you should extend from.
 #### The column class method
 Defines the mapping between a Ruby object attribute and a Cassandra column. Also defines a getter and setter attribute with the same name.
 The second argument is a Hash, which support the following keys:
-* type: the data type. Supported values are: :string, :integer, :float, :timestamp, :time
+* type: the data type. Supported values are: :string, :integer, :float, :timestamp, :time, :array, :set, :map
 * cql_type: the CQL data type.
-For type determination, you must include either or both the :type or the :cql_type options.
+* element_type: sets the type of elements in a collection if the type is a :set (CQL type SET) or an :array (CQL type LIST)
+* key_type; set the type of the hash keys is the type is a :hash (CQL type MAP)
+* value_type; set the type of the hash values is the type is a :hash (CQL type MAP)
+
+Note: for correct type determination, you must include either or both the :type or the :cql_type options.
+
+#### Counters
+You can use CQL counters by setting the column type to :counter. The internal value is a Believer::Counter instance,
+and can be manipulated in the following ways:
+
+``` ruby
+class AlbumSales < Believer::Base
+    column :artist_name
+    column :name
+
+    column :sales, :type => :counter
+
+    primary_key :artist_name, :name
+end
+
+album_sales = AlbumSales.new
+album_sales.sales # Returns a Believer::Counter, with a value of 0
+album_sales.sales.incr # Increment counter by 1, value is 1
+album_sales.sales.incr(6) # Increment counter by 3, value is 7
+album_sales.sales.decr # Decrement counter by 1, value is 6
+album_sales.sales.decr(3) # Decrement counter by 3, value is 3
+album_sales.sales.reset! # Reset it to the initial value, which is 0
+```
 
 #### The primary_key class method
 Sets the primary key columns of the class.

data/lib/believer.rb

@@ -19,6 +19,7 @@ require 'believer/environment/rails_env'
 require 'believer/environment/merb_env'
 require 'believer/environment'
 require 'believer/connection'
+require 'believer/counter'
 require 'believer/values'
 require 'believer/column'
 require 'believer/columns'
@@ -32,6 +33,7 @@ require 'believer/filter_command'
 require 'believer/query'
 require 'believer/empty_result'
 require 'believer/delete'
+require 'believer/update'
 require 'believer/insert'
 require 'believer/querying'
 require 'believer/scoping'
@@ -44,6 +46,9 @@ require 'believer/log_subscriber'
 require 'believer/observer'
 require 'believer/relation'
 
+require 'believer/create_table'
+require 'believer/drop_table'
 require 'believer/ddl'
+require 'believer/counting'
 require 'believer/base'
 

data/lib/believer/base.rb

@@ -12,6 +12,7 @@ module Believer
     extend Querying
     extend FinderMethods
     include Callbacks
+    include Counting
     include DDL
 
     include ::ActiveModel::Observing
@@ -21,10 +22,7 @@ module Believer
 
     def initialize(attrs = {})
       @attributes = {}
-      attrs.each do |name, val|
-        send("#{name}=".to_sym, val)
-      end if attrs.present?
-
+      set_attributes(attrs)
       yield self if block_given?
     end
 
@@ -32,6 +30,20 @@ module Believer
       new(row)
     end
 
+    def reload!
+      persisted_object = self.class.scoped.where(key_values).first
+      unless persisted_object.nil?
+        set_attributes(persisted_object.attributes)
+      end
+      self
+    end
+
+    def set_attributes(attrs)
+      attrs.each do |name, val|
+        send("#{name}=".to_sym, val)
+      end if attrs.present?
+    end
+
     def ==(obj)
       eql?(obj)
     end

data/lib/believer/column.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Believer
 
   # Represents a Cassandra table column
@@ -9,7 +11,7 @@ module Believer
         :bigint => {:ruby_type => :integer}, # integers 64-bit signed long
         :blob => {:ruby_type => :string}, # blobs Arbitrary bytes (no validation), expressed as hexadecimal
         :boolean => {:ruby_type => :boolean}, # booleans true or false
-        :counter => {:ruby_type => :integer}, # integers Distributed counter value (64-bit long)
+        :counter => {:ruby_type => :counter}, # integers Distributed counter value (64-bit long)
         :decimal => {:ruby_type => :float}, # integers, floats Variable-precision decimal
         :double => {:ruby_type => :float}, # integers 64-bit IEEE-754 floating point
         :float => {:ruby_type => :float}, # integers, floats 32-bit IEEE-754 floating point
@@ -17,25 +19,35 @@ module Believer
         :int => {:ruby_type => :integer}, # integers 32-bit signed integer
         :list => {:ruby_type => :array}, # n/a A collection of one or more ordered elements
         :map => {:ruby_type => :hash}, # n/a A JSON-style array of literals: { literal : literal, literal : literal ... }
-        :set => {:ruby_type => :array}, # n/a A collection of one or more elements
+        :set => {:ruby_type => :set}, # n/a A collection of one or more elements
         :text => {:ruby_type => :string}, # strings UTF-8 encoded string
         :timestamp => {:ruby_type => :time}, # integers, strings Date plus time, encoded as 8 bytes since epoch
         :uuid => {:ruby_type => :string}, # uuids A UUID in standard UUID format
         :timeuuid => {:ruby_type => :integer}, # uuids Type 1 UUID only (CQL 3)
         :varchar => {:ruby_type => :string}, # strings UTF-8 encoded string
-        :varint => {:ruby_type => :integer}, # integers Arbitrary-precision integer
+        :varint => {:ruby_type => :integer} # integers Arbitrary-precision integer
     }
 
     # Supported Ruby 'types'
     RUBY_TYPES = {
+        :symbol => {:default_cql_type => :varchar},
         :integer => {:default_cql_type => :int},
         :string => {:default_cql_type => :varchar},
         :time => {:default_cql_type => :timestamp},
         :timestamp => {:default_cql_type => :timestamp},
-        :float => {:default_cql_type => :float}
+        :float => {:default_cql_type => :float},
+        :array => {:default_cql_type => :list},
+        :set => {:default_cql_type => :set},
+        :hash => {:default_cql_type => :map},
+        :counter => {:default_cql_type => :counter, :default_value => lambda { Counter.new } }
     }
 
-    attr_reader :name, :type, :cql_type
+    attr_reader :name,
+                :ruby_type,
+                :cql_type,
+                :element_type,
+                :key_type,
+                :value_type
 
     # Creates a new instance.
     # @param opts [Hash] values options
@@ -48,16 +60,69 @@ module Believer
       raise "Invalid type #{opts[:type]}" unless RUBY_TYPES.has_key?(opts[:type])
 
       @name = opts[:name]
-      @type = opts[:type].nil? ? CQL_TYPES[opts[:cql_type]][:ruby_type] : opts[:type]
+      @ruby_type = opts[:type].nil? ? CQL_TYPES[opts[:cql_type]][:ruby_type] : opts[:type]
       @cql_type = opts[:cql_type].nil? ? RUBY_TYPES[opts[:type]][:default_cql_type] : opts[:cql_type]
+
+      @element_type = opts[:element_type]
+      @key_type = opts[:key_type]
+      @value_type = opts[:value_type]
+
+      @default_value = opts[:default_value]
+
+
     end
 
     # Converts the value to a one that conforms to the type of this column
     # @param v [Object] the value
     def convert_to_type(v)
-      convert_method = "convert_to_#{@type}".to_sym
-      return self.send(convert_method, v) if respond_to?(convert_method)
-      v
+      # TODO: kind of a dirty hack, this...
+      case @ruby_type
+        when :array
+          return convert_to_array(v, element_type)
+        when :set
+          return convert_to_set(v, element_type)
+        when :hash
+          return convert_to_hash(v, key_type, value_type)
+      end
+      convert_value_to_type(v, @ruby_type)
+    end
+
+    def to_cql
+      col_stmt = "#{name} #{cql_type}"
+      if cql_type == :list
+        col_stmt << "<#{to_cql_type(element_type)}>"
+      elsif cql_type == :set
+        col_stmt << "<#{to_cql_type(element_type)}>"
+      elsif cql_type == :map
+        col_stmt << "<#{to_cql_type(key_type)},#{to_cql_type(value_type)}>"
+      end
+      col_stmt
+    end
+
+    def has_default_value?
+      (@default_value != nil) || RUBY_TYPES[ruby_type][:default_value] != nil
+    end
+
+    def default_value
+      def_val = @default_value || RUBY_TYPES[ruby_type][:default_value]
+      unless def_val.nil?
+        return def_val.call if def_val.is_a?(Proc)
+        return def_val
+      end
+      nil
+    end
+
+    private
+    def to_cql_type(t)
+      return t if CQL_TYPES.has_key?(t)
+      return RUBY_TYPES[t][:default_cql_type] if RUBY_TYPES.has_key?(t)
+      nil
+    end
+
+    def to_ruby_type(t)
+      return t if RUBY_TYPES.has_key?(t)
+      return CQL_TYPES[t][:ruby_type] if CQL_TYPES.has_key?(t)
+      nil
     end
 
   end

data/lib/believer/columns.rb

@@ -47,6 +47,10 @@ module Believer
         end
       end
 
+      def columns_with_type(t)
+        columns.values.find_all {|col| col.ruby_type == t}
+      end
+
       def primary_key(*cols)
         @primary_key = *cols
       end
@@ -91,13 +95,26 @@ module Believer
     end
 
     def read_attribute(attr_name)
+      col = self.class.columns[attr_name]
+      if !@attributes.has_key?(attr_name) && col && col.has_default_value?
+        write_attribute(attr_name, col.default_value)
+      end
       @attributes[attr_name]
     end
 
     def write_attribute(attr_name, value)
       v = value
       # Convert the value to the actual type
-      v = self.class.columns[attr_name].convert_to_type(v) unless self.class.columns[attr_name].nil?
+      col = self.class.columns[attr_name]
+      unless col.nil?
+        cur_val = @attributes[attr_name]
+        if cur_val && cur_val.respond_to?(:adopt_value)
+          cur_val.adopt_value(value)
+          v = cur_val
+        else
+          v = col.convert_to_type(v)
+        end
+      end
       @attributes[attr_name] = v
     end
 

data/lib/believer/command.rb

@@ -28,7 +28,13 @@ module Believer
       self.class.name.split('::').last.underscore
     end
 
+    def can_execute?
+      true
+    end
+
     def execute(name = nil)
+      return false unless can_execute?
+
       @record_class.connection_pool.with do |connection|
         cql = to_cql
         begin
@@ -36,7 +42,12 @@ module Believer
           return ActiveSupport::Notifications.instrument('cql.believer', :cql => cql, :name => name) do
             exec_opts = {}
             exec_opts[:consistency] = consistency_level unless consistency_level.nil?
-            return connection.execute(cql, exec_opts)
+            begin
+              return connection.execute(cql, exec_opts)
+            rescue Cql::NotConnectedError => not_connected
+              connection.connect
+              return connection.execute(cql, exec_opts)
+            end
           end
         rescue Cql::Protocol::DecodingError => e
           # Decoding errors tend to #$%# up the connection, resulting in no more activity, so a reconnect is performed here.

data/lib/believer/counter.rb

@@ -0,0 +1,60 @@
+module Believer
+
+  class Counter
+
+    def initialize(v = 0, initial_val = nil)
+      @value = v
+      @initial_value = initial_val.nil? ? @value : initial_val
+    end
+
+    def reset!
+      @value = initial_value
+      self
+    end
+
+    def adopt_value(v)
+      @value = 0 if v.nil?
+      @value = v.to_i
+      self
+    end
+
+    def incr(val = 1)
+      @value = @value + val
+      self
+    end
+
+    def incremented?
+      @value > initial_value
+    end
+
+    def decr(val = 1)
+      @value = @value - val
+      self
+    end
+
+    def decremented?
+      initial_value > @value
+    end
+
+    def diff
+      (@value - initial_value).abs
+    end
+
+    def changed?
+      diff > 0
+    end
+
+    def to_i
+      @value
+    end
+
+    def initial_value
+      if @initial_value.nil?
+        @initial_value = self.to_i
+      end
+      @initial_value
+    end
+
+  end
+
+end

data/lib/believer/counting.rb

@@ -0,0 +1,29 @@
+module Believer
+  module Counting
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+
+      def counter_columns
+        columns_with_type(:counter)
+      end
+
+      def is_counter_table?
+        counter_columns.any?
+      end
+
+    end
+
+    def is_counter_instance?
+      self.class.is_counter_table?
+    end
+
+    def has_counter_diffs?
+      self.class.counter_columns.any? do |col|
+        counter = self.send(col.name)
+        counter && counter.diff > 0
+      end
+    end
+
+  end
+end

data/lib/believer/cql_helper.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Believer
 
   # Contains various methods for dealing with CQL statements
@@ -10,9 +12,29 @@ module Believer
     def to_cql_literal(value)
       return 'NULL' if value.nil?
       return "'#{value}'" if value.is_a?(String)
+      return "'#{value}'" if value.is_a?(Symbol)
       return "#{value}" if value.is_a?(Numeric)
       return "'#{value.strftime(CQL_TIMESTAMP_FORMAT)}'" if value.is_a?(Time) || value.is_a?(DateTime)
       #return "#{value.to_i * 1000}" if value.is_a?(Time) || value.is_a?(DateTime)
+
+      if value.is_a?(Counter)
+
+      end
+
+      # Set
+      if value.is_a?(Set)
+        return "{#{value.map {|v| to_cql_literal(v)}.join(',')}}"
+      end
+
+      # Map
+      if value.is_a?(Hash)
+        keys = value.keys
+        return "{#{keys.map {|k| "#{to_cql_literal(k)} : #{to_cql_literal(value[k])}" }.join(',')} }"
+      end
+
+      # List
+      return "[#{value.map {|v| to_cql_literal(v)}.join(',')}]" if value.is_a?(Array)
+
       return nil
     end
 

data/lib/believer/create_table.rb

@@ -0,0 +1,24 @@
+module Believer
+  class CreateTable < Command
+
+    def to_cql
+      keys = []
+      record_class.get_primary_key.each do |key_part|
+        if key_part.is_a?(Enumerable)
+          keys << "(#{key_part.join(',')})"
+        else
+          keys << key_part
+        end
+      end
+
+      s = "CREATE TABLE #{record_class.table_name} (\n"
+      col_statement_parts = record_class.columns.keys.map {|col_name| record_class.columns[col_name].to_cql }
+      s << col_statement_parts.join(",\n")
+      s << ",\n"
+      s << "PRIMARY KEY (#{keys.join(',')})"
+      s << "\n)"
+      s
+    end
+
+  end
+end