cassanity 0.1.0

data/lib/cassanity/argument_generators/column_family_select.rb

@@ -0,0 +1,34 @@
+require 'cassanity/argument_generators/where_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilySelect
+
+      # Internal
+      def initialize(args = {})
+        @where_clause = args.fetch(:where_clause) { WhereClause.new }
+      end
+
+      # Internal
+      def call(args = {})
+        select = Array(args.fetch(:select, '*'))
+        name   = args.fetch(:name)
+        where  = args[:where]
+
+        variables = []
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        cql = "SELECT #{select.join(', ')} FROM #{name}"
+
+        where_cql, *where_variables = @where_clause.call(where: where)
+        cql << where_cql
+        variables.concat(where_variables)
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/column_family_truncate.rb

@@ -0,0 +1,18 @@
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyTruncate
+
+      # Internal
+      def call(args = {})
+        name = args.fetch(:name)
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        cql = "TRUNCATE #{name}"
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/column_family_update.rb

@@ -0,0 +1,69 @@
+require 'cassanity/argument_generators/where_clause'
+require 'cassanity/argument_generators/set_clause'
+require 'cassanity/argument_generators/using_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyUpdate
+
+      # Internal
+      def initialize(args = {})
+        @using_clause = args.fetch(:using_clause) { UsingClause.new }
+        @set_clause   = args.fetch(:set_clause)   { SetClause.new }
+        @where_clause = args.fetch(:where_clause) { WhereClause.new }
+      end
+
+      # Internal: Converts a Hash of arguments to CQL with bound variables.
+      #
+      # args - The Hash of arguments to use.
+      #        :name - The String name of the column family
+      #        :set - The Hash of data to actually update
+      #        :where - The Hash of options to use to filter the update
+      #        :using - The Hash of options for the query ie: consistency, ttl,
+      #                 and timestamp (optional).
+      #
+      # Examples
+      #
+      #   call({
+      #     name: 'apps',
+      #     set: {
+      #       name: 'GitHub',
+      #     },
+      #     where: {
+      #       :id => '1',
+      #     }
+      #   })
+      #
+      # Returns Array where first element is CQL string and the rest are
+      #   bound values.
+      def call(args = {})
+        name  = args.fetch(:name)
+        set   = args.fetch(:set)
+        where = args.fetch(:where)
+        using = args[:using] || {}
+
+        variables = []
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        cql = "UPDATE #{name}"
+
+        using_cql, *using_variables = @using_clause.call(using: using)
+        cql << using_cql
+        variables.concat(using_variables)
+
+        set_cql, *set_variables = @set_clause.call(set: set)
+        cql << set_cql
+        variables.concat(set_variables)
+
+        where_cql, *where_variables = @where_clause.call(where: where)
+        cql << where_cql
+        variables.concat(where_variables)
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/index_create.rb

@@ -0,0 +1,22 @@
+module Cassanity
+  module ArgumentGenerators
+    class IndexCreate
+
+      # Internal
+      def call(args = {})
+        name = args[:name]
+        column_name = args.fetch(:column_name)
+        column_family_name = args.fetch(:column_family_name)
+
+        if (keyspace_name = args[:keyspace_name])
+          column_family_name = "#{keyspace_name}.#{column_family_name}"
+        end
+
+        cql = "CREATE INDEX"
+        cql << " #{name}" unless name.nil?
+        cql << " ON #{column_family_name} (#{column_name})"
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/index_drop.rb

@@ -0,0 +1,13 @@
+module Cassanity
+  module ArgumentGenerators
+    class IndexDrop
+
+      # Internal
+      def call(args = {})
+        name = args.fetch(:name)
+        cql = "DROP INDEX #{name}"
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/keyspace_create.rb

@@ -0,0 +1,51 @@
+module Cassanity
+  module ArgumentGenerators
+    class KeyspaceCreate
+
+      # Internal
+      def call(args = {})
+        options, variables = [], []
+        name = args.fetch(:name)
+        cql = "CREATE KEYSPACE %s WITH " % name.to_s
+
+        with = {
+          strategy_class: default_strategy_class,
+          strategy_options: default_strategy_options,
+        }
+
+        if args[:strategy_class]
+          with[:strategy_class] = args[:strategy_class]
+        end
+
+        cql << "strategy_class = ? AND "
+        variables << with[:strategy_class]
+
+        if args[:strategy_options]
+          args[:strategy_options].each do |key, value|
+            with[:strategy_options][key] = value
+          end
+        end
+
+        with[:strategy_options].each do |key, value|
+          options << "strategy_options:#{key} = ?"
+          variables << value
+        end
+        cql << options.join(' AND ')
+
+        [cql, *variables]
+      end
+
+      # Private
+      def default_strategy_class
+        'SimpleStrategy'
+      end
+
+      # Private
+      def default_strategy_options
+        {
+          replication_factor: 1,
+        }
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/keyspace_drop.rb

@@ -0,0 +1,13 @@
+module Cassanity
+  module ArgumentGenerators
+    class KeyspaceDrop
+
+      # Internal
+      def call(args = {})
+        name = args.fetch(:name)
+        cql = "DROP KEYSPACE %s" % name
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/keyspace_use.rb

@@ -0,0 +1,13 @@
+module Cassanity
+  module ArgumentGenerators
+    class KeyspaceUse
+
+      # Internal
+      def call(args = {})
+        name = args.fetch(:name)
+        cql = "USE #{name}"
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/keyspaces.rb

@@ -0,0 +1,12 @@
+module Cassanity
+  module ArgumentGenerators
+    class Keyspaces
+
+      # Internal
+      def call(args = {})
+        cql = "SELECT * FROM system.schema_keyspaces"
+        [cql]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/set_clause.rb

@@ -0,0 +1,30 @@
+module Cassanity
+  module ArgumentGenerators
+    class SetClause
+
+      # Internal
+      def call(args = {})
+        set = args.fetch(:set)
+        cql, variables, sets = '', [], []
+
+        set.each do |key, value|
+          if counter?(key, value)
+            sets << "#{key} = #{value}"
+          else
+            sets << "#{key} = ?"
+            variables << value
+          end
+        end
+        cql << " SET #{sets.join(', ')}"
+
+
+        [cql, *variables]
+      end
+
+      # Private
+      def counter?(key, value)
+        value.is_a?(String) && value.match(/#{key}(\s+)?[\+\-](\s+)?\d/)
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/using_clause.rb

@@ -0,0 +1,24 @@
+module Cassanity
+  module ArgumentGenerators
+    class UsingClause
+
+      # Internal
+      def call(args = {})
+        using = args[:using]
+        cql = ''
+
+        return [cql] if using.nil? || using.empty?
+
+        variables, usings = [], []
+
+        using.each do |key, value|
+          usings << "#{key.upcase} #{value}"
+        end
+
+        cql << " USING #{usings.join(' AND ')}"
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/where_clause.rb

@@ -0,0 +1,29 @@
+module Cassanity
+  module ArgumentGenerators
+    class WhereClause
+
+      # Internal
+      def call(args = {})
+        where = args[:where]
+        cql = ''
+        return [cql] if where.nil? || where.empty?
+
+        variables, wheres = [], []
+
+        where.each do |key, value|
+          if value.is_a?(Array)
+            wheres << "#{key} IN (?)"
+            variables << value
+          else
+            wheres << "#{key} = ?"
+            variables << value
+          end
+        end
+
+        cql << " WHERE #{wheres.join(' AND ')}"
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/with_clause.rb

@@ -0,0 +1,32 @@
+module Cassanity
+  module ArgumentGenerators
+    class WithClause
+
+      # Internal
+      def call(args = {})
+        with = args[:with]
+        cql = ''
+
+        return [cql] if with.nil? || with.empty?
+
+        variables, withs = [], []
+
+        with.each do |key, value|
+          if value.is_a?(Hash)
+            value.each do |sub_key, sub_value|
+              withs << "#{key}:#{sub_key} = ?"
+              variables << sub_value
+            end
+          else
+            withs << "#{key} = ?"
+            variables << value
+          end
+        end
+
+        cql << " WITH #{withs.join(' AND ')}"
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/column_family.rb

@@ -0,0 +1,233 @@
+require 'cassanity/schema'
+
+module Cassanity
+  class ColumnFamily
+    # Public
+    attr_reader :name
+
+    # Public
+    attr_reader :keyspace
+
+    # Private
+    attr_reader :executor
+
+    # Private
+    attr_reader :schema
+
+    # Public: Initializes a ColumnFamily.
+    #
+    # args - The Hash of arguments (default: {}).
+    #        :name - The String name of the column family.
+    #        :keyspace - The Cassanity::Keyspace the column family is in.
+    #        :executor - What will execute the queries (optional).
+    #                    Must respond to `call`.
+    #        :schema - The schema used to create the column family (optional).
+    #
+    def initialize(args = {})
+      @name = args.fetch(:name)
+      @keyspace = args.fetch(:keyspace)
+      @executor = args.fetch(:executor) { @keyspace.executor }
+      @schema = args[:schema]
+    end
+
+    # Public: Creates the column family in the keyspace based on the schema.
+    #
+    # args - The Hash of arguments to pass to the executor. Always passes
+    #        :name and :keyspace_name.
+    #        :schema - The Schema to use to create the column family
+    #                  (defaults to schema provided during initialization).
+    #
+    # Examples
+    #
+    #   create # uses schema from initialization
+    #   create(schema: Cassanity::Schema.new(...))
+    #
+    # Returns nothing.
+    # Raises Cassanity::Error if schema not set during initialization and also
+    #   not passed in via arguments.
+    def create(args = {})
+      forced_arguments = {
+        name: @name,
+        keyspace_name: @keyspace.name,
+      }
+      arguments = args.merge(forced_arguments)
+      arguments[:schema] = schema unless arguments[:schema]
+
+      @executor.call({
+        command: :column_family_create,
+        arguments: arguments,
+      })
+    end
+
+    # Public: Truncates the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Examples
+    #
+    #   truncate # you should rarely need more than this
+    #
+    # Returns whatever is returned by executor.
+    def truncate(args = {})
+      @executor.call({
+        command: :column_family_truncate,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Drops the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Examples
+    #
+    #   drop # you should rarely need more than this
+    #
+    # Returns whatever is returned by executor.
+    def drop(args = {})
+      @executor.call({
+        command: :column_family_drop,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Alters the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Examples
+    #
+    #   alter(alter: {created_at: :timestamp})
+    #   alter(add: {description: :text})
+    #   alter(drop: :description)
+    #   alter(with: {read_repair_chance: 0.2})
+    #
+    # Returns whatever is returned by executor.
+    def alter(args = {})
+      @executor.call({
+        command: :column_family_alter,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Creates an index
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :column_family_name and :keyspace_name are
+    #        always included.
+    #
+    # Examples
+    #
+    #   create_index(column_name: 'ability_id')
+    #   create_index(name: 'ability_index', column_name: 'ability_id')
+    #
+    # Returns whatever is returned by executor.
+    def create_index(args = {})
+      @executor.call({
+        command: :index_create,
+        arguments: args.merge({
+          column_family_name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Drops an index
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}).
+    #
+    # Examples
+    #
+    #   drop_index(name: 'my_index_name')
+    #
+    # Returns whatever is returned by executor.
+    def drop_index(args = {})
+      @executor.call({
+        command: :index_drop,
+        arguments: args,
+      })
+    end
+
+    # Public: Makes it possible to query data from the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Returns whatever is returned by executor.
+    def select(args = {})
+      @executor.call({
+        command: :column_family_select,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        })
+      })
+    end
+
+    # Public: Makes it possible to insert data into the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Returns whatever is returned by executor.
+    def insert(args = {})
+      @executor.call({
+        command: :column_family_insert,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Makes it possible to update data in the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Returns whatever is returned by executor.
+    def update(args = {})
+      @executor.call({
+        command: :column_family_update,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Public: Makes it possible to delete data from the column family.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name and :keyspace_name are always included.
+    #
+    # Returns whatever is returned by executor.
+    def delete(args = {})
+      @executor.call({
+        command: :column_family_delete,
+        arguments: args.merge({
+          name: @name,
+          keyspace_name: @keyspace.name,
+        }),
+      })
+    end
+
+    # Internal
+    def schema
+      @schema || raise(Cassanity::Error.new(message: "No schema found to create #{@name} column family. Please set :schema during initialization or include it as a key in #create call."))
+    end
+  end
+end

data/lib/cassanity/connection.rb

@@ -0,0 +1,88 @@
+require 'cassanity/keyspace'
+
+module Cassanity
+  class Connection
+    # Internal
+    attr_reader :executor
+
+    # Public: Initializes a connection
+    #
+    # args - The Hash of arguments (default: {}).
+    #        :executor - What will execute the CQL statements.
+    #                    Must respond to `call`.
+    def initialize(args = {})
+      @executor = args.fetch(:executor)
+    end
+
+    # Public: Group multiple statements into a batch.
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}).
+    #
+    # Examples
+    #
+    #   batch({
+    #     modifications: [
+    #       [:insert, name: 'apps', data: {id: '1', name: 'github'}],
+    #       [:insert, name: 'apps', data: {id: '2', name: 'gist'}],
+    #       [:update, name: 'apps', set: {name: 'github.com'}, where: {id: '1'}],
+    #       [:delete, name: 'apps', where: {id: '2'}],
+    #     ]
+    #   })
+    #
+    # Returns whatever is returned by executor.
+    def batch(args = {})
+      @executor.call({
+        command: :batch,
+        arguments: args,
+      })
+    end
+
+    # Public: Get all keyspaces.
+    #
+    # Returns Array of Cassanity::Keyspace instances.
+    def keyspaces
+      keyspaces = []
+
+      result = @executor.call({
+        command: :keyspaces,
+      })
+
+      result.fetch_hash do |row|
+        keyspaces << row
+      end
+
+      keyspaces.map { |row|
+        Keyspace.new({
+          name: row['name'],
+          executor: @executor,
+        })
+      }
+    end
+
+    # Public: Find out if a keyspace exists or not
+    #
+    # name - The String name of the keyspace
+    #
+    # Returns true if keyspace exists else false.
+    def keyspace?(name)
+      keyspaces.map(&:name).include?(name)
+    end
+
+    # Public: Get a keyspace instance
+    #
+    # name - The String name of the keyspace.
+    #
+    # Returns a Cassanity::Keyspace instance.
+    def keyspace(name, args = {})
+      keyspace_args = args.merge({
+        name: name,
+        executor: @executor,
+      })
+
+      Keyspace.new(keyspace_args)
+    end
+
+    alias_method :[], :keyspace
+  end
+end