cassandra_complex 0.5

data/lib/cassandra_complex.rb

@@ -0,0 +1,7 @@
+require 'cassandra-cql/1.1'
+require 'cassandra_complex/configuration'
+require 'cassandra_complex/row'
+require 'cassandra_complex/connection'
+require 'cassandra_complex/table'
+require 'cassandra_complex/model'
+require 'cassandra_complex/index'

data/lib/cassandra_complex/configuration.rb

@@ -0,0 +1,59 @@
+module CassandraComplex
+
+  class ConfigurationError < Exception
+  end
+
+  class MissingConfiguration < ConfigurationError
+  end
+
+  # Configuration class to specify basic settings,
+  # such as host, default keyspace and logger.
+  #
+  # Your yaml configuration file should looks like:
+  #   host: '127.0.0.1:9160, example.com:9160'
+  #   default_keyspace: 'keyspace_production'
+  #
+  # @!attribute [r] host
+  #   @return [String] The host is being connected to
+  # @!attribute [r] default_keyspace
+  #   @return [String] The keyspace is being used within connection by default
+  # @!attribute [rw] logger
+  #   @return [String] The logger(kind_of? Logger) is being used by default
+  class Configuration
+
+    class << self
+      attr_reader :host
+      attr_reader :default_keyspace
+
+      attr_accessor :logger
+
+      # Load yaml source
+      #
+      # @param [IO, String, Hash] something file path, IO, raw YAML string, or a pre-loaded Hash
+      # @return [Boolean, Hash] loaded yaml file or false if a RuntimeError occurred while loading
+      def read(something)
+        return_value = false
+
+        begin
+          if something.kind_of?(Hash)
+            return_value = something
+          elsif File.exists?(something)
+            return_value = YAML.load_file(something)
+          else
+            return_value = YAML.load(something)
+          end
+          raise ConfigurationError unless return_value.kind_of?(Hash)
+        rescue
+          return_value = false
+        end
+        @host = return_value['host']
+        @default_keyspace = return_value['default_keyspace']
+
+        @logger = Logger.new('/dev/null')
+
+        return_value
+      end
+
+    end
+  end
+end

data/lib/cassandra_complex/connection.rb

@@ -0,0 +1,168 @@
+require 'thread'
+
+module CassandraComplex
+  # Basic class which encapsulate driver` connection to a Cassandra cluster.
+  # It executes raw CQL and can return result sets in two ways.
+  #
+  # @!attribute [r] keyspace
+  #   @return [String] The keyspace is being connected to
+  # @example Usage of Connection
+  #   connection = Connection.new('127.0.0.1:9160', {:keyspace=>'cassandra_complex_test'})
+  #   row_set    = connection.execute("select * from timeline")
+  #   row_set.each |row|
+  #     puts row['user_id']
+  #   end
+  class Connection
+
+    attr_reader :keyspace
+    attr_reader :conn
+    # Connections pool, @see .connection
+    @@connections = {}
+
+    class << self
+
+      # Create( if not exists or not active) and return connection to kyspc
+      #
+      # @param [String] kyspc ('system') The keyspace to which connect
+      # @return [CassandraComplex::Connection] Connection instance
+      def connection(kyspc=nil)
+	raise MissingConfiguration if Configuration.host.nil? || Configuration.default_keyspace.nil?
+        @@connections[kyspc] = CassandraComplex::Connection.new(Configuration.host, {:keyspace=>kyspc || Configuration.default_keyspace || 'system'})\
+                                 unless ( @@connections[kyspc] && @@connections[kyspc].conn.active?)
+        Configuration.logger.info "Connected to: #{Configuration.host}:#{Configuration.default_keyspace}"\
+                                                                         if Configuration.logger.kind_of?(Logger)
+        @@connections[kyspc]
+      end
+    end
+
+
+    # Create new instance of Connection and initialize connection with Cassandra
+    #
+    # @param [Array, String] hosts list of hosts, a single host, to connect to
+    # @param [Hash] options list of options
+    # @option options [String] keyspace initial keyspace to connect, default is 'system'
+    # @return [CassandraComplex::Connection] new instance
+    def initialize(hosts, options = {})
+      @keyspace = options[:keyspace] || 'system'
+      Configuration.logger.info "Connecting to #{hosts.inspect} with params #{options.inspect}"\
+                                                                  if Configuration.logger.kind_of?(Logger)
+      @conn = CassandraCQL::Database.new(hosts, options.merge({:cql_version=>'3.0.0'}))
+      @mutex = Mutex.new
+    end
+
+    # Execute CQL3 query with Thread safety.
+    #
+    # @param [Array<String>, String] cql_string string with cql3 commands
+    # @param [Boolean] multi_commands if the cql_strings should be divided into separate commands
+    # @param [CassandraComplex::Table] table the table with describing schema
+    # @param [Array] bind bind for cql string
+    # @yieldparam [Proc] blck custom code to be executed on each new row adding
+    # @return [Array] row set
+    def execute(cql_string, multi_commands = true, table=nil, bind=[], &blck)
+      row_set = []
+      @mutex.synchronize {
+        begin
+          join_multi_commands(cql_string, multi_commands).each do |cql|
+            if !(cql.strip.empty?)
+              if bind.size > 0
+                cql = CassandraCQL::Statement.sanitize(cql, bind)
+              end
+              Configuration.logger.info "Going to execute CQL: '#{cql}'"\
+                                                              if Configuration.logger.kind_of?(Logger)
+              new_rows = process_thrift_rows(@conn.execute(cql), &blck)
+              row_set << new_rows if new_rows
+            end
+          end
+        ensure
+          row_set_flatten = row_set.flatten
+          return row_set_flatten
+        end
+      }
+    end
+
+    # Change current keyspace temporarily; restore original keyspace upon return.
+    #
+    # @param [String] kyspc The keyspace of chaning context
+    # @yield Execute cassandra operations within context of kyspc
+    def with_keyspace(kyspc)
+      @mutex.synchronize {
+        if kyspc != @keyspace.strip
+          old_keyspace, @keyspace = @keyspace, kyspc
+
+          execute("use #{@keyspace};")
+          yield if block_given?
+          execute("use #{old_keyspace};")
+
+          @keyspace = old_keyspace
+        else
+          yield if block_given?
+        end
+      }
+    end
+
+    # Execute CQL3 commands within batch
+    # (see #execute)
+    #
+    # @param [String, Array] cql_commands CQL3 commands to be executed within batch
+    # @param [Hash] options Consistency options of batch command
+    # @option options[String] :write_consistency ('ANY') Write consistency
+    # @option options[Time]   :write_timestamp   (nil)   Write timestamp
+    # @option options[String] :read_consistency ('QUORUM') Read consistency
+    # @option options[Time]   :read_timestamp   (nil)   Read timestamp
+    # @return [CassandraModeCql::RowSet] row set
+    def execute_batch(cql_commands, options={:write_consistency=>'ANY', :write_timestamp=>nil, :read_consistency=>'QUORUM', :read_timestamp=>nil})
+      command = "\
+        BEGIN BATCH #{prepare_consistency_level(options)}
+          #{cql_commands}
+        APPLY BATCH;\
+      "
+      execute(command, false)
+    end
+
+    # Return key alias(first part of primary key) for given table
+    #
+    # @param [String] table_name Table name of given table
+    # @return [String] primary key for given table
+    def key_alias(table_name)
+      @conn.schema.column_families[table_name].cf_def.key_alias
+    end
+
+    private
+
+    # Process thrift rows
+    #
+    # @param [Array] rows thrift rows
+    # @yieldparam [Proc] blck custom code to be executed on each new row adding
+    def process_thrift_rows(rows, &blck)
+      return unless rows
+      return_value = []
+      rows.fetch do |thrift_row|
+        row = {}
+        thrift_row.row.columns.each do |thrift_column|
+          column_name  = CassandraCQL::ColumnFamily.cast(thrift_column.name, thrift_row.schema.names[thrift_column.name])
+          column_value = CassandraCQL::ColumnFamily.cast(thrift_column.value, thrift_row.schema.values[thrift_column.name])
+          row.merge!({column_name=>column_value})
+        end
+        blck.call(row) if block_given?
+        return_value.push(row)
+      end
+      return_value
+    end
+
+    # Prepare cql statement before executing
+    #
+    # @param [String] cql_statement CQL3 statemenet that need to be prepared
+    # @param [Boolean] multi_commands If cql_statement consist multi commands
+    def join_multi_commands(cql_statement, multi_commands)
+      return_value = cql_statement
+      if multi_commands
+        return_value  = return_value.gsub(/\n/, ' ')
+        return_value  = return_value.each_line(';')
+      else
+        return_value  = return_value.to_a
+      end
+      return_value
+    end
+
+  end
+end

data/lib/cassandra_complex/index.rb

@@ -0,0 +1,39 @@
+module CassandraComplex
+  # A composite index for table
+  # not yet implemented
+  # @example
+  #   class Timeline < CassandraComplex::Model
+  #
+  #     set_keyspace 'history'
+  #
+  #     attribute :user_id, 'varchar'
+  #     attribute :author_tweet_id, 'uuid'
+  #     attribute :author, 'varchar'
+  #     attribute :body, 'varchar'
+  #
+  #     primary_key :user_id, :tweet_id
+  #   end
+  #
+  #   class Tweet < CassandraComplex::Model
+  #     set_keyspace 'history'
+  #
+  #     attribute :tweet_id, 'varchar'
+  #     attribute :important_data, 'varchar'
+  #   end
+  #
+  #   class TwitIndex < CassandraComplex::Index
+  #     index :with_table=>Timeline  #, :attributes=>[:author, :author_tweet_id]
+  #     indexing :table=> Tweet, :index=>[:tweet_id]
+  #
+  #     indexing_rule Proc.new{|timeline| timeline.author.to_s + ':' + timeline.author_tweet_id.to_s}
+  #   end
+  #
+  #   t = Timeline.find('gmason')
+  #   puts t.inspect
+  #   => <Timeline:{:user_id=>'gmason', :author_tweet_id=>1, :author=>'gwashington', :body=>'Some text'}
+  #   puts t.tweets.inspect
+  #   <Tweet:{:tweet_id=>'gwashington:1', :important_data=>'Some data.'}>
+
+  class Index < Table
+  end
+end

data/lib/cassandra_complex/model.rb

@@ -0,0 +1,309 @@
+module CassandraComplex
+  # A little bit sugared model.
+  #
+  # @!attribute [rw] table_name
+  #   @return [String] Table name
+  #
+  # @example Using model
+  # class Timeline < CassandraComplex::Model
+  #
+  #   table 'timeline'
+  #
+  #   attribute :user_id, 'varchar'
+  #   attribute :tweet_id, 'uuid'
+  #   attribute :author, 'varchar'
+  #   attribute :body, 'varchar'
+  #   #composite primary key
+  #   primary_key :user_id, :tweet_id
+  # end
+  #
+  # #creating Column Family
+  # Timeline.create_table
+  #
+  # t = Timeline.new(:user_id=>'mickey', :tweet_id=>1715, :author=> 'mouse', :body=>"'Hello!'")
+  # t.save
+  #
+  # timelines = Timeline.all('mickey')
+  # t = timelines.first
+  # puts t.body
+  # => 'Hello!'
+  # t.body  = "'Goodbye!'"
+  # puts t.dirty?
+  # => true
+  # t.save
+  #
+  # t.update(:tweet_id=>1777)
+  #
+  # #dropping Column Family
+  # Timeline.drop_table
+  class ModelError < Exception
+  end
+
+  class WrongModelDefinition < ModelError
+  end
+
+  class WrongModelInitialization < ModelError
+  end
+
+  class Model
+    #class` methods
+    class << self
+      attr_accessor :table_name
+
+      @@table       = Hash.new {|hash, key| hash[key] = nil}
+      @@table_name  = Hash.new {|hash, key| hash[key] = ''}
+
+      @@attributes  = Hash.new {|hash, key| hash[key] = {}}
+      @@primary_key = Hash.new {|hash, key| hash[key] = []}
+
+      # Returns table executing all cql commands
+      #
+      # @return [Table] CassandraComplex::Table
+      def table_cql
+        @@table[self]
+      end
+
+      # Returns table name
+      #
+      # @return [String] Name of the table
+      def table_name
+        @@table_name[self]
+      end
+
+      # Returns all attributes within class
+      #
+      # @return [Hash] attributes of current Model
+      def attributes
+        @@attributes[self]
+      end
+
+      # Returns primary key for current Model
+      #
+      # @return [Array<String>] primary key for current Model
+      def get_primary_key
+        @@primary_key[self]
+      end
+
+      # Returns schema for current Model
+      #
+      # @return [Hash] schema for current model
+      def schema
+        attr = {}
+        attributes.each{|x,y| attr[x] = y[:type]}
+        {:table => table_name, :attributes => attr, :primary_key => get_primary_key}
+      end
+
+      # Set primary key(s) for current Model
+      #
+      # @param [Array<Symbol>] attr_names Primary key(s)
+      def primary_key(*attr_names)
+        attr_names.each do |attr_name|
+          raise WrongModelDefinition, 'Primary key could be choosen just from already introduced attribute.'\
+                                                                       unless attributes.has_key?(attr_name.intern)
+          @@primary_key[self] << attr_name.intern
+        end
+      end
+
+      # Introduce attribute for the Model.
+      # Valid attribute`s types: 'blog', 'ascii', 'text'/'varchar', 'varint', 'int', 'bigint', 'uuid', 'timestamp', 'boolean',
+      # 'float', 'double', 'decimal', 'counter'.
+      #
+      # @param [Symbol] attr_name Attribute`s name
+      # @param [String] attr_type Attribute`s type
+      def attribute(attr_name, attr_type)
+        attr_name = attr_name.intern
+        raise WrongModelDefinition, 'You can`t redefine already introduced attribute.' if self.instance_methods.include?(name)
+
+        attributes[attr_name] = {:type => attr_type}
+        define_method(attr_name) do
+          @_attributes[attr_name][:value]
+        end
+        define_method(:"#{attr_name}=") do |value|
+          @_attributes[attr_name][:value]  = value
+          @_attributes[attr_name][:dirty?] = true
+        end
+      end
+
+      # Set table name for current Model
+      #
+      # @param [String] new_table_name
+      def table(new_table_name)
+        table_name  = new_table_name.to_s.downcase
+        @@table[self]   = Class.new(CassandraComplex::Table) do
+          set_table_name table_name
+        end
+        @@table_name[self] = table_name
+      end
+
+      # Return count of result set for given primary key
+      #
+      # @param [String, Array<String>, Hash] key
+      # @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
+      # @yieldparam [Proc] blck custom code
+      # @return [Array<Hash>] array of hashes
+      def count(key=nil, clauses={}, &blck)
+        key = nil if key == :all
+        table_cql.count(key, clauses, &blck)
+      end
+
+      # Return 'all' result set
+      #
+      # @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
+      # @yieldparam [Proc] blck custom code
+      # @return [Array<Hash>] array of hashes
+      def all(clauses={}, &blck)
+        find(:all, clauses, &blck)
+      end
+
+      # Return result set for given primary key
+      #
+      # @param [String, Array<String>, Hash] key
+      # @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
+      # @yieldparam [Proc] blck custom code
+      # @return [Array<Hash>] array of hashes
+      def find(key=nil, clauses={}, &blck)
+        key = nil if key == :all
+        return_value = table_cql.find(key, clauses).map do |record|
+          new_instance = self.new(record, {:dirty => false})
+          blck.call(new_instance) if block_given?
+          new_instance
+        end
+        return_value
+      end
+
+      # Delete record(s)
+      #
+      # @param [String, Array<String>, Hash] key
+      # @param [Hash] clauses
+      # @option clauses [String] timestamp timestamp of operation
+      # @option clauses [Array<String>] columns columns which should be deleted
+      # @option clauses [Array, String] where where options for delete operation
+      # @return [Boolean] always true
+      def delete(key, clauses={}, &blck)
+        key = nil if key == :all
+        table_cql.delete(key, clauses, &blck)
+      end
+
+      # Create record from hash
+      #
+      # @param [Hash] hsh attributes for new record
+      # @return [Model] created model
+      def create(hsh={})
+        new_model = self.new(hsh)
+        new_model.save
+        new_model
+      end
+
+      # Create table for model within Cassandra
+      def create_table
+        attrs = attributes.map{|x,y| "#{x.to_s} #{y[:type].to_s}"}.join(', ')
+        p_key = ''
+        p_key = " PRIMARY KEY (#{get_primary_key.map{|x| x.to_s}.join(', ')})"
+        create_table_command = <<-eos
+          CREATE TABLE table_name (
+            #{attrs}
+            #{p_key}
+          );
+        eos
+        table_cql.execute(create_table_command)
+      end
+
+      # Drop table for model within Cassandra
+      def drop_table
+        drop_table_command = <<-eos
+          DROP TABLE table_name;
+        eos
+        table_cql.execute(drop_table_command)
+      end
+
+      # Truncate table within Cassandra
+      def truncate
+        table_cql.truncate
+      end
+    end
+
+    # Returns if model is dirty(some field were changed but model still not saved)
+    #
+    # @return [Boolean] is model dirty
+    def dirty?
+      return_value = false
+      @_attributes.each_value do |attr_value|
+        return_value = true if attr_value[:dirty?]
+      end
+      return_value
+    end
+
+    # Initialize model with hash due to options
+    #
+    # @param [Hash] hsh initialization attributes
+    # @param [Hash] options initalization options
+    # @option options [Bolean] :dirty dirtiness of initialized model
+    # @raise [WrongModelInitialization] raised if passed previously not described attribute
+    def initialize(hsh = {}, options={})
+      @_attributes = Hash.new{|hash, key| hash[key] = {}}
+      hsh.each_pair do |key, value|
+        if self.class.attributes.has_key?(key.intern)
+          @_attributes[key.intern][:value] = value
+          @_attributes[key.intern][:dirty?] = options[:dirty].nil? ? true : options[:dirty]
+        else
+          raise WrongModelInitialization, "Can`t initialize Model with attribute - #{key} ,that are not described in Model definition."
+        end
+      end
+    end
+
+    # Comparator for current and other model
+    #
+    # @param [Model] other model to compare with
+    # @return [Boolean] true if attrbitues of models are equal and each attribute of other model equal to proper attribute of current model, false otherwise
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      return false unless self.class.attributes.keys.sort == other.class.attributes.keys.sort
+
+      self.class.attributes.keys.each do |attr|
+        return false unless self.send(attr) == other.send(attr)
+      end
+
+      return true
+    end
+
+    # Save the Model within Cassandra
+    def save
+      insert_hash = {}
+
+      @_attributes.keys.each do |key|
+        insert_hash[key.to_s] = self.send(key) if self.class.get_primary_key.include?(key) || @_attributes[key.intern][:dirty?]
+      end
+
+      self.class.table_cql.create(insert_hash)
+      self.dirty = false
+    end
+
+    # Delete the Model within Cassandra
+    def delete
+      delete_hash = {}
+      self.class.get_primary_key.each{|pk| delete_hash[pk.to_s]=self.send(pk)}
+      self.class.table_cql.delete(delete_hash)
+      self.dirty = false
+    end
+
+    private
+
+    # Set dirtiness for the whole Model
+    def dirty=(new_dirty_value, columns = nil)
+      columns ||= @_attributes.keys
+      @_attributes.each_key do |attr_name|
+        @_attributes[attr_name][:dirty?] = new_dirty_value if columns.include?(attr_name)
+      end
+    end
+
+  end
+end