quandl_cassandra 1.3.1 → 1.4.0

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

@@ -1,89 +1,94 @@
 module Quandl::Cassandra::Base::Schema
-  
   extend ActiveSupport::Concern
-    
+
   def primary_key?
     !primary_key_attributes.values.include?(nil)
   end
-    
+
   def primary_key_attributes
-    self.class.primary_key.inject({}){|m,key| m[key] = self.send(key); m }
+    self.class.primary_key.inject({}) { |m,key| m[key] = self.send(key); m }
   end
-  
+
   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 )
+      unless @column_types && @column_types.is_a?(Hash) && !@column_types.empty?
+        @column_types = {}
+        columns.each do |c|
+          @column_types[c.column_name.to_sym] = Quandl::Cassandra::Types.type(c.type)
+        end
+        Quandl::Logger.info("Column types for #{self.to_s}: #{@column_types}")
       end
       @column_types
     end
-    
+
     def column_names
-      @column_names ||= columns.collect(&:column_name)
+      unless @column_names && @column_names.is_a?(Array) && !@column_names.empty?
+        @column_names = columns.map(&:column_name)
+        Quandl::Logger.info("Column names for #{self.to_s}: #{@column_names.join(', ')}")
+      end
+      @column_names
     end
-    
+
     def columns
-      @columns ||= execute("SELECT * FROM #{table_name} LIMIT 1").metadata
+      unless @columns && @columns.is_a?(Cql::Client::ResultMetadata)
+        @columns = execute("SELECT * FROM #{table_name} LIMIT 1").metadata
+        Quandl::Logger.info("Columns for #{self.to_s} #{@columns.inspect}")
+      end
+      @columns
     end
-    
+
     def primary_key
       @primary_key ||= key_aliases + column_aliases
     end
-    
+
     def column_aliases
       return [] if system_schema.blank?
-      @column_aliases ||= JSON.parse(system_schema['column_aliases']).collect(&:to_sym)
+      @column_aliases ||= JSON.parse(system_schema['column_aliases']).map(&:to_sym)
     rescue JSON::ParserError
       []
     end
-    
+
     def key_aliases
       return [] if system_schema.blank?
-      @key_aliases ||= JSON.parse(system_schema['key_aliases']).collect(&:to_sym)
+      @key_aliases ||= JSON.parse(system_schema['key_aliases']).map(&:to_sym)
     rescue JSON::ParserError
       []
     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}' 
+        SELECT * FROM system.schema_columnfamilies WHERE
+        keyspace_name='#{Quandl::Cassandra.configuration.keyspace}'
         AND columnfamily_name = '#{table_name}'
         }, 'ONE').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
-

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

@@ -1,122 +1,118 @@
 module Quandl::Cassandra::Base::Scoping
-  
   extend ActiveSupport::Concern
-  
+
   module ClassMethods
-    
     def scope_names
       scope.scope_names
     end
-    
+
     def where(*args)
       scope.new.where(*args)
     end
-    
   end
-  
+
   included do
-  
     include ScopeComposer::Model
-  
+
     has_scope_composer
-    
+
     scope :select, :delete_all, :limit,
       :order, :count, :find, :first, :all, :pluck, :exists?, :to_h
-    
+
     scope.class_eval do
-      
+
       attr_accessor :statement_type
-      
+
       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  
+          else
             yield record
           end
-        end  
+        end
       end
-      
+
       def exists?
         columns = primary_key.collect{|pk| attributes.keys.include?(pk) ? pk : nil }.compact
         select(*columns).execute.present?
       end
-      
+
       def to_h
         execute
       end
-      
+
       def pluck(*args)
         r = select(*args).values
         r = r.flatten if args.count <= 1
         r
       end
-      
+
       def select=(*names)
         self.statement_type = :select
         write_scope_attribute(:select, names)
       end
-      
+
       def values
         to_a.collect(&:values)
       end
-      
+
       def find(*args)
         primary_key = parent.bind_primary_key(*args)
         return nil if primary_key.blank?
         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
         [cql_statement_type, table_name, cql_where, cql_order, cql_limit].compact.join(' ')
       end
-      
+
       def delete_all
         self.statement_type = :delete
         execute
       end
-      
+
       def insert
         self.statement_type = :insert
         self
       end
-      
+
       protected
-      
+
       def cql_statement_type
         case statement_type
         when :insert then "INSERT INTO"
-        when :delete then "DELETE FROM" 
+        when :delete then "DELETE FROM"
         else
           "SELECT #{cql_select} FROM"
         end
       end
-      
+
       def cql_where
         attrs = attributes.clone
         attrs = sanitize_attributes(attrs) if parent.table_exists?
         attrs = attrs.collect{|key, value| cql_where_attribute(key, value) }.join(' AND ')
         cql = attrs.present? ? "WHERE #{attrs}" : nil
       end
-      
+
       def cql_where_attribute(key, value)
         if value.is_a?(Array)
           "#{key} IN (#{value.join(',')})"
@@ -124,43 +120,43 @@ module Quandl::Cassandra::Base::Scoping
           "#{key} = #{value}"
         end
       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/batch/logging.rb

@@ -1,22 +1,22 @@
 class Quandl::Cassandra::Batch
-module Logging
+  module Logging
 
-  extend ActiveSupport::Concern
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def execute(rows, &block)
+        # log init
+        statement = block.call(rows[0].collect{'?'})
+        t1 = Time.now
+        # call method
+        r = super if defined?(super)
+        # log write
+        Quandl::Logger.debug("(#{t1.elapsed_ms}) ".blue + " [#{rows.count} rows] BATCH #{statement}")
+        r
+      end
 
-  module ClassMethods
-  
-    def execute(rows, &block)
-      # log init
-      statement = block.call(rows[0].collect{'?'})
-      t1 = Time.now
-      # call method
-      r = super if defined?(super)
-      # log write
-      Quandl::Logger.debug("(#{t1.elapsed_ms}) ".blue + " [#{rows.count} rows] BATCH #{statement}")
-      r
     end
-  
-  end
 
-end
+  end
 end

data/lib/quandl/cassandra/configuration.rb

@@ -1,40 +1,40 @@
 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, :read_consistency, :write_consistency
+  module Cassandra
     
-    def initialize
-      @hosts = ['localhost']
-      @consistency = :all
-      @read_consistency = :one
-      @write_consistency = :one
-      @batch_size = 35 * 4
+    class << self
+      attr_accessor :configuration
     end
     
-    def attributes
-      { hosts: hosts, consistency: consistency, keyspace: keyspace, batch_size: batch_size }
+    def self.configuration
+      @configuration ||= Configuration.new
     end
     
-    def to_h
-      attributes
+    def self.configure
+      yield(configuration)
+      true
+    end
+    
+    class Configuration
+    
+      attr_accessor :hosts, :consistency, :keyspace, :batch_size, :read_consistency, :write_consistency
+      
+      def initialize
+        @hosts = ['localhost']
+        @consistency = :all
+        @read_consistency = :one
+        @write_consistency = :one
+        @batch_size = 35 * 4
+      end
+      
+      def attributes
+        { hosts: hosts, consistency: consistency, keyspace: keyspace, batch_size: batch_size }
+      end
+      
+      def to_h
+        attributes
+      end
+      
     end
     
   end
-  
-end
 end

data/lib/quandl/cassandra/logger.rb

@@ -1,14 +1,14 @@
 module Quandl
-module Cassandra
-class Logger
-  class << self
-    
-    def method_missing(method_sym, *args, &block)
-      args[0] = "CASSANDRA ".blue + args[0].to_s
-      Quandl::Logger.send(method_sym, *args)
+  module Cassandra
+    class Logger
+      class << self
+
+        def method_missing(method_sym, *args, &block)
+          args[0] = "CASSANDRA ".blue + args[0].to_s
+          Quandl::Logger.send(method_sym, *args)
+        end
+
+      end
     end
-    
   end
-end
-end
 end