quandl_cassandra 0.0.1

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

@@ -0,0 +1,122 @@
+module Quandl::Cassandra::Base::Scoping
+  
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    
+    def where(*args)
+      scope.new.where(*args)
+    end
+    
+  end
+  
+  included do
+  
+    include ScopeComposer::Model
+  
+    has_scope_composer
+    
+    scope :select, :limit, :order, :count, :find, :first, :all, :pluck, :exists?
+    
+    scope.class_eval do
+      
+      delegate :to_a, to: :execute
+      
+      delegate :primary_key, :table_name, :sanitize_attributes, to: :parent
+      
+      include Enumerable
+      
+      def each(&block)
+        all.each do |record|
+          if block_given?
+            block.call(record)
+          else  
+            yield record
+          end
+        end  
+      end
+      
+      def exists?
+        columns = primary_key.collect{|pk| attributes.keys.include?(pk) ? pk : nil }.compact
+        select(*columns).execute.present?
+      end
+      
+      def pluck(*args)
+        r = select(*args).values
+        r = r.flatten if args.count <= 1
+        r
+      end
+      
+      def values
+        to_a.collect(&:values)
+      end
+      
+      def find(*args)
+        primary_key = parent.bind_primary_key(*args)
+        where(primary_key).first
+      end
+      
+      def first
+        limit(1).execute_returning_record
+      end
+      
+      def all
+        execute_returning_collection
+      end
+      
+      def count
+        select("COUNT(*)").execute.first.try(:[], 'count').to_i
+      end
+      
+      def to_cql
+        ["SELECT #{cql_select} FROM", table_name, cql_where, cql_order, cql_limit].compact.join(' ')
+      end
+      
+      protected
+      
+      def cql_where
+        attrs = attributes.clone
+        attrs = sanitize_attributes(attrs) if parent.table_exists?
+        attrs = attrs.collect{|k,v| "#{k} = #{v}" }.join(' AND ')
+        cql = attrs.present? ? "WHERE #{attrs}" : nil
+      end
+  
+      def cql_select
+        columns = Array(select).join(',') if select.present?
+        columns = '*' if columns.blank?
+        columns
+      end
+      
+      def cql_order
+        "ORDER BY #{order}" if order.present?
+      end
+      
+      def cql_limit
+        "LIMIT #{limit}" if limit.present?
+      end
+      
+      def execute
+        @execute ||= parent.execute(to_cql)
+      end
+      
+      def execute_async
+        @execute_async ||= parent.execute(to_cql)
+      end
+      
+      def parent
+        self.class.parent
+      end
+      
+      def execute_returning_collection
+        execute.collect{|r| parent.new_from_query_result(r) }
+      end
+      
+      def execute_returning_record
+        parent.new_from_query_result( execute.first )
+      end
+  
+    end
+    
+  end
+  
+end

data/lib/quandl/cassandra/base.rb

@@ -0,0 +1,51 @@
+require 'active_model'
+require 'active_model/attribute_methods'
+require 'active_model/dirty'
+require 'active_model/validations'
+require 'active_model/conversion'
+require 'active_model/naming'
+require 'active_model/callbacks'
+
+require 'quandl/cassandra/base/attributes'
+require 'quandl/cassandra/base/callbacks'
+require 'quandl/cassandra/base/connection'
+require 'quandl/cassandra/base/naming'
+require 'quandl/cassandra/base/persistence'
+require 'quandl/cassandra/base/logging'
+require 'quandl/cassandra/base/sanitization'
+require 'quandl/cassandra/base/schema'
+require 'quandl/cassandra/base/scoping'
+
+class Quandl::Cassandra::Base
+  
+  include Quandl::Cassandra::Base::Connection
+  include Quandl::Cassandra::Base::Logging if defined?(QUANDL_LOGGER) && QUANDL_LOGGER == true
+  
+  class << self
+    
+    def inherited(subclass)
+      # remember models that inherit from base
+      models << subclass unless models.include?(subclass)
+      # include model behaviour
+      subclass.class_eval do
+        
+        include ActiveModel::Validations
+
+        include Quandl::Cassandra::Base::Scoping
+        include Quandl::Cassandra::Base::Naming
+        include Quandl::Cassandra::Base::Attributes
+        include Quandl::Cassandra::Base::Persistence
+        include Quandl::Cassandra::Base::Sanitization
+        include Quandl::Cassandra::Base::Schema
+        include Quandl::Cassandra::Base::Callbacks
+        
+      end
+    end
+    
+    def models
+      @@models ||= []
+    end
+    
+  end
+  
+end

data/lib/quandl/cassandra/configuration.rb

@@ -0,0 +1,34 @@
+module Quandl
+module Cassandra
+  
+  class << self
+    attr_accessor :configuration
+  end
+  
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  
+  def self.configure
+    yield(configuration)
+    true
+  end
+  
+  class Configuration
+  
+    attr_accessor :hosts, :consistency, :keyspace, :batch_size
+    
+    def initialize
+      @hosts = ['localhost']
+      @consistency = :all
+      @batch_size = 35
+    end
+    
+    def to_h
+      self.attributes
+    end
+    
+  end
+  
+end
+end

data/lib/quandl/cassandra/error.rb

@@ -0,0 +1,10 @@
+module Quandl::Cassandra::Error
+  class CastException < Exception
+    attr_reader :bytes
+
+    def initialize(message = nil, bytes = nil)
+      super(message)
+      @bytes = bytes
+    end
+  end
+end

data/lib/quandl/cassandra/types/abstract_type.rb

@@ -0,0 +1,33 @@
+class Quandl::Cassandra::Types::AbstractType
+
+  class << self
+    
+    def sanitize_for_cql(value)
+      sanitize(value)
+    end
+    
+    def sanitize(value)
+      value
+    end
+    
+    def quote_string(value)
+      ["'",value.to_s.gsub(/[']/, '\\\\\''),"'"].join
+    end
+    
+  end
+      
+  attr_accessor :value
+      
+  def initialize(v)
+    self.value = v
+  end
+  
+  def sanitize_for_cql
+    self.class.sanitize_for_cql(value)
+  end
+  
+  def sanitize
+    self.class.sanitize(value)
+  end
+  
+end

data/lib/quandl/cassandra/types/boolean_type.rb

@@ -0,0 +1,10 @@
+class Quandl::Cassandra::Types::BooleanType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    return true if value == true || value.to_s =~ (/(true|t|yes|y|1)$/i)
+    return false if value == false || value.blank? || value.to_s =~ (/(false|f|no|n|0)$/i)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/decimal_type.rb

@@ -0,0 +1,9 @@
+class Quandl::Cassandra::Types::DecimalType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    Float(value)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/double_type.rb

@@ -0,0 +1,9 @@
+class Quandl::Cassandra::Types::DoubleType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    Float(value)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/float_type.rb

@@ -0,0 +1,9 @@
+class Quandl::Cassandra::Types::FloatType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    Float(value)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/integer_type.rb

@@ -0,0 +1,9 @@
+class Quandl::Cassandra::Types::IntegerType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    Integer(value)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/long_type.rb

@@ -0,0 +1,9 @@
+class Quandl::Cassandra::Types::LongType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize(value)
+    Integer(value)
+  rescue
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert value to #{self.class}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/timestamp_type.rb

@@ -0,0 +1,15 @@
+class Quandl::Cassandra::Types::TimestampType < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize_for_cql(value)
+    (value.to_f * 1000).to_i
+  end
+  
+  def self.sanitize(value)
+    return value if value.is_a?(Time)
+    return Time.at(value.get_time / 1000.0) if value.respond_to?(:get_time)
+    Time.at(value.to_f) if value.present?
+  rescue => error
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert to Timestamp #{value} #{error}", value)
+  end
+  
+end

data/lib/quandl/cassandra/types/utf8_type.rb

@@ -0,0 +1,13 @@
+class Quandl::Cassandra::Types::UTF8Type < Quandl::Cassandra::Types::AbstractType
+  
+  def self.sanitize_for_cql(value)
+    quote_string( sanitize(value) )
+  end
+  
+  def self.sanitize(value)
+    RUBY_VERSION >= "1.9" ? value.to_s.dup.force_encoding('UTF-8') : value.to_s.dup
+  rescue => e
+    raise Quandl::Cassandra::Error::CastException.new("Unable to convert to UTF8", caller)
+  end
+  
+end

data/lib/quandl/cassandra/types/uuid_type.rb

@@ -0,0 +1,21 @@
+module Quandl::Cassandra::Types
+  
+  class UUIDType < Quandl::Cassandra::Types::AbstractType
+  
+    def self.sanitize(value)
+      value = value.to_s
+      raise Quandl::Cassandra::Error::CastException, "Unable to convert to UUID", caller unless value =~ regex_validator
+      value
+    rescue => e
+      raise 
+    end
+
+    def self.regex_validator
+      /^[A-Za-z0-9]{8}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{12}$/
+    end
+    
+  end
+  
+  class TimeUUIDType < UUIDType; end
+  
+end

data/lib/quandl/cassandra/types.rb

@@ -0,0 +1,42 @@
+module Quandl::Cassandra::Types
+  
+  require 'quandl/cassandra/types/abstract_type'
+  require 'quandl/cassandra/types/boolean_type'
+  require 'quandl/cassandra/types/timestamp_type'
+  require 'quandl/cassandra/types/decimal_type'
+  require 'quandl/cassandra/types/double_type'
+  require 'quandl/cassandra/types/float_type'
+  require 'quandl/cassandra/types/integer_type'
+  require 'quandl/cassandra/types/long_type'
+  require 'quandl/cassandra/types/utf8_type'
+  require 'quandl/cassandra/types/uuid_type'
+  
+  class << self
+    def type(type)
+      self.types[type]
+    end
+    
+    def types
+      @@types ||= {
+        bigint:      Quandl::Cassandra::Types::DoubleType,
+        blob:        Quandl::Cassandra::Types::UTF8Type,
+        boolean:     Quandl::Cassandra::Types::BooleanType,
+        counter:     Quandl::Cassandra::Types::IntegerType,
+        decimal:     Quandl::Cassandra::Types::FloatType,
+        double:      Quandl::Cassandra::Types::IntegerType,
+        float:       Quandl::Cassandra::Types::FloatType,
+        int:         Quandl::Cassandra::Types::IntegerType,
+        timestamp:   Quandl::Cassandra::Types::TimestampType,
+        varchar:     Quandl::Cassandra::Types::UTF8Type,
+        text:        Quandl::Cassandra::Types::UTF8Type,
+        varint:      Quandl::Cassandra::Types::IntegerType,
+        timeuuid:    Quandl::Cassandra::Types::TimestampType,
+        uuid:        Quandl::Cassandra::Types::UUIDType,
+        inet:        Quandl::Cassandra::Types::UTF8Type,
+      }
+    end
+  end
+  
+end
+
+

data/lib/quandl/cassandra/version.rb

@@ -0,0 +1,5 @@
+module Quandl
+module Cassandra
+  VERSION = '0.0.1'
+end
+end

data/lib/quandl/cassandra.rb

@@ -0,0 +1,30 @@
+require 'quandl/cassandra/version'
+
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object"
+
+require 'cql'
+require 'scope_composer'
+
+require 'quandl/logger'
+require "quandl/data"
+require 'quandl/strategy'
+
+require 'quandl/cassandra/error'
+require 'quandl/cassandra/types'
+require 'quandl/cassandra/base'
+require 'quandl/cassandra/configuration'
+
+require 'quandl/cassandra_models/column'
+require 'quandl/cassandra_models/column_attribute'
+require 'quandl/cassandra_models/data'
+require 'quandl/cassandra_models/dataset'
+require 'quandl/cassandra_models/dataset_attribute'
+require 'quandl/cassandra_models/multiset'
+
+module Quandl
+module Cassandra
+end
+end