datastax_rails 1.0.5

data/lib/datastax_rails/consistency.rb

@@ -0,0 +1,33 @@
+module DatastaxRails
+  module Consistency
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :consistency_levels
+      self.consistency_levels = [:one, :quorum, :all]
+
+      class_attribute :write_consistency
+      class_attribute :read_consistency
+      self.write_consistency  = :quorum
+      self.read_consistency   = :quorum
+    end
+
+    module ClassMethods
+      THRIFT_LEVELS = {
+        :one    => 'ONE',
+        :quorum => 'QUORUM',
+        :local_quorum => 'LOCAL_QUORUM',
+        :each_quorum => 'EACH_QUORUM',
+        :all => 'ALL'
+      }
+
+      def thrift_read_consistency
+        THRIFT_LEVELS[read_consistency] || (raise "Invalid consistency level #{read_consistency}")
+      end
+
+      def thrift_write_consistency
+        THRIFT_LEVELS[write_consistency] || (raise "Invalid consistency level #{write_consistency}")
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/base.rb

@@ -0,0 +1,15 @@
+module DatastaxRails
+  module Cql
+    class Base
+      def to_cql #:nodoc:
+        nil
+      end
+      
+      def execute
+        cql = self.to_cql
+        Rails.logger.debug(cql)
+        DatastaxRails::Base.connection.execute_cql_query(cql)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/column_family.rb

@@ -0,0 +1,38 @@
+module DatastaxRails
+  module Cql
+    class ColumnFamily
+      def initialize(klass)
+        @klass = klass
+      end
+      
+      def create_column_family
+        DatastaxRails::Cql::CreateColumnFamily.new(@klass.column_family)
+      end
+      
+      def delete(*keys)
+        DatastaxRails::Cql::Delete.new(@klass, keys.flatten)
+      end
+      
+      def insert
+        DatastaxRails::Cql::Insert.new(@klass)
+      end
+      
+      def drop_column_family
+        DatastaxRails::Cql::DropColumnFamily.new(@klass.column_family)
+      end
+      
+      def select(*columns)
+        columns << "*" if columns.empty?
+        DatastaxRails::Cql::Select.new(@klass, columns.flatten)
+      end
+
+      def truncate
+        DatastaxRails::Cql::Truncate.new(@klass)
+      end
+      
+      def update(*keys)
+        DatastaxRails::Cql::Update.new(@klass, keys.flatten)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/consistency.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    module Consistency
+      ONE = 'ONE'
+      QUORUM = 'QUORUM'
+      LOCAL_QUORUM = 'LOCAL_QUORUM'
+      EACH_QUORUM = 'EACH_QUORUM'
+      ALL = 'ALL'
+      
+      VALID_CONSISTENCY_LEVELS = [ONE, QUORUM, LOCAL_QUORUM, EACH_QUORUM, ALL]
+    end
+  end
+end

data/lib/datastax_rails/cql/create_column_family.rb

@@ -0,0 +1,63 @@
+module DatastaxRails#:nodoc:
+  module Cql #:nodoc:
+    class CreateColumnFamily < Base #:nodoc:
+      def initialize(cf_name)
+        @cf_name = cf_name
+        @columns = {}
+        @storage_parameters = {}
+        @key_type = 'uuid'
+      end
+      
+      def key_type(key_type)
+        @key_type = key_type
+        self
+      end
+      
+      def with(with)
+        @storage_parameters.merge!(with)
+        self
+      end
+      
+      def columns(columns)
+        @columns.merge! columns
+        self
+      end
+      
+      # Migration helpers
+      def comment=(comment)
+        with("comment" => comment)
+      end
+      
+      def comparator=(comp)
+        with("comparator" => comp)
+      end
+      
+      def default_validation=(val)
+        with("default_validation" => val)
+      end
+      
+      def column_type=(type)
+        # TODO: Ignored till CQL supports super-columns
+      end
+      
+      def to_cql
+        stmt = "CREATE COLUMNFAMILY #{@cf_name} (key #{@key_type} PRIMARY KEY"
+        @columns.each do |name,type|
+          stmt << ", #{name} #{type}"
+        end
+        stmt << ")"
+        unless @storage_parameters.empty?
+          stmt << " WITH "
+          first_parm = @storage_parameter.shift
+          stmt << "#{first_parm.first.to_s} = '#{first_parm.last.to_s}'"
+          
+          @storage_parameters.each do |key, value|
+            stmt << " AND #{key.to_s} = '#{value.to_s}'"
+          end
+        end
+        
+        stmt
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/create_keyspace.rb

@@ -0,0 +1,30 @@
+module DatastaxRails#:nodoc:
+  module Cql #:nodoc:
+    class CreateKeyspace < Base #:nodoc:
+      def initialize(ks_name)
+        @ks_name = ks_name
+        @strategy_options = {}
+      end
+      
+      def strategy_class(sc)
+        @strategy_class = sc
+        self
+      end
+      
+      def strategy_options(so)
+        @strategy_options.merge!(so)
+        self
+      end
+      
+      def to_cql
+        stmt = "CREATE KEYSPACE #{@ks_name} WITH strategy_class = '#{@strategy_class}'"
+        
+        @strategy_options.each do |key, value|
+          stmt << " AND strategy_options:#{key.to_s} = '#{value.to_s}'"
+        end
+        
+        stmt
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/delete.rb

@@ -0,0 +1,41 @@
+module DatastaxRails
+  module Cql
+    class Delete < Base
+      def initialize(klass, keys)
+        @klass = klass
+        @keys = keys
+        @consistency = DatastaxRails::Cql::Consistency::QUORUM
+        @timestamp = nil
+        @columns = []
+      end
+      
+      def using(consistency)
+        @consistency = consistency
+        self
+      end
+      
+      def columns(columns)
+        @columns = columns
+        self
+      end
+      
+      def timestamp(timestamp)
+        @timestamp = timestamp
+        self
+      end
+      
+      def to_cql
+        values = []
+        stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} USING CONSISTENCY #{@consistency} "
+        
+        if(@timestamp)
+          stmt << "AND TIMESTAMP #{@timestamp} "
+        end
+        
+        stmt << "WHERE KEY IN (?)"
+        
+        CassandraCQL::Statement.sanitize(stmt, @keys)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/drop_column_family.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    class DropColumnFamily < Base
+      def initialize(cf_name)
+        @cf_name = cf_name
+      end
+      
+      def to_cql
+        "DROP COLUMNFAMILY #{@cf_name}"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/drop_keyspace.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    class DropKeyspace < Base
+      def initialize(ks_name)
+        @ks_name = ks_name
+      end
+      
+      def to_cql
+        "DROP KEYSPACE #{@ks_name}"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/insert.rb

@@ -0,0 +1,53 @@
+module DatastaxRails
+  module Cql
+    class Insert < Base
+      def initialize(klass)
+        @klass = klass
+        @consistency = DatastaxRails::Cql::Consistency::QUORUM
+        @ttl = nil
+        @timestamp = nil
+        @columns = {}
+      end
+      
+      def using(consistency)
+        @consistency = consistency
+        self
+      end
+      
+      def columns(columns)
+        @columns.merge!(columns)
+        self
+      end
+      
+      def ttl(ttl)
+        @ttl = ttl
+        self
+      end
+      
+      def timestamp(timestamp)
+        @timestamp = timestamp
+        self
+      end
+      
+      def to_cql
+        values = []
+        keys = []
+        @columns.each do |k,v|
+          keys << k.to_s
+          values << v
+        end
+        stmt = "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) VALUES (#{('?'*keys.size).split(//).join(',')}) USING CONSISTENCY #{@consistency} "
+        
+        if(@ttl)
+          stmt << "AND TTL #{@ttl} "
+        end
+        
+        if(@timestamp)
+          stmt << "AND TIMESTAMP #{@timestamp}"
+        end
+        
+        CassandraCQL::Statement.sanitize(stmt, values)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/select.rb

@@ -0,0 +1,51 @@
+module DatastaxRails#:nodoc:
+  module Cql #:nodoc:
+    class Select < Base #:nodoc:
+      def initialize(klass, select)
+        @klass = klass
+        @select = select.join(",")
+        @consistency = DatastaxRails::Cql::Consistency::QUORUM
+        @limit = nil
+        @conditions = {}
+      end
+      
+      def using(consistency)
+        @consistency = consistency
+        self
+      end
+      
+      def conditions(conditions)
+        @conditions.merge!(conditions)
+        self
+      end
+      
+      def limit(limit)
+        @limit = limit
+        self
+      end
+      
+      def to_cql
+        conditions = []
+        values = []
+        stmt = "SELECT #{@select} FROM #{@klass.column_family} USING CONSISTENCY #{@consistency} "
+        @conditions.each do |k,v|
+          values << v
+          if v.kind_of?(Array)
+            conditions << "#{k.to_s} IN (?)"
+          else
+            conditions << "#{k.to_s} = ?"
+          end
+        end
+        
+        unless conditions.empty?
+          stmt << "WHERE #{conditions.join(" AND ")} "
+        end
+        
+        if @limit
+          stmt << "LIMIT #{@limit}"
+        end
+        CassandraCQL::Statement.sanitize(stmt, values)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/truncate.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    class Truncate < Base
+      def initialize(klass)
+        @klass = klass
+      end
+      
+      def to_cql
+        "TRUNCATE #{@klass.column_family}"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/update.rb

@@ -0,0 +1,68 @@
+module DatastaxRails
+  module Cql
+    class Update < Base
+      def initialize(klass, key)
+        @klass = klass
+        @key = key
+        @consistency = DatastaxRails::Cql::Consistency::QUORUM
+        @columns = {}
+      end
+      
+      def using(consistency)
+        @consistency = consistency
+        self
+      end
+      
+      def columns(columns)
+        @columns.merge!(columns)
+        self
+      end
+      
+      def limit(limit)
+        @limit = limit
+        self
+      end
+      
+      def ttl(ttl)
+        @ttl = ttl
+        self
+      end
+      
+      def timestamp(timestamp)
+        @timestamp = timestamp
+        self
+      end
+      
+      def to_cql
+        values = []
+        
+        stmt = "update #{@klass.column_family} using consistency #{@consistency} "
+        
+        if(@ttl)
+          stmt << "AND TTL #{@ttl} "
+        end
+        
+        if(@timestamp)
+          stmt << "AND TIMESTAMP #{@timestamp}"
+        end
+        
+        stmt << "SET "
+        
+        first_entry = @columns.shift
+        
+        stmt << "#{first_entry.first.to_s} = ? "
+        values << first_entry.last
+        
+        @columns.each do |k,v|
+          stmt << ", #{k.to_s} = ? "
+          values << v
+        end
+        
+        stmt << "WHERE KEY IN (?)"
+        values << @key
+        
+        CassandraCQL::Statement.sanitize(stmt, values)
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql/use_keyspace.rb

@@ -0,0 +1,13 @@
+module DatastaxRails
+  module Cql
+    class UseKeyspace < Base
+      def initialize(ks_name)
+        @ks_name = ks_name
+      end
+      
+      def to_cql
+        "USE #{@ks_name}"
+      end
+    end
+  end
+end

data/lib/datastax_rails/cql.rb

@@ -0,0 +1,25 @@
+module DatastaxRails
+  module Cql
+    extend ActiveSupport::Autoload
+    class << self
+      def for_class(klass)
+        @cql ||= {}
+        @cql[klass] ||= DatastaxRails::Cql::ColumnFamily.new(klass)
+      end
+    end
+    
+    autoload :Base
+    autoload :ColumnFamily
+    autoload :Consistency
+    autoload :CreateColumnFamily
+    autoload :CreateKeyspace
+    autoload :Delete
+    autoload :DropColumnFamily
+    autoload :DropKeyspace
+    autoload :Insert
+    autoload :Select
+    autoload :Truncate
+    autoload :Update
+    autoload :UseKeyspace
+  end
+end

data/lib/datastax_rails/cursor.rb

@@ -0,0 +1,90 @@
+module DatastaxRails
+  class Cursor
+    include Consistency
+
+    def initialize(target_class, column_family, key, super_column, options={})
+      @target_class  = target_class
+      @column_family = column_family
+      @key           = key.to_s
+      @super_column  = super_column
+      @options       = options
+      @validators    = []
+    end
+    
+    def find(number_to_find)
+      limit       = number_to_find
+      objects     = DatastaxRails::Collection.new
+      out_of_keys = false
+
+      if start_with = @options[:start_after]
+        limit += 1
+      else
+        start_with = nil
+      end
+      
+      while objects.size < number_to_find && !out_of_keys
+        index_results = connection.get(@column_family, @key, @super_column,
+          :count => limit,
+          :start => start_with,
+          :reversed => @options[:reversed],
+          :consistency => @target_class.thrift_read_consistency)
+
+        out_of_keys  = index_results.size < limit
+
+        if !start_with.blank?
+          index_results.delete(start_with)
+        end
+
+        keys = index_results.keys
+        values = index_results.values
+        
+        missing_keys = []
+        
+        results = values.empty? ? {} : @target_class.multi_get(values)
+        results.each do |(key, result)|
+          if result.nil?
+            missing_keys << key
+          end
+        end
+    
+        unless missing_keys.empty?
+          @target_class.multi_get(missing_keys, :quorum=>true).each do |(key, result)|
+            index_key = index_results.key(key)
+            if result.nil?
+              remove(index_key)
+              results.delete(key)
+            else
+              results[key] = result
+            end
+          end
+        end
+
+        results.values.each do |o|
+          if @validators.all? {|v| v.call(o) }
+            objects << o
+          else
+            remove(index_results.index(o.key))
+          end
+        end
+        
+        start_with = objects.last_column_name = keys.last
+        limit = (number_to_find - results.size) + 1
+        
+      end
+      
+      return objects
+    end
+    
+    def connection
+      @target_class.connection
+    end
+    
+    def remove(index_key)
+      connection.remove(@column_family, @key, @super_column, index_key, :consistency => @target_class.thrift_write_consistency)
+    end
+    
+    def validator(&validator)
+      @validators << validator
+    end
+  end
+end

data/lib/datastax_rails/errors.rb

@@ -0,0 +1,16 @@
+module DatastaxRails
+  class DatastaxRailsError < StandardError
+  end
+  
+  class AssociationTypeMismatch < DatastaxRailsError
+  end
+  
+  class RecordNotSaved < DatastaxRailsError
+  end
+  
+  class DeleteRestrictionError < DatastaxRailsError
+  end
+  
+  class RecordNotFound < DatastaxRailsError
+  end
+end

data/lib/datastax_rails/identity/abstract_key_factory.rb

@@ -0,0 +1,26 @@
+module DatastaxRails
+  module Identity
+    # Key factories need to support 3 operations
+    class AbstractKeyFactory
+      # Next key takes an object and returns the key object it should use.
+      # object will be ignored with synthetic keys but could be useful with natural ones
+      #
+      # @param  [CassandraObject::Base] the object that needs a new key
+      # @return [CassandraObject::Identity::Key] the key
+      #
+      def next_key(object)
+        raise NotImplementedError, "#{self.class.name}#next_key isn't implemented."
+      end
+
+      # Parse should create a new key object from the 'to_param' format
+      #
+      # @param  [String] the result of calling key.to_param
+      # @return [CassandraObject::Identity::Key] the parsed key
+      #
+      def parse(string)
+        raise NotImplementedError, "#{self.class.name}#parse isn't implemented."
+      end
+    end
+  end
+end
+

data/lib/datastax_rails/identity/custom_key_factory.rb

@@ -0,0 +1,36 @@
+module DatastaxRails
+  module Identity
+    class CustomKeyFactory < AbstractKeyFactory
+      class CustomKey
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          value
+        end
+
+        def ==(other)
+          other.to_s == value
+        end
+      end
+
+      attr_reader :method
+
+      def initialize(options)
+        @method = options[:method]
+      end
+
+      def next_key(object)
+        CustomKey.new(object.send(@method))
+      end
+
+      def parse(value)
+        value
+      end
+    end
+  end
+end
+

data/lib/datastax_rails/identity/hashed_natural_key_factory.rb

@@ -0,0 +1,10 @@
+require 'digest/sha1'
+module DatastaxRails
+  module Identity
+    class HashedNaturalKeyFactory < NaturalKeyFactory
+      def next_key(object)
+        NaturalKey.new(Digest::SHA1.hexdigest(attributes.map { |a| object.attributes[a.to_s] }.join(separator)))
+      end
+    end
+  end
+end