cassanity 0.1.0

data/lib/cassanity/error.rb

@@ -0,0 +1,28 @@
+module Cassanity
+  class Error < Exception
+    # Public: The original error this exception is wrapping.
+    attr_reader :original
+
+    # Public: Initializes an Error.
+    #
+    # args - The Hash of arguments.
+    #        :original - The Exception being wrapped (optional).
+    #
+    # Returns the duplicated String.
+    def initialize(args = {})
+      @original = args.fetch(:original) { $! }
+      @message = args.fetch(:message) {
+        if @original
+          "Original Exception: #{@original.class}: #{@original.message}"
+        else
+          "Something truly horrible went wrong"
+        end
+      }
+
+      super @message
+    end
+  end
+
+  class UnknownCommand < Error
+  end
+end

data/lib/cassanity/executors/cassandra_cql.rb

@@ -0,0 +1,120 @@
+require 'cassandra-cql'
+require 'cassanity/error'
+require 'cassanity/argument_generators/keyspaces'
+require 'cassanity/argument_generators/keyspace_create'
+require 'cassanity/argument_generators/keyspace_drop'
+require 'cassanity/argument_generators/keyspace_use'
+require 'cassanity/argument_generators/column_family_create'
+require 'cassanity/argument_generators/column_family_drop'
+require 'cassanity/argument_generators/column_family_truncate'
+require 'cassanity/argument_generators/column_family_select'
+require 'cassanity/argument_generators/column_family_insert'
+require 'cassanity/argument_generators/column_family_update'
+require 'cassanity/argument_generators/column_family_delete'
+require 'cassanity/argument_generators/column_family_alter'
+require 'cassanity/argument_generators/index_create'
+require 'cassanity/argument_generators/index_drop'
+require 'cassanity/argument_generators/batch'
+require 'cassanity/result_transformers/column_family_select'
+require 'cassanity/result_transformers/mirror'
+
+module Cassanity
+  module Executors
+    class CassandraCql
+
+      # Private: Hash of commands to related argument generators.
+      ArgumentGenerators = {
+        keyspaces: Cassanity::ArgumentGenerators::Keyspaces.new,
+        keyspace_create: Cassanity::ArgumentGenerators::KeyspaceCreate.new,
+        keyspace_drop: Cassanity::ArgumentGenerators::KeyspaceDrop.new,
+        keyspace_use: Cassanity::ArgumentGenerators::KeyspaceUse.new,
+        column_family_create: Cassanity::ArgumentGenerators::ColumnFamilyCreate.new,
+        column_family_drop: Cassanity::ArgumentGenerators::ColumnFamilyDrop.new,
+        column_family_truncate: Cassanity::ArgumentGenerators::ColumnFamilyTruncate.new,
+        column_family_select: Cassanity::ArgumentGenerators::ColumnFamilySelect.new,
+        column_family_insert: Cassanity::ArgumentGenerators::ColumnFamilyInsert.new,
+        column_family_update: Cassanity::ArgumentGenerators::ColumnFamilyUpdate.new,
+        column_family_delete: Cassanity::ArgumentGenerators::ColumnFamilyDelete.new,
+        column_family_alter: Cassanity::ArgumentGenerators::ColumnFamilyAlter.new,
+        index_create: Cassanity::ArgumentGenerators::IndexCreate.new,
+        index_drop: Cassanity::ArgumentGenerators::IndexDrop.new,
+        batch: Cassanity::ArgumentGenerators::Batch.new,
+      }
+
+      # Private: Hash of commands to related result transformers.
+      ResultTransformers = {
+        column_family_select: Cassanity::ResultTransformers::ColumnFamilySelect.new,
+      }
+
+      # Private: Default result transformer for commands that do not have one.
+      Mirror = Cassanity::ResultTransformers::Mirror.new
+
+      # Private
+      attr_reader :client
+
+      # Private
+      attr_reader :argument_generators
+
+      # Private
+      attr_reader :result_transformers
+
+      # Internal: Initializes a cassandra-cql based CQL executor.
+      #
+      # args - The Hash of arguments.
+      #        :client - The CassandraCQL::Database connection instance.
+      #        :argument_generators - A Hash where each key is a command name
+      #                               and each value is the related argument
+      #                               generator that responds to `call`
+      #                               (optional).
+      #        :result_transformers - A Hash where each key is a command name
+      #                               and each value is the related result
+      #                               transformer that responds to `call`
+      #                               (optional).
+      #
+      # Examples
+      #
+      #   client = CassandraCQL::Database.new('host')
+      #   Cassanity::Executors::CassandraCql.new(client: client)
+      #
+      def initialize(args = {})
+        @client = args.fetch(:client)
+        @argument_generators = args.fetch(:argument_generators) { ArgumentGenerators }
+        @result_transformers = args.fetch(:result_transformers) { ResultTransformers }
+      end
+
+      # Internal: Execute a CQL query.
+      #
+      # args - One or more arguments to send to execute. First should always be
+      #        String CQL query. The rest should be the bound variables if any
+      #        are needed.
+      #
+      # Examples
+      #
+      #   call({
+      #     command: :keyspaces,
+      #   })
+      #
+      #   call({
+      #     command: :keyspace_create,
+      #     arguments: {name: 'analytics'},
+      #   })
+      #
+      # Returns the result of execution.
+      # Raises Cassanity::Error if anything goes wrong during execution.
+      def call(args = {})
+        command = args.fetch(:command)
+        generator = @argument_generators.fetch(command)
+        execute_arguments = generator.call(args[:arguments])
+
+        result = @client.execute(*execute_arguments)
+
+        transformer = @result_transformers.fetch(command) { Mirror }
+        transformer.call(result)
+      rescue KeyError
+        raise Cassanity::UnknownCommand
+      rescue Exception => e
+        raise Cassanity::Error
+      end
+    end
+  end
+end

data/lib/cassanity/keyspace.rb

@@ -0,0 +1,118 @@
+require 'cassanity/column_family'
+
+module Cassanity
+  class Keyspace
+    # Public
+    attr_reader :name
+
+    # Internal
+    attr_reader :executor
+
+    # Internal
+    attr_reader :strategy_class
+
+    # Internal
+    attr_reader :strategy_options
+
+    # Public: Initializes a Keyspace.
+    #
+    # args - The Hash of arguments (default: {}).
+    #        :name - The String name of the keyspace.
+    #        :executor - What will execute the queries. Must respond to `call`.
+    #        :strategy_class - The String strategy class name to use when
+    #                          creating keyspace.
+    #        :strategy_options - The Hash of strategy options to use when
+    #                            creating keyspace.
+    #
+    def initialize(args = {})
+      @name = args.fetch(:name)
+      @executor = args.fetch(:executor)
+      @strategy_class = args[:strategy_class]
+      @strategy_options = args[:strategy_options]
+    end
+
+    # Public: Creates the keyspace
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name is always included.
+    #
+    # Examples
+    #
+    #   create # uses options from initialization
+    #
+    #   # override options from initialization
+    #   create({
+    #     strategy_class: 'NetworkTopologyStrategy',
+    #     strategy_options: {
+    #       dc1: 1,
+    #       dc2: 3,
+    #     }
+    #   })
+    #
+    # Returns whatever is returned by executor.
+    def create(args = {})
+      @executor.call({
+        command: :keyspace_create,
+        arguments: args.merge({
+          name: @name,
+        })
+      })
+    end
+
+    # Public: Uses a keyspace
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name is always included.
+    #
+    # Examples
+    #
+    #   use # you shouldn't really ever need more than this
+    #
+    # Returns whatever is returned by executor.
+    def use(args = {})
+      @executor.call({
+        command: :keyspace_use,
+        arguments: args.merge({
+          name: @name,
+        }),
+      })
+    end
+
+    # Public: Drops a keyspace
+    #
+    # args - The Hash of arguments to pass to the argument generator
+    #        (default: {}). :name is always included.
+    #
+    # Examples
+    #
+    #   drop # you shouldn't really ever need more than this
+    #
+    # Returns whatever is returned by executor.
+    def drop(args = {})
+      @executor.call({
+        command: :keyspace_drop,
+        arguments: args.merge({
+          name: @name,
+        }),
+      })
+    end
+
+    # Public: Get a column family instance
+    #
+    # name - The String name of the column family.
+    # args - The Hash of arguments to use for ColumnFamily initialization
+    #        (optional, default: {}). :name and :keyspace are always included.
+    #
+    # Returns a Cassanity::ColumnFamily instance.
+    def column_family(name, args = {})
+      column_family_args = args.merge({
+        name: name,
+        keyspace: self,
+      })
+
+      ColumnFamily.new(column_family_args)
+    end
+    alias_method :table, :column_family
+    alias_method :[], :column_family
+  end
+end

data/lib/cassanity/result_transformers/column_family_select.rb

@@ -0,0 +1,15 @@
+module Cassanity
+  module ResultTransformers
+    class ColumnFamilySelect
+
+      # Internal: Turns result into Array of Hashes.
+      def call(result)
+        rows = []
+        result.fetch_hash do |row|
+          rows << row
+        end
+        rows
+      end
+    end
+  end
+end

data/lib/cassanity/result_transformers/mirror.rb

@@ -0,0 +1,12 @@
+module Cassanity
+  module ResultTransformers
+    class Mirror
+
+      # Internal: Returns whatever result is passed to it. This is used as the
+      # default result transformer when a command does not have one.
+      def call(result)
+        result
+      end
+    end
+  end
+end

data/lib/cassanity/schema.rb

@@ -0,0 +1,26 @@
+module Cassanity
+  class Schema
+    # Internal
+    attr_reader :primary_key
+
+    # Internal
+    attr_reader :columns
+
+    # Internal
+    attr_reader :with
+
+    # Public: Initializes a Schema.
+    #
+    # args - The Hash of arguments.
+    #        :primary_key - The String or Symbol key or Array of String/Symbol
+    #                       keys to use as primary key.
+    #        :columns - The Hash of columns where the name is the column name
+    #                   and the value is the column type.
+    #        :with - The Hash of options for the WITH clause.
+    def initialize(args = {})
+      @primary_key = args.fetch(:primary_key)
+      @columns = args.fetch(:columns)
+      @with = args[:with] || {}
+    end
+  end
+end

data/lib/cassanity/version.rb

@@ -0,0 +1,3 @@
+module Cassanity
+  VERSION = "0.1.0"
+end

data/lib/cassanity.rb

@@ -0,0 +1,5 @@
+module Cassanity
+end
+
+require 'cassanity/connection'
+require 'cassanity/executors/cassandra_cql'

data/spec/helper.rb

@@ -0,0 +1,27 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default
+
+require 'cassanity'
+
+root = Pathname(__FILE__).dirname.join('..').expand_path
+
+Dir[root.join("spec/support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = :random
+
+  config.filter_run :focused => true
+  config.alias_example_to :fit, :focused => true
+  config.alias_example_to :xit, :pending => true
+  config.run_all_when_everything_filtered = true
+
+  config.backtrace_clean_patterns = [
+    /lib\/rspec\/(core|expectations|matchers|mocks)/,
+  ]
+
+  config.include CassanityHelpers
+end

data/spec/integration/cassanity/column_family_spec.rb

@@ -0,0 +1,243 @@
+require 'helper'
+require 'cassanity/keyspace'
+require 'cassanity/executors/cassandra_cql'
+
+describe Cassanity::ColumnFamily do
+  let(:keyspace_name)               { 'cassanity_test' }
+  let(:column_family_name)          { 'apps' }
+  let(:counters_column_family_name) { 'counters' }
+
+  let(:client) {
+    CassandraCQL::Database.new('127.0.0.1:9160', {
+      cql_version: '3.0.0',
+    })
+  }
+
+  let(:keyspace) {
+    Cassanity::Keyspace.new({
+      name: keyspace_name,
+      executor: executor,
+    })
+  }
+
+  let(:executor) {
+    Cassanity::Executors::CassandraCql.new({
+      client: client,
+    })
+  }
+
+  let(:schema) {
+    Cassanity::Schema.new({
+      primary_key: :id,
+      columns: {
+        id: :timeuuid,
+        name: :text,
+      },
+      with: {
+        comment: 'For storing things',
+      }
+    })
+  }
+
+  let(:arguments) {
+    {
+      keyspace: keyspace,
+      name: column_family_name,
+      schema: schema,
+    }
+  }
+
+  subject {
+    described_class.new(arguments)
+  }
+
+  before do
+    client_drop_keyspace(client, keyspace_name)
+    client_create_keyspace(client, keyspace_name)
+    client_create_column_family(client, column_family_name, "id text PRIMARY KEY, name text")
+    client_create_column_family(client, counters_column_family_name, "id text PRIMARY KEY, views counter")
+  end
+
+  after do
+    client_drop_keyspace(client, keyspace_name)
+  end
+
+  it "can create itself" do
+    column_family = described_class.new(arguments.merge(name: 'people'))
+    column_family.create
+
+    apps_column_family = client.schema.column_families.fetch(column_family.name)
+    apps_column_family.comment.should eq('For storing things')
+
+    columns = apps_column_family.columns
+    columns.should have_key('id')
+    columns.should have_key('name')
+    columns['id'].should eq('org.apache.cassandra.db.marshal.TimeUUIDType')
+    columns['name'].should eq('org.apache.cassandra.db.marshal.UTF8Type')
+  end
+
+  it "can truncate" do
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '1', 'github')
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '2', 'gist')
+    result = client.execute("SELECT * FROM #{column_family_name}")
+    result.rows.should eq(2)
+
+    subject.truncate
+
+    result = client.execute("SELECT * FROM #{column_family_name}")
+    result.rows.should eq(0)
+  end
+
+  it "can drop" do
+    client_column_family?(client, column_family_name).should be_true
+    subject.drop
+    client_column_family?(client, column_family_name).should be_false
+  end
+
+  it "can drop when using a different keyspace" do
+    client_column_family?(client, column_family_name).should be_true
+    client.execute('USE system')
+    subject.drop
+    client_column_family?(client, column_family_name).should be_false
+  end
+
+  it "can alter" do
+    subject.alter(add: {created_at: :timestamp})
+
+    apps_column_family = client.schema.column_families.fetch(column_family_name)
+    columns = apps_column_family.columns
+    columns.should have_key('created_at')
+    columns['created_at'].should eq('org.apache.cassandra.db.marshal.DateType')
+
+    subject.alter(alter: {created_at: :timeuuid})
+
+    apps_column_family = client.schema.column_families.fetch(column_family_name)
+    columns = apps_column_family.columns
+    columns.should have_key('created_at')
+    columns['created_at'].should eq('org.apache.cassandra.db.marshal.TimeUUIDType')
+
+    subject.alter(drop: :created_at)
+
+    apps_column_family = client.schema.column_families.fetch(column_family_name)
+    columns = apps_column_family.columns
+    columns.should_not have_key('created_at')
+
+    subject.alter(with: {comment: 'Some new comment'})
+    apps_column_family = client.schema.column_families.fetch(column_family_name)
+    apps_column_family.comment.should eq('Some new comment')
+  end
+
+  it "can create and drop indexes" do
+    subject.create_index({
+      name: :apps_name_index,
+      column_name: :name,
+    })
+
+    apps = client.schema.column_families['apps']
+    apps_meta = apps.column_metadata
+    index = apps_meta.detect { |c| c.index_name == 'apps_name_index' }
+    index.should_not be_nil
+
+    subject.drop_index({
+      name: :apps_name_index,
+    })
+
+    apps = client.schema.column_families['apps']
+    apps_meta = apps.column_metadata
+    index = apps_meta.detect { |c| c.index_name == 'apps_name_index' }
+    index.should be_nil
+  end
+
+  it "can select data" do
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '1', 'github')
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '2', 'gist')
+    result = subject.select({
+      select: :name,
+      where: {
+        id: '2',
+      },
+    })
+    result.should eq([
+      {'name' => 'gist'}
+    ])
+  end
+
+  it "can insert data" do
+    subject.insert({
+      data: {
+        id: '1',
+        name: 'GitHub',
+      },
+    })
+
+    result = client.execute("SELECT * FROM #{column_family_name}")
+    result.rows.should eq(1)
+    row = result.fetch_hash
+    row['id'].should eq('1')
+    row['name'].should eq('GitHub')
+  end
+
+  it "can update data" do
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '1', 'github')
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '2', 'gist')
+
+    subject.update({
+      set: {name: 'New Name'},
+      where: {id: '1'},
+    })
+
+    result = client.execute("SELECT * FROM #{column_family_name} WHERE id = '1'")
+    result.rows.should eq(1)
+    row = result.fetch_hash
+    row['id'].should eq('1')
+    row['name'].should eq('New Name')
+
+    # does not update other rows
+    result = client.execute("SELECT * FROM #{column_family_name} WHERE id = '2'")
+    result.rows.should eq(1)
+    row = result.fetch_hash
+    row['id'].should eq('2')
+    row['name'].should eq('gist')
+  end
+
+  describe "updating a counter column" do
+    subject {
+      described_class.new({
+        keyspace: keyspace,
+        name: counters_column_family_name,
+      })
+    }
+
+    it "works" do
+      subject.update({
+        set: {views: 'views + 2'},
+        where: {id: '1'},
+      })
+
+      result = client.execute("SELECT * FROM #{counters_column_family_name} WHERE id = '1'")
+      result.rows.should eq(1)
+      row = result.fetch_hash
+      row['id'].should eq('1')
+      row['views'].should be(2)
+    end
+  end
+
+  it "can delete data" do
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '1', 'github')
+    client.execute("INSERT INTO #{column_family_name} (id, name) VALUES (?, ?)", '2', 'gist')
+
+    result = client.execute("SELECT * FROM #{column_family_name}")
+    result.rows.should eq(2)
+
+    subject.delete({
+      where: {id: '1'},
+    })
+
+    result = client.execute("SELECT * FROM #{column_family_name} WHERE id = '1'")
+    result.rows.should eq(0)
+
+    # does not delete other rows
+    result = client.execute("SELECT * FROM #{column_family_name} WHERE id = '2'")
+    result.rows.should eq(1)
+  end
+end

data/spec/integration/cassanity/connection_spec.rb

@@ -0,0 +1,87 @@
+require 'helper'
+require 'cassanity/connection'
+require 'cassanity/executors/cassandra_cql'
+
+describe Cassanity::Connection do
+  let(:keyspace_name)      { 'cassanity_test' }
+  let(:column_family_name) { 'apps' }
+
+  let(:client) {
+    CassandraCQL::Database.new('127.0.0.1:9160', {
+      cql_version: '3.0.0',
+    })
+  }
+
+  let(:executor) {
+    Cassanity::Executors::CassandraCql.new({
+      client: client,
+    })
+  }
+
+  subject {
+    described_class.new({
+      executor: executor,
+    })
+  }
+
+  before do
+    client_drop_keyspace(client, keyspace_name)
+  end
+
+  after do
+    client_drop_keyspace(client, keyspace_name)
+  end
+
+  it "can batch" do
+    client_create_keyspace(client, keyspace_name)
+    client_create_column_family(client, column_family_name, "id text PRIMARY KEY, name text")
+
+    default_arguments = {
+      keyspace_name: keyspace_name,
+      name: column_family_name,
+    }
+
+    subject.batch({
+      :modifications => [
+        [:insert, default_arguments.merge(data: {id: '1', name: 'github'})],
+        [:insert, default_arguments.merge(data: {id: '2', name: 'gist'})],
+        [:update, default_arguments.merge(set: {name: 'github.com'}, where: {id: '1'})],
+        [:delete, default_arguments.merge(where: {id: '2'})],
+      ]
+    })
+
+    result = client.execute("SELECT * FROM apps")
+    result.rows.should be(1)
+
+    rows = []
+    result.fetch_hash { |row| rows << row }
+
+    rows.should eq([
+      {'id' => '1', 'name' => 'github.com'},
+    ])
+  end
+
+  it "knows keyspaces" do
+    client_create_keyspace(client, 'something1')
+    client_create_keyspace(client, 'something2')
+
+    result = subject.keyspaces
+    result.each do |keyspace|
+      keyspace.should be_instance_of(Cassanity::Keyspace)
+      keyspace.executor.should eq(subject.executor)
+    end
+
+    names = result.map(&:name)
+    names.should include('something1')
+    names.should include('something2')
+
+    client_drop_keyspace(client, 'something1')
+    client_drop_keyspace(client, 'something2')
+  end
+
+  it "knows if a keyspace exists" do
+    subject.keyspace?(keyspace_name).should be_false
+    client_create_keyspace(client, keyspace_name)
+    subject.keyspace?(keyspace_name).should be_true
+  end
+end