quandl_cassandra 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+/Gemfile.lock
+/pkg
+/tmp
+quandl_cassandra-*
+.rvmrc
+*.gem
+*.log

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012-2013 Blake Hilscher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# Installation
+
+```ruby
+
+gem 'quandl_cassandra'
+
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+require "rake"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "spec/**/*_spec.rb"
+end

data/UPGRADE.md

@@ -0,0 +1,3 @@
+## 0.0.1
+
+* Begin

data/lib/quandl/cassandra/base/attributes.rb

@@ -0,0 +1,103 @@
+module Quandl
+module Cassandra
+class Base
+  
+module Attributes
+  
+  extend ActiveSupport::Concern
+  
+  included do
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+  end
+  
+  module ClassMethods
+  
+    def define_attributes(*names)
+      Array(names).each{|name| define_attribute(name) }
+    end
+    
+    def define_attribute(name)
+      name = name.to_sym
+      self.class_eval do
+        define_attribute_methods [name.to_sym]
+      end
+      define_method(name) do
+        read_attribute(name)
+      end
+      define_method("#{name}=") do |value|
+        write_attribute(name, value)
+      end
+      define_method("#{name}?") do
+        read_attribute(name).present?
+      end
+      # store an array of defined attriubte names
+      attribute_names << name unless attribute_names.include?(name)
+    end
+    
+    def attribute_names
+      @attribute_names ||= []
+    end
+    
+  end
+  
+  def initialize(*args)
+    self.assign_attributes(args.extract_options!)
+  end
+  
+  def inspect
+    "#{self.class.name} " + attributes.inspect
+  end
+  
+  def assign_attributes(hash)
+    hash.each do |k,v|
+      send("#{k}=", v) if self.class.attribute_names.include?(k) && respond_to?("#{k}=")
+    end
+  end
+  
+  def attributes
+    @attributes ||= self.class.attribute_names.inject({}){|m,k| m[k] ||= nil; m }
+  end
+  
+  def attributes=(value)
+    @attributes = value.symbolize_keys! if value.is_a?(Hash)
+  end
+  
+  def save
+    cycle_changes!
+  end
+  
+  def reload
+    clear_changes!
+  end
+  
+  protected
+  
+  def write_attribute(attribute, value)
+    self.send(:"#{attribute}_will_change!") if self.attributes[:"#{attribute}"] != value
+    @attributes[:"#{attribute}"] = value
+  end
+  
+  def read_attribute(attribute)
+    @attributes[:"#{attribute}"]
+  end
+  
+  def attribute_changed?(attribute)
+    !changes[attribute.to_s].nil?
+  end
+  
+  def clear_changes!
+    @previously_changed = {}
+    @changed_attributes.clear
+  end
+  
+  def cycle_changes!
+    @previously_changed = changes
+    @changed_attributes.clear
+  end
+  
+end
+
+end
+end
+end

data/lib/quandl/cassandra/base/callbacks.rb

@@ -0,0 +1,15 @@
+module Quandl::Cassandra::Base::Callbacks
+  
+  extend ActiveSupport::Concern
+  
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create, :update, :save, :find, :destroy, :initialize
+  end
+  
+  def initialize(*args)
+    super if defined?(super)
+    run_callbacks :initialize
+  end
+  
+end

data/lib/quandl/cassandra/base/connection.rb

@@ -0,0 +1,49 @@
+module Quandl::Cassandra::Base::Connection
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def delete(*ids)
+      statement = prepare("DELETE FROM #{table_name} WHERE id = ?")
+      Array(ids).flatten.
+        collect{|id| statement.async.execute(id, consistency) }.
+        collect(&:value)
+    end
+    
+    def prepare(statement)
+      connection.prepare(statement)
+    end
+    
+    def execute_async(statement, query_consistency = nil)
+      query_consistency = consistency unless query_consistency.present?
+      connection.async.execute( statement, query_consistency )
+    end
+    
+    def execute(statement, query_consistency = nil)
+      query_consistency = consistency unless query_consistency.present?
+      connection.execute( statement, query_consistency )
+    end
+    
+    def connection
+      @connection ||= connect
+    end
+    
+    def consistency
+      Quandl::Cassandra.configuration.consistency
+    end
+    
+    protected
+    
+    def connect
+      c = Cql::Client.connect(
+        hosts:        Quandl::Cassandra.configuration.hosts, 
+        consistency:  Quandl::Cassandra.configuration.consistency )
+      # switch keyspace
+      c.use( Quandl::Cassandra.configuration.keyspace )
+      c
+    end
+    
+  end  
+  
+end

data/lib/quandl/cassandra/base/logging.rb

@@ -0,0 +1,40 @@
+module Quandl::Cassandra::Base::Logging
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def prepare(*args, &block)
+      statement = args.first.to_s
+      statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
+      Quandl::Logger.debug(statement)
+      super if defined?(super)
+    end
+    
+    def execute_async(*args, &block)
+      statement = args.first.to_s
+      statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
+      t1 = Time.now
+      begin
+        r = super if defined?(super)
+      ensure
+        Quandl::Logger.debug("(#{t1.elapsed_ms}) #{statement}")
+      end
+      r
+    end
+    
+    def execute(*args, &block)
+      statement = args.first.to_s
+      statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
+      t1 = Time.now
+      begin
+        r = super if defined?(super)
+      ensure
+        Quandl::Logger.debug("(#{t1.elapsed_ms}) #{statement}")
+      end
+      r
+    end
+    
+  end  
+  
+end

data/lib/quandl/cassandra/base/naming.rb

@@ -0,0 +1,19 @@
+module Quandl::Cassandra::Base::Naming
+  
+  extend ActiveSupport::Concern
+  
+  included do
+    include ActiveModel::Conversion
+    include ActiveModel::Naming
+  end
+  
+  module ClassMethods
+
+    def table_name(*args)
+      @table_name = args.first.to_s if args.first.present?
+      @table_name ||= model_name.plural
+    end
+    
+  end
+  
+end

data/lib/quandl/cassandra/base/persistence.rb

@@ -0,0 +1,67 @@
+module Quandl::Cassandra::Base::Persistence
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def autosave_changes(*args)
+      @autosave_changes = (args.first == true) unless args.first.nil?
+      @autosave_changes = true if @autosave_changes.nil?
+      @autosave_changes
+    end
+    
+    def find_or_build(id)
+      find(id) || new( id: id )
+    end
+    
+    def create(*args)
+      r = self.new(*args)
+      r.save
+      r
+    end
+    
+    def new_from_query_result(result)
+      return nil if result.blank?
+      r = self.new
+      r.attributes = result
+      r
+    end
+    
+  end
+  
+  def save!
+    save
+  end
+  
+  def save
+    run_callbacks :save do
+      touch
+      save_changes! if self.class.autosave_changes == true
+      clear_changes!
+    end
+  end
+  
+  def touch
+    self.created_at = Time.now if respond_to?(:created_at=) && created_at.blank?
+    self.updated_at = Time.now if respond_to?(:updated_at=)
+  end
+  
+  def update_attributes(values)
+    values = self.class.sanitize_attributes(values)
+    # add primary key parts to values
+    self.class.primary_key.each do |attribute|
+      values[attribute.to_s] = sanitized_attribute(attribute) unless values.has_key?(attribute.to_s)
+    end
+    # update
+    self.class.execute("INSERT INTO #{self.class.table_name} (#{values.keys.join(', ')}) VALUES (#{values.values.join(', ')})")
+  end
+  
+  private
+  
+  def save_changes!
+    attrs = {}
+    changes.each{|k,v| attrs[k] = v[1] }
+    update_attributes(attrs)
+  end
+  
+end

data/lib/quandl/cassandra/base/sanitization.rb

@@ -0,0 +1,38 @@
+module Quandl::Cassandra::Base::Sanitization
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def bind_primary_key(*args)
+      if args.count > primary_key.count
+        message = "wrong number of arguments (#{args.count} for 1..#{primary_key.count}) expected: #{primary_key.join(', ')}"
+        raise(ArgumentError, message)
+      end
+      attrs = {}
+      primary_key.each_with_index { |k, i| attrs[k] = args[i] if args[i].present? }
+      attrs
+    end
+    
+    def sanitize_attributes(attrs)
+      values = {}
+      attrs.each do |attribute, value|
+        # exclude attributes that are not present in columns
+        next unless column_type(attribute)
+        # sanitize value for cql
+        values[attribute] = sanitize_attribute(attribute, value)# unless value.nil?
+      end
+      values
+    end
+  
+    def sanitize_attribute(attribute, value)
+      column_type(attribute).sanitize_for_cql( value )
+    end
+    
+  end
+  
+  def sanitized_attribute(attribute)
+    self.class.sanitize_attribute(attribute, read_attribute(attribute))
+  end
+  
+end

data/lib/quandl/cassandra/base/schema.rb

@@ -0,0 +1,79 @@
+module Quandl::Cassandra::Base::Schema
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def initialize_class_once
+      return if defined?(@initialize_class_once)
+      define_schema_attributes
+      @initialize_class_once = true
+    end
+    
+    def column_type(type)
+      column_types[type.to_sym]
+    end
+    
+    def column_types
+      return @column_types if @column_types
+      @column_types = {}
+      columns.each do |c|
+        @column_types[c.column_name.to_sym] = Quandl::Cassandra::Types.type( c.type )
+      end
+      @column_types
+    end
+    
+    def column_names
+      @column_names ||= columns.collect(&:column_name)
+    end
+    
+    def columns
+      @columns ||= execute("SELECT * FROM #{table_name} LIMIT 1").metadata
+    end
+    
+    def primary_key
+      @primary_key ||= key_aliases + column_aliases
+    end
+    
+    def column_aliases
+      @column_aliases ||= JSON.parse(system_schema['column_aliases']).collect(&:to_sym)
+    rescue
+      []
+    end
+    
+    def key_aliases
+      @key_aliases ||= JSON.parse(system_schema['key_aliases']).collect(&:to_sym)
+    rescue
+      []
+    end
+    
+    def table_exists?
+      system_schema.present?
+    end
+    
+    def system_schema
+      return @system_schema if defined?(@system_schema)
+      @system_schema = execute(%Q{
+        SELECT * FROM system.schema_columnfamilies WHERE 
+        keyspace_name='#{Quandl::Cassandra.configuration.keyspace}' 
+        AND columnfamily_name = '#{table_name}'
+        }).first
+    end
+    
+    private
+    
+    def define_schema_attributes
+      self.class_eval do
+        define_attributes *column_names
+      end
+    end
+    
+  end
+  
+  def initialize(*args, &block)
+    self.class.initialize_class_once
+    super if defined?(super)
+  end
+  
+end
+