virsandra 0.5.0

data/lib/virsandra/model_query.rb

@@ -0,0 +1,52 @@
+module Virsandra
+  class ModelQuery
+
+    def initialize(model)
+      @model = model
+    end
+
+    def find_by_key
+      return {} unless @model.valid?
+      query = Query.select.from(@model.table).where(@model.key)
+      query.fetch
+    end
+
+    def save
+      query = Query.insert.into(@model.table).values(@model.attributes)
+      query.fetch
+    end
+
+    def delete
+      query = Query.delete.from(@model.table).where(@model.key)
+      query.fetch
+    end
+
+    def where(params)
+      query = Query.select.from(@model.table)
+
+      unless params.empty?
+        raise ArgumentError.new("Invalid search terms") unless valid_search_params?(params)
+        query.where(params)
+      end
+
+      query_enumerator(query)
+    end
+
+    private
+
+    def valid_search_params?(params)
+      params.keys.all? { |k| @model.column_names.include?(k.to_sym) }
+    end
+
+    def query_enumerator(query)
+      Enumerator.new do |yielder|
+        rows = query.execute
+        rows.each do |row|
+          record = @model.new(row.to_hash)
+          yielder.yield record
+        end
+      end
+    end
+
+  end
+end

data/lib/virsandra/queries/add_query.rb

@@ -0,0 +1,25 @@
+module Virsandra
+  class AddQuery < Query
+    def initialize(column_name, column_type = nil)
+      @column_name = column_name
+      @column_type = column_type.to_s.empty? ? "varchar" : column_type
+    end
+
+    def to_s
+      validate
+      super
+    end
+
+    private
+
+    def raw_query
+      ["ADD", @column_name, @column_type]
+    end
+
+    def validate
+      if @column_name.to_s.empty?
+        raise InvalidQuery.new("You must specify column name")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/alter_query.rb

@@ -0,0 +1,34 @@
+module Virsandra
+  class AlterQuery < Query
+    def initialize(skip_validation = false)
+      @skip_validation = skip_validation
+    end
+
+    def table(table_name)
+      @table = TableQuery.new("TABLE", table_name)
+      self
+    end
+
+    def add(column_name, column_type = nil)
+      @add = AddQuery.new(column_name, column_type)
+      self
+    end
+
+    def to_s
+      validate
+      super
+    end
+
+    private
+
+    def raw_query
+      ["ALTER", @table, @add]
+    end
+
+    def validate
+      if !@skip_validation && @table.to_s.empty?
+        raise InvalidQuery.new("You must set the table")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/delete_query.rb

@@ -0,0 +1,25 @@
+module Virsandra
+  class DeleteQuery < Query
+
+    def from(table)
+      @from = TableQuery.new("FROM" ,table)
+      self
+    end
+    alias_method :table, :from
+
+    def where(clause)
+      unless @where
+        @where = WhereQuery.new(clause)
+      else
+        @where += WhereQuery.new(clause)
+      end
+      self
+    end
+
+    private
+
+    def raw_query
+      ["DELETE", @from.to_s, @where.to_s]
+    end
+  end
+end

data/lib/virsandra/queries/insert_query.rb

@@ -0,0 +1,34 @@
+module Virsandra
+  class InsertQuery < Query
+
+    def into(table_name)
+      @into = TableQuery.new("INTO", table_name)
+      self
+    end
+
+    def values(values)
+      @values = ValuesQuery.new(values)
+      self
+    end
+
+    def to_s
+      validate
+      super
+    end
+
+    private
+
+    def raw_query
+      ["INSERT", @into, @values]
+    end
+
+    def validate
+      if @into.to_s.empty?
+        raise InvalidQuery.new("You must set into")
+      end
+      if @values.to_s.empty?
+        raise InvalidQuery.new("You must set values")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/limit_query.rb

@@ -0,0 +1,17 @@
+module Virsandra
+  class LimitQuery < Query
+    def initialize(number)
+      @number = number
+    end
+
+    private
+
+    def raw_query
+      if @number.to_i > 0
+        ["LIMIT", @number]
+      else
+        raise InvalidQuery.new("Limit must be positive number")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/order_query.rb

@@ -0,0 +1,36 @@
+module Virsandra
+  class OrderQuery < Query
+    VALID_ORDERS = ["ASC", "DESC"]
+
+    def initialize(columns)
+      @columns = columns
+    end
+
+    private
+
+    def raw_query
+      [@columns.nil? ? "" : "ORDER BY" ,columns_as_string]
+    end
+
+    def columns_as_string
+      if @columns.respond_to?(:each_pair)
+        result = []
+        @columns.each_pair do |column_name, order|
+          result << column_as_string(column_name, order)
+        end
+        result.join(", ")
+      else
+        @columns.to_s
+      end
+    end
+
+    def column_as_string(column_name, order)
+      normalized_order = order.to_s.upcase
+      if VALID_ORDERS.include?(normalized_order)
+        "#{column_name} #{normalized_order}"
+      else
+        raise InvalidQuery.new("Unknown order #{order}")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/select_query.rb

@@ -0,0 +1,72 @@
+module Virsandra
+  class SelectQuery < Query
+    def initialize(columns = nil, skip_validation = false)
+      @columns = columns
+      @skip_validation = skip_validation
+    end
+
+    def from(table)
+      @from = TableQuery.new("FROM", table)
+      self
+    end
+
+    def where(clause)
+      unless @where
+        @where = WhereQuery.new(clause)
+      else
+        @where += WhereQuery.new(clause)
+      end
+      self
+    end
+
+    def order(columns)
+      @order = OrderQuery.new(columns)
+      self
+    end
+
+    def limit(number)
+      @limit = LimitQuery.new(number)
+      self
+    end
+
+    def allow_filtering!
+      @allow_filtering = "ALLOW FILTERING"
+      self
+    end
+
+    def deny_filtering!
+      @allow_filtering = nil
+      self
+    end
+
+    def reset
+      @where, @order, @limit = nil
+    end
+
+    def to_s
+      validate
+      super
+    end
+
+    private
+
+    def raw_query
+      ["SELECT", columns_as_string, @from, @where, @order, @limit, @allow_filtering]
+    end
+
+    def columns_as_string
+      converted_columns = if @columns.respond_to?(:join)
+        @columns.join(", ")
+      else
+        @columns.to_s
+      end
+      converted_columns.empty? ? "*" : converted_columns
+    end
+
+    def validate
+      if !@skip_validation && @from.to_s.empty?
+        raise InvalidQuery.new("You must set from")
+      end
+    end
+  end
+end

data/lib/virsandra/queries/table_query.rb

@@ -0,0 +1,13 @@
+module Virsandra
+  class TableQuery < Query
+    def initialize(keyword, table_name)
+      @table_name, @keyword = table_name, keyword
+    end
+
+    private
+
+    def raw_query
+      [@table_name.to_s.empty? ? "" : @keyword, @table_name]
+    end
+  end
+end

data/lib/virsandra/queries/values_query.rb

@@ -0,0 +1,41 @@
+module Virsandra
+  class ValuesQuery < Query
+    def initialize(values)
+      @values = values
+    end
+
+    private
+
+    def raw_query
+      [values_to_string]
+    end
+
+    def values_to_string
+      if @values.respond_to?(:each_pair)
+        if values_str = values_as_string and !values_str.empty?
+          "(#{columns_as_string}) VALUES (#{values_str})"
+        else
+          ""
+        end
+      else
+        ""
+      end
+    end
+
+    def columns_as_string
+      columns = []
+      @values.each_pair do |key, value|
+        columns << key unless value.nil?
+      end
+      columns.join(", ")
+    end
+
+    def values_as_string
+      values = []
+      @values.each_pair do |key, value|
+        values << CQLValue.convert(value) unless value.nil?
+      end
+      values.join(", ")
+    end
+  end
+end

data/lib/virsandra/queries/where_query.rb

@@ -0,0 +1,69 @@
+module Virsandra
+  class WhereQuery < Query
+    OPERATOR_MAPPING = {
+      :lt => "<",
+      :gt => ">",
+      :eq => "=",
+      :lt_or_eq => "<=",
+      :gt_or_eq => ">=",
+      :in => "IN"
+    }
+
+    def initialize(clause)
+      @clause = clause
+    end
+
+    def +(where_query)
+      if where_query.is_a?(self.class)
+        @clause = [to_s, where_query.to_s.gsub(/^WHERE\s+/, "")].join(" AND ")
+      else
+        raise InvalidQuery.new("WhereQuery can be mereged only with other WhereQuery")
+      end
+    end
+    alias_method :merge, :+
+
+    private
+
+    def raw_query
+      ["WHERE", clause_as_string]
+    end
+
+    def clause_as_string
+      if @clause.respond_to?(:each_pair)
+        result = []
+        @clause.each_pair do |field_name, value|
+          result << "#{field_name} #{operator_for(value)} #{convert_value(value)}"
+        end
+        result.join(" AND ")
+      else
+        @clause.to_s
+      end
+    end
+
+    def operator_for(value)
+      if value.respond_to?(:keys)
+        OPERATOR_MAPPING[value.keys.first.to_sym]
+      elsif value.respond_to?(:to_a)
+        OPERATOR_MAPPING[:in]
+      else
+        OPERATOR_MAPPING[:eq]
+      end
+    end
+
+    def convert_value(value)
+      if value.respond_to?(:values)
+        attribute_value = value.values.first
+        if value.keys.first == :in
+          convert_value(Array(attribute_value))
+        else
+          convert_value(attribute_value)
+        end
+      elsif value.respond_to?(:to_a)
+        converted_values = value.to_a.map{|value| CQLValue.convert(value)}
+        "(#{converted_values.join(", ")})"
+      else
+        CQLValue.convert(value)
+      end
+    end
+  end
+end

data/lib/virsandra/query.rb

@@ -0,0 +1,87 @@
+module Virsandra
+  class InvalidQuery < Exception; end
+
+  class Query
+
+    attr_reader :row
+    attr_accessor :table, :statement
+
+    class << self
+
+      def select(*fields)
+        SelectQuery.new(fields)
+      end
+
+      def insert
+        InsertQuery.new
+      end
+
+      def delete
+        DeleteQuery.new
+      end
+
+      def alter
+        AlterQuery.new
+      end
+    end
+
+    def to_s
+      raw_query.map{|query_part| query_part.to_s }.reject(&:empty?).join(" ")
+    end
+
+    def from *args
+      raise InvalidQuery.new("From, table or into clause not defined for #{self.class}")
+    end
+    alias_method :table, :from
+    alias_method :into, :from
+
+    def where *args
+      raise InvalidQuery.new("Where clause not defined for #{self.class}")
+    end
+
+    def order *args
+      raise InvalidQuery.new("Order clause not defined for #{self.class}")
+    end
+
+    def limit *args
+      raise InvalidQuery.new("Limit clause not defined for #{self.class}")
+    end
+
+    def add *args
+      raise InvalidQuery.new("Add clause not defined for #{self.class}")
+    end
+
+    def values *args
+      raise InvalidQuery.new("Values clause not defined for #{self.class}")
+    end
+
+    def execute
+
+      @row = Virsandra.execute(self.to_s)
+    end
+
+    def fetch(statement = nil)
+      @raw_query = statement if statement
+      execute
+      fetch_with_symbolized_keys
+    end
+
+    private
+
+    def raw_query
+      [@raw_query]
+    end
+
+    def fetch_with_symbolized_keys
+      row_hash = @row && @row.first
+      return {} unless row_hash
+
+      Hash[row_hash.map{|(k,v)| [k.to_sym,v]}]
+    end
+  end
+
+end
+
+Dir[File.expand_path('../queries/*_query.rb', __FILE__)].each do |path|
+  require path
+end