cassandra_model 0.9.3.2

data/lib/cassandra_model/result_paginator.rb

@@ -0,0 +1,37 @@
+module CassandraModel
+  class ResultPaginator
+    include Enumerable
+
+    def initialize(first_page, &callback)
+      @page = first_page
+      @callback = callback
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      each_slice { |slice| slice.each(&block) }
+    end
+
+    def each_slice
+      return to_enum(:each_slice) unless block_given?
+
+      current_page = @page
+      loop do
+        page_results = current_page.get
+        modified_results = page_results.map { |result| @callback.call(result, page_results.execution_info) }
+        break if page_results.empty?
+        if page_results.last_page?
+          yield modified_results
+          break
+        else
+          current_page = page_results.next_page_async
+          yield modified_results
+        end
+      end
+    end
+
+    alias :get :to_a
+
+  end
+end

data/lib/cassandra_model/rotating_table.rb

@@ -0,0 +1,49 @@
+module CassandraModel
+  class RotatingTable
+    extend Forwardable
+
+    def_delegators :first_table, :primary_key, :partition_key, :clustering_columns, :columns
+    def_delegators :table, :connection, :name, :truncate!
+
+    def initialize(tables, schedule)
+      columns = tables.first.columns
+      raise 'RotatingTable, Table columns do not match' unless valid_tables?(columns, tables)
+
+      @tables = tables
+      @schedule = schedule
+    end
+
+    def allow_truncation!
+      tables.each(&:allow_truncation!)
+    end
+
+    def reset_local_schema!
+      @tables.reject { |table| table.is_a?(MetaTable) }.each(&:reset_local_schema!)
+    end
+
+    def ==(rhs)
+      @schedule == rhs.schedule &&
+          @tables == rhs.tables
+    end
+
+    protected
+
+    attr_reader :schedule, :tables
+
+    private
+
+    def first_table
+      @tables.first
+    end
+
+    def table
+      index = (Time.now.to_f / @schedule).to_i % @tables.count
+      @tables[index]
+    end
+
+    def valid_tables?(columns, tables)
+      tables.map(&:columns).reduce(&:|) == columns
+    end
+
+  end
+end

data/lib/cassandra_model/single_token_batch.rb

@@ -0,0 +1,23 @@
+module CassandraModel
+  module SingleTokenBatch
+    extend Forwardable
+    include Enumerable
+
+    attr_writer :result
+
+    def_delegators :result, :execution_info, :empty?, :each
+
+    def keyspace
+      nil
+    end
+
+    def partition_key
+      @statements.first.partition_key
+    end
+
+    private
+
+    attr_reader :result
+
+  end
+end

data/lib/cassandra_model/single_token_counter_batch.rb

@@ -0,0 +1,5 @@
+module CassandraModel
+  class SingleTokenCounterBatch < Cassandra::Statements::Batch::Counter
+    include SingleTokenBatch
+  end
+end

data/lib/cassandra_model/single_token_logged_batch.rb

@@ -0,0 +1,5 @@
+module CassandraModel
+  class SingleTokenLoggedBatch < Cassandra::Statements::Batch::Logged
+    include SingleTokenBatch
+  end
+end

data/lib/cassandra_model/single_token_unlogged_batch.rb

@@ -0,0 +1,5 @@
+module CassandraModel
+  class SingleTokenUnloggedBatch < Cassandra::Statements::Batch::Unlogged
+    include SingleTokenBatch
+  end
+end

data/lib/cassandra_model/table_definition.rb

@@ -0,0 +1,72 @@
+module CassandraModel
+  class TableDefinition
+    attr_reader :name
+
+    def self.from_data_model(name, inquirer, data_set)
+      partition_key = inquirer_partition_key(inquirer)
+      partition_key.merge!(rk_shard: :int) if inquirer.is_sharding
+      clustering_columns = table_set_clustering_columns(data_set)
+      remaining_columns = table_set_remaining_columns(data_set)
+      new(name: name, partition_key: partition_key,
+          clustering_columns: clustering_columns,
+          remaining_columns: remaining_columns)
+    end
+
+    def initialize(options)
+      @partition_key = options[:partition_key].keys
+      @clustering_columns = options[:clustering_columns].keys
+      @name = options[:name]
+      @columns = options[:partition_key].merge(options[:clustering_columns].merge(options[:remaining_columns]))
+    end
+
+    def to_cql(options = {})
+      table_name = options[:no_id] ? name : name_in_cassandra
+      exists = if options[:check_exists]
+                 'IF NOT EXISTS '
+               end
+      "CREATE TABLE #{exists}#{table_name} (#{columns}, PRIMARY KEY #{primary_key})"
+    end
+
+    def table_id
+      Digest::MD5.hexdigest(columns)
+    end
+
+    def name_in_cassandra
+      "#{name}_#{table_id}"
+    end
+
+    def ==(rhs)
+      to_cql == rhs.to_cql
+    end
+
+    private
+
+    def self.table_set_remaining_columns(data_set)
+      data_set.columns.except(*data_set.clustering_columns)
+    end
+
+    def self.table_set_clustering_columns(data_set)
+      data_set.clustering_columns.inject({}) do |memo, column|
+        memo.merge!(:"ck_#{column}" => data_set.columns[column])
+      end
+    end
+
+    def self.inquirer_partition_key(inquirer)
+      inquirer.partition_key.inject({}) do |memo, (key, value)|
+        memo.merge!(:"rk_#{key}" => value)
+      end
+    end
+
+    def columns
+      @columns.map { |name, type| "#{name} #{type}" } * ', '
+    end
+
+    def primary_key
+      if @clustering_columns.present?
+        "((#{@partition_key * ', '}), #{@clustering_columns * ', '})"
+      else
+        "((#{@partition_key * ', '}))"
+      end
+    end
+  end
+end

data/lib/cassandra_model/table_descriptor.rb

@@ -0,0 +1,49 @@
+module CassandraModel
+  class TableDescriptor < Record
+
+    class << self
+      def create_async(table_definition)
+        super(table_descriptor(table_definition), check_exists: true)
+      end
+
+      def create(table_definition)
+        create_async(table_definition).get
+      end
+
+      def create_descriptor_table
+        session.execute(table_desc.to_cql(no_id: true)) unless descriptor_table_exists?
+      end
+
+      def drop_descriptor_table
+        session.execute("DROP TABLE #{table_name}") if descriptor_table_exists?
+      end
+
+      private
+
+      def descriptor_table_exists?
+        table.connection.keyspace.table(table.name)
+      end
+
+      def table_descriptor(table_definition)
+        {name: table_definition.name.to_s,
+         created_at: rounded_time,
+         id: table_definition.table_id}
+      end
+
+      def rounded_time
+        Time.at((Time.now.to_i / 1.day) * 1.day)
+      end
+
+      def table_desc
+        @table_desc ||= begin
+          options = {name: table_name,
+                     partition_key: {name: :ascii},
+                     clustering_columns: {id: :ascii},
+                     remaining_columns: {created_at: :timestamp}}
+          TableDefinition.new(options)
+        end
+      end
+    end
+
+  end
+end

data/lib/cassandra_model/table_redux.rb

@@ -0,0 +1,58 @@
+module CassandraModel
+  class TableRedux
+    extend Forwardable
+
+    attr_reader :name
+
+    def initialize(connection_name = nil, table_name)
+      @name = table_name.to_s
+      @connection_name = connection_name
+    end
+
+    #noinspection RubyUnusedLocalVariable
+    def in_context(time)
+      yield self
+    end
+
+    def connection
+      ConnectionCache[@connection_name]
+    end
+
+    def allow_truncation!
+      @allow_truncation = true
+    end
+
+    def truncate!
+      raise "Truncation not enabled for table '#{name}'" unless @allow_truncation
+      connection.session.execute("TRUNCATE #{name}")
+    end
+
+    def reset_local_schema!
+      @partition_key = nil
+      @clustering_columns = nil
+      @columns = nil
+    end
+
+    def partition_key
+      @partition_key ||= table.send(:partition_key).map { |column| column.name.to_sym }
+    end
+
+    def clustering_columns
+      @clustering_columns ||= table.send(:clustering_columns).map { |column| column.name.to_sym }
+    end
+
+    def primary_key
+      partition_key + clustering_columns
+    end
+
+    def columns
+      @columns ||= table.columns.map { |column| column.name.to_sym }
+    end
+
+    private
+
+    def table
+      connection.keyspace.table(name)
+    end
+  end
+end

data/lib/cassandra_model/type_guessing.rb

@@ -0,0 +1,40 @@
+module TypeGuessing
+  def guess_data_types!
+    @guess_data_types = true
+  end
+
+  private
+
+  class DataTypeGuess < Struct.new(:column, :counter_type)
+    def guessed_type
+      postfix_type || :text
+    end
+
+    private
+
+    def postfix_type
+      if column =~ /_at$/
+        :timestamp
+      elsif column =~ /_at_id$/
+        :timeuuid
+      elsif column =~ /_id$/
+        :uuid
+      elsif column =~ /_(price|average|stddev)$/
+        :double
+      elsif column =~ /_(total|count)$/
+        counter_type
+      elsif column =~ /_(year|day|month|index)$/
+        :int
+      elsif column =~ /_data/
+        :blob
+      elsif column =~ /_map$/
+        'map<string, string>'
+      end
+    end
+  end
+
+  def guessed_data_type(column, counter_type)
+    DataTypeGuess.new(column, counter_type).guessed_type
+  end
+
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: cassandra_model
+version: !ruby/object:Gem::Version
+  version: 0.9.3.2
+platform: ruby
+authors:
+- Thomas RM Rogers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: batch_reactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: thomas_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.13
+description: |-
+  Cassandra data modelling framework for Ruby that makes
+  data modelling for Cassandra tables easy, fast, and stable
+email: thomasrogers03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/cassandra_model.rb
+- lib/cassandra_model/batch_reactor.rb
+- lib/cassandra_model/batch_reactor/future.rb
+- lib/cassandra_model/composite_record.rb
+- lib/cassandra_model/composite_record_static.rb
+- lib/cassandra_model/connection_cache.rb
+- lib/cassandra_model/counter_record.rb
+- lib/cassandra_model/data_inquirer.rb
+- lib/cassandra_model/data_modelling.rb
+- lib/cassandra_model/data_set.rb
+- lib/cassandra_model/displayable_attributes.rb
+- lib/cassandra_model/global_callbacks.rb
+- lib/cassandra_model/logging.rb
+- lib/cassandra_model/meta_columns.rb
+- lib/cassandra_model/meta_table.rb
+- lib/cassandra_model/query_builder.rb
+- lib/cassandra_model/query_helper.rb
+- lib/cassandra_model/query_result.rb
+- lib/cassandra_model/raw_connection.rb
+- lib/cassandra_model/record.rb
+- lib/cassandra_model/result_paginator.rb
+- lib/cassandra_model/rotating_table.rb
+- lib/cassandra_model/single_token_batch.rb
+- lib/cassandra_model/single_token_counter_batch.rb
+- lib/cassandra_model/single_token_logged_batch.rb
+- lib/cassandra_model/single_token_unlogged_batch.rb
+- lib/cassandra_model/table_definition.rb
+- lib/cassandra_model/table_descriptor.rb
+- lib/cassandra_model/table_redux.rb
+- lib/cassandra_model/type_guessing.rb
+homepage: https://www.github.com/thomasrogers03/cassandra_model
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Cassandra data modelling framework for Ruby
+test_files: []