cassandra_complex 0.5

data/lib/cassandra_complex/row.rb

@@ -0,0 +1,10 @@
+# Rough monkey-patch to CassandraCQL::Row for access schema
+module CassandraCQL
+  # CassandraCQL::Row
+  #
+  # @!attribute [r] schema
+  # @return [CassandraCQL::Schema] Row schema
+  class Row
+    attr_reader :schema
+  end
+end

data/lib/cassandra_complex/table.rb

@@ -0,0 +1,271 @@
+module CassandraComplex
+  # Class Table which wraps CQL3 operations
+  #
+  # @!attribute [rw] keyspace
+  #   @return [String] The keyspace is being connected to
+  # @!attribute [rw] configuration
+  #   @return [String] The configuration of the connection
+  # @example Selecting all rows with given primary
+  #   class Timeline < CassandraComplex::Table
+  #     set_table_name 'timeline'
+  #   end
+  #
+  #   rows = Timeline.all('some_primary_key') do |row|
+  #     # this puts is outputed on each row is being fetch
+  #     puts row['body']
+  #   end
+  #   rows.each do |row|
+  #     # puts is being outputed when all rows are fetched from Cassandra
+  #     puts row['body']
+  #   end
+  class Table
+    #not neccessary to allow .new
+    private_class_method :new
+
+    class << self
+
+      attr_accessor :keyspace
+      attr_accessor :configuration
+
+      # Specify keyspace for particular table
+      #
+      # @param [String] kyspc keyspace
+      def set_keyspace(kyspc)
+        self.keyspace = kyspc
+      end
+
+      # Return connection for given keyspace(or default keyspace if no keyspace is given)
+      #
+      # @param [String] kyspc keyspace for which return the connection
+      # @return [CassandraComplex::Connection] new instance of Connection
+      def connection(kyspc=nil)
+        CassandraComplex::Connection.connection(kyspc || self.keyspace)
+      end
+
+      # Execute code within specific keyspace
+      #
+      # @param [String] kyspc keyspace in which code should be executed
+      # @yieldparam [Proc] blck custom code to be executed within keyspace
+      def with_keyspace(kyspc, &blck)
+        connection.with_keyspace(kyspc, &blck)
+      end
+
+      # Set table name for particular table
+      #
+      # @param[String] tbl table name
+      def set_table_name(tbl)
+        @tbl_name = tbl
+      end
+
+      # Return table name
+      #
+      # @return [String] table name
+      def table_name
+        @tbl_name || self.name.downcase
+      end
+
+      # Return first part of primary key
+      #
+      # @return [String] first part of primary key
+      def id
+        @id ||= connection.key_alias(table_name)
+        @id
+      end
+
+      # Return if table is empty
+      #
+      # @return [Boolean] if table is empty
+      def empty?
+        all.empty?
+      end
+
+      # Truncate table
+      # @return [Boolean] true
+      def truncate
+        command = "truncate #{table_name};"
+        rs = connection.execute(command, true, self)
+        true
+      end
+
+      # Raw query execution
+      # @param [String] cql_query_string
+      # @yieldparam [Proc] blck custom code to be executed within keyspace
+      # @return [Array<Hash>] result set as array of hashes
+      def execute(cql_query_string, &blck)
+        rs = connection.execute(cql_query_string, true, self, [], &blck)
+        rs
+      end
+
+      # Return result set for given primary key
+      # @see .build_select_clause
+      #
+      # @param [String, Array<String>, Hash] key key for where clause
+      # @param [Hash] clauses select clauses
+      # @option clauses [String, Array<String>] where where clause
+      # @option clauses [String] order order clause
+      # @option clauses [String] limit limit clause
+      # @return [Array<Hash>] array of hashes
+      def all(key=nil, clauses={}, &blck)
+        key = nil if key == :all
+
+        return_value = nil
+        if (!clauses[:select_expression])
+          if (clauses[:distinct])
+            clauses.merge!({:select_expression=>clauses[:distinct]})
+          else
+            clauses.merge!({:select_expression=>"*"})
+          end
+        end
+
+        command = build_select_clause(key, clauses)
+        if clauses[:where].kind_of?(Array)
+          bind = clauses[:where][1..-1]
+        else
+          bind = []
+        end
+        return_value = connection.execute(command, true, self, bind, &blck)
+
+        #distinct
+        return_value = return_value.map{|row| row[clauses[:distinct]]}.uniq if clauses[:distinct]
+
+        return_value
+      end
+
+      alias find all
+
+      # Return count of result set for given primary key
+      # @see .build_select_clause
+      #
+      # @param [String, Array<String>, Hash] key key for where clause
+      # @param [Hash] clauses select clauses
+      # @option clauses [String, Array<String>] where where clause
+      # @option clauses [String] order order clause
+      # @option clauses [String] limit limit clause
+      # @return [Array<Hash>] result as as array of hashes
+      def count(key=nil, clauses={}, &blck)
+        key = nil if key == :all
+        return_value = nil
+        command = build_select_clause(key, clauses.merge({:select_expression=>"count(1)"}))
+        if clauses[:where].kind_of?(Array)
+          bind = clauses[:where][1..-1]
+        else
+          bind = []
+        end
+        rs = connection.execute(command, true, self, bind, &blck)
+        if !rs.empty? && rs[0].has_key?('count')
+          return_value = rs[0]['count']
+        end
+
+        return_value
+      end
+
+      # Insert record
+      # @param [Hash] clauses hash of fields, which need to be inserted
+      # @param [Hash] options create options, such as consistency
+      # @return [Boolean] always true
+      def create(clauses={}, options={})
+        return false if clauses.empty?
+
+        keys   = clauses.keys.join(', ')
+        values = clauses.values.map{|x| !!options[:sanitize] ? x : CassandraCQL::Statement.quote(CassandraCQL::Statement.cast_to_cql(x))}.join(', ')
+
+        options_clause = ''
+
+        if !options.empty?
+          options_clause = "using " + options.map{|x,y| ' ' + x.to_s + ' ' + y.to_s + ' '}.join(' AND ')
+        end
+
+        command = "insert into #{table_name} (#{keys}) values (#{values}) #{options_clause}"
+        rs = connection.execute(command, true, self)
+
+        return true
+      end
+
+
+      alias update create
+
+      # Delete record(s)
+      # @param [String, Array<String>, Hash] key key for where clause
+      # @param [Hash] options options for delete
+      # @option options [String] timestamp timestamp of operation
+      # @option options [Array<String>] columns columns which should be deleted
+      # @option options [Array, String] where where options for delete operation
+      # @return [Boolean] always true
+      def delete(key=nil,options={})
+        return false unless (key || options.has_key?(:where))
+
+        where_clause = build_where_clause(key, options)
+
+        consistency_clause = ''
+        consistency_clause = " using consistency quorum and timestamp #{options[:timestamp]} " if options[:timestamp]
+
+        columns_clause = ''
+        columns_clause = options[:columns].join(', ') if options[:columns]
+        command = "delete #{columns_clause} from #{table_name} #{consistency_clause} #{where_clause}"
+
+        if options[:where].kind_of?(Array)
+          bind = options[:where][1..-1]
+        else
+          bind = []
+        end
+        rs = connection.execute(command, true, self, bind)
+
+        return true
+      end
+
+    protected
+
+      # Build select clause from clauses hash
+      # @see .build_where_clause
+      #
+      # @param [String, Array<String>, Hash] key key for where clause
+      # @param [Hash] clauses select clauses
+      # @option clauses [String, Array<String>] where where clause
+      # @option clauses [String] order order clause
+      # @option clauses [String] limit limit clause
+      # @return [String] CQL command
+      def build_select_clause(key=nil, clauses={})
+        where_clause = build_where_clause(key, clauses)
+        order_clause = ''
+        limit_clause = ''
+        if !clauses.empty?
+          order_clause = ' order by ' + clauses[:order] if clauses[:order]
+          limit_clause = ' limit ' + clauses[:limit].to_s if clauses[:limit]
+        end
+        command = "select #{clauses[:select_expression]} from #{table_name} #{where_clause} #{order_clause} #{limit_clause};"
+        command
+      end
+
+      # Build where clause from clauses hash
+      #
+      # @param [String, Array<String>, Hash] key key for where clause
+      # @param [Hash] clauses where clauses
+      # @option clauses [String, Array<String>] where where clause
+      # @return [String] where part of CQL command
+      def build_where_clause(key, clauses)
+        where_clause = ''
+        if clauses[:where].kind_of?(Array)
+          where = clauses[:where][0]
+        else
+          where = clauses[:where]
+        end
+        if key
+          if key.kind_of?(String)
+            where_clause = "where #{id} = #{CassandraCQL::Statement.quote(CassandraCQL::Statement.cast_to_cql(key))}"
+          elsif key.kind_of?(Array)
+            where_clause = "where #{id} in (#{key.map{|x| CassandraCQL::Statement.quote(CassandraCQL::Statement.cast_to_cql(x))}.join(', ')})"
+          elsif key.kind_of?(Hash)
+            where_clause = "where " + key.map{|x,y| "#{x} = #{CassandraCQL::Statement.quote(CassandraCQL::Statement.cast_to_cql(y))}"}.join(' and ')
+          end
+          if !clauses.empty? && clauses[:where]
+            where_clause << ' and ' + where
+          end
+        elsif !clauses.empty? && clauses[:where]
+          where_clause = 'where ' + where
+        end
+        where_clause
+      end
+
+    end
+  end
+end

data/spec/cassandra_complex/model_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+class TimelineModel < CassandraComplex::Model
+  table 'timeline'
+
+  attribute :user_id,  'varchar'
+  attribute :tweet_id, 'int'
+  attribute :author,   'varchar'
+  attribute :body,     'varchar'
+
+  primary_key :user_id, :tweet_id
+end
+
+class Tickets < CassandraComplex::Model
+  table 'tickets'
+
+  attribute :user_id, 'int'
+  attribute :owner, 'varchar'
+  attribute :time, 'timestamp'
+
+  primary_key :user_id
+end
+
+#CassandraComplex::Configuration.logger = Logger.new('/dev/null')
+
+describe 'Model' do
+
+  before :all do
+    conn = CassandraComplex::Connection.new('127.0.0.1:9160')
+    conn.execute('CREATE KEYSPACE cassandra_complex_test WITH strategy_class = \'SimpleStrategy\' AND strategy_options:replication_factor = 1;')
+    CassandraComplex::Configuration.read({'host'=>'127.0.0.1:9160', 'default_keyspace'=>'cassandra_complex_test'})
+    TimelineModel.create_table
+    Tickets.create_table
+  end
+
+  after :all do
+    conn = CassandraComplex::Connection.new('127.0.0.1:9160')
+    TimelineModel.drop_table
+    Tickets.drop_table
+    conn.execute('DROP KEYSPACE cassandra_complex;')
+  end
+
+  context 'basic operations' do
+    before :each do
+      TimelineModel.truncate
+      Tickets.truncate
+    end
+
+    it 'returns schema' do
+      TimelineModel.schema.should == {:table => 'timeline', :attributes=>{:user_id => 'varchar', :tweet_id => 'int', :author => 'varchar', :body => 'varchar'}, :primary_key => [:user_id, :tweet_id]}
+      Tickets.schema.should == {:table => 'tickets', :attributes=>{:user_id => 'int', :owner => 'varchar', :time => 'timestamp'}, :primary_key => [:user_id]}
+    end
+
+    it 'checks equality of two models' do
+      timeline1 = TimelineModel.new({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+      timeline2 = TimelineModel.new({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+
+      timeline1.should == timeline2
+
+      timeline3 = TimelineModel.new({'user_id' => 'test_user3', 'tweet_id' => 3, 'author' => 'test_author3', 'body' => 'test_body3'})
+      timeline1.should_not == timeline3
+
+      tickets = Tickets.new({:user_id => 10, :owner=> 'Tim Collins', :time => Time.now})
+
+      tickets.should_not == timeline3
+    end
+
+    it 'implements dirtiness' do
+      timeline1 = TimelineModel.new({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+      timeline1.dirty?.should == true
+
+      timeline1.save
+      timeline1.dirty?.should == false
+
+      timeline1 == TimelineModel.all[0]
+      timeline1.dirty?.should == false
+      timeline1.author = 'test_author42'
+      timeline1.dirty?.should == true
+      timeline1.save
+
+      timelines = TimelineModel.all
+      timelines.size.should == 1
+      timeline1 = timelines[0]
+
+      timeline1.user_id.should  == 'test_user1'
+      timeline1.tweet_id.should == 1
+      timeline1.author.should   == 'test_author42'
+      timeline1.body.should     == 'test_body1'
+    end
+  end
+
+  context 'creating new model' do
+    before (:each) do
+      TimelineModel.truncate
+      Tickets.truncate
+    end
+
+    it 'with Hash' do
+      timeline1 = TimelineModel.new({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+
+      timeline1.user_id.should  == 'test_user1'
+      timeline1.tweet_id.should == 1
+      timeline1.author.should   == 'test_author1'
+      timeline1.body.should     == 'test_body1'
+
+      ticket1 = Tickets.new({:user_id => 10, :owner=> 'Tim Collins', :time => Time.now})
+
+      ticket1.user_id.should == 10
+      ticket1.owner.should   == 'Tim Collins'
+    end
+
+    it 'with assigment' do
+      timeline = TimelineModel.new
+
+      timeline.user_id  = 'test_user2'
+      timeline.tweet_id = 2
+      timeline.author   = 'test_author2'
+      timeline.body     = 'test_body2'
+
+      timeline.user_id.should == 'test_user2'
+      timeline.tweet_id.should == 2
+      timeline.author.should == 'test_author2'
+      timeline.body.should == 'test_body2'
+    end
+
+    it 'creating and saving new model within DB' do
+      timeline_created = TimelineModel.create({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+
+      timeline_created.user_id.should == 'test_user1'
+      timeline_created.tweet_id.should == 1
+      timeline_created.author.should == 'test_author1'
+      timeline_created.body.should == 'test_body1'
+
+      timeline_found = TimelineModel.find('test_user1', :where=>['tweet_id = ?', 1])
+      timeline_created.should == timeline_found.first
+    end
+  end
+
+  context 'saving model' do
+
+    before (:each) do
+      TimelineModel.truncate
+    end
+
+    it 'just save' do
+      timeline = TimelineModel.new({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+
+      timeline.save
+
+      TimelineModel.all.size.should == 1
+    end
+  end
+
+  context 'deleting model' do
+    before (:each) do
+      TimelineModel.truncate
+      TimelineModel.create({'user_id' => 'test_user1', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+    end
+
+    it 'as class method' do
+      TimelineModel.delete({'user_id' => 'test_user1', 'tweet_id' => 1})
+      TimelineModel.all.size.should == 0
+    end
+
+    it 'as instance method' do
+      TimelineModel.find('test_user1', :where=>['tweet_id = ?', 1])[0].delete
+      TimelineModel.all.size.should == 0
+    end
+
+  end
+
+  context 'all, find, count, etc' do
+
+    before (:each) do
+      TimelineModel.truncate
+      TimelineModel.create({'user_id' => 'test_user0', 'tweet_id' => 0, 'author' => 'test_author0', 'body' => 'test_body0'})
+      TimelineModel.create({'user_id' => 'test_user0', 'tweet_id' => 1, 'author' => 'test_author1', 'body' => 'test_body1'})
+      TimelineModel.create({'user_id' => 'test_user2', 'tweet_id' => 2, 'author' => 'test_author2', 'body' => 'test_body2'})
+      TimelineModel.create({'user_id' => 'test_user3', 'tweet_id' => 3, 'author' => 'test_author3', 'body' => 'test_body3'})
+    end
+
+
+    it 'count' do
+      TimelineModel.count.should == 4
+      TimelineModel.count('test_user0').should == 2
+      TimelineModel.count(:all, {:where=>['user_id = ? and tweet_id = ?', 'test_user0', 0]}).should == 1
+      TimelineModel.count({'user_id' => 'test_user0'}).should == 2
+    end
+
+    it 'all' do
+      TimelineModel.all.size.should == 4
+      TimelineModel.all({:where=>['user_id = ?', 'test_user0']}).size.should == 2
+    end
+
+    it 'find' do
+      TimelineModel.find(:all).size.should == 4
+      TimelineModel.find(:all, {:where=>['user_id = ?', 'test_user0']}).size.should == 2
+      TimelineModel.find({'user_id' => 'test_user0', 'tweet_id' => 1}).size.should  == 1
+    end
+
+  end
+
+end