cassanity 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin
+vendor/gems

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+gemfile:
+  - Gemfile
+language: ruby
+rvm:
+  - 1.9.3
+notifications:
+  email: false
+bundler_args: --without guard
+services:
+ - cassandra

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'rake'
+gem 'rspec', '~> 2.8'
+
+group(:guard) do
+  gem 'guard',          '~> 1.0.0'
+  gem 'guard-rspec',    '~> 0.6.0'
+  gem 'guard-bundler',  '~> 0.1.0'
+end

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| [
+    "spec/unit/#{m[1]}_spec.rb",
+    "spec/integration/#{m[1]}_spec.rb",
+  ] }
+  watch('spec/helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 John Nunemaker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Cassanity
+
+Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.
+
+Current status: Incomplete and changing fast. **Do not use this yet**, but feel free to follow along.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cassanity'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cassanity
+
+## Usage
+
+```ruby
+require 'cassanity'
+
+# cassandra-cql connection
+client = CassandraCQL::Database.new('127.0.0.1:9160', {
+  cql_version: '3.0.0',
+})
+
+# what is going to execute the cql queries?
+executor = Cassanity::Executors::CassandraCql.new({
+  client: client,
+})
+
+# setup connection with something that can execute queries
+connection = Cassanity::Connection.new({
+  executor: executor,
+})
+
+# get keyspace instance
+keyspace = connection[:my_app]
+
+# tell client to use keyspace for future queries
+keyspace.use
+
+# schema for apps column family
+apps_schema = Cassanity::Schema.new({
+  primary_key: :id,
+  columns: {
+    id: :text,
+    name: :text,
+    created_at: :timestamp,
+  },
+  with: {
+    comment: 'For storing apps',
+  }
+})
+
+# get instance of column family with name and schema set
+apps = keyspace.column_family({
+  name: :apps,
+  schema: apps_schema,
+})
+
+# create column family based on name and schema
+apps.create
+
+# insert row
+apps.insert(data: {
+  id: '1',
+  name: 'GitHub.com',
+  created_at: Time.now,
+})
+
+# update name for row
+apps.update(set: {name: 'GitHub'}, where: {id: '1'})
+
+# delete row
+apps.delete(where: {id: '1'})
+
+# truncate column family (remove all rows, still can add new stuff)
+apps.truncate
+
+# drop column family (no more inserting into it, it is gone)
+apps.drop
+```
+
+## Compatibility
+
+* Ruby 1.9.3
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.pattern = './spec/integration/**/*_spec.rb'
+  end
+
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.pattern = './spec/unit/**/*_spec.rb'
+  end
+end

data/cassanity.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cassanity/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cassanity"
+  gem.version       = Cassanity::VERSION
+  gem.authors       = ["John Nunemaker"]
+  gem.email         = ["nunemaker@gmail.com"]
+  gem.description   = %q{Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.}
+  gem.summary       = %q{Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.}
+  gem.homepage      = "https://github.com/jnunemaker/cassanity/"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'cassandra-cql', '~> 1.1.3'
+end

data/examples/_shared.rb

@@ -0,0 +1,8 @@
+# Nothing to see here... move along.
+# Sets up load path for examples and requires some stuff
+require 'pp'
+require 'pathname'
+
+root_path = Pathname(__FILE__).dirname.join('..').expand_path
+lib_path  = root_path.join('lib')
+$:.unshift(lib_path)

data/examples/batch.rb

@@ -0,0 +1,40 @@
+require_relative '_shared'
+require 'cassanity'
+
+client = CassandraCQL::Database.new('127.0.0.1:9160')
+executor = Cassanity::Executors::CassandraCql.new(client: client)
+
+connection = Cassanity::Connection.new(executor: executor)
+keyspace = connection['cassanity_examples']
+keyspace.drop if connection.keyspace?('cassanity_examples')
+keyspace.create
+
+# setting up the apps column family
+apps_schema = Cassanity::Schema.new({
+  primary_key: :id,
+  columns: {
+    id: :text,
+    name: :text,
+  },
+})
+apps = keyspace.column_family('apps', schema: apps_schema)
+apps.create
+
+# passing in keyspace and column family names by default
+default_arguments = {
+  keyspace_name: keyspace.name,
+  name: apps.name,
+}
+
+# batch several operations in one network call
+connection.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'})],
+  ],
+})
+
+# only github.com is left
+pp apps.select

data/examples/column_families.rb

@@ -0,0 +1,68 @@
+require_relative '_shared'
+require 'cassanity'
+
+client = CassandraCQL::Database.new('127.0.0.1:9160')
+executor = Cassanity::Executors::CassandraCql.new(client: client)
+
+connection = Cassanity::Connection.new(executor: executor)
+keyspace = connection['cassanity_examples']
+keyspace.drop if connection.keyspace?('cassanity_examples')
+keyspace.create
+
+apps_schema = Cassanity::Schema.new({
+  primary_key: :id,
+  columns: {
+    id: :text,
+    name: :text,
+  },
+})
+
+# get an instance of a column family, providing schema means it can create itself
+apps = keyspace.column_family('apps', schema: apps_schema)
+
+# create column family based on schema
+apps.create
+
+# insert a row
+apps.insert(data: {id: '1', name: 'GitHub'})
+
+# insert another row
+apps.insert(data: {id: '2', name: 'Gist'})
+
+# select rows from apps
+pp apps.select
+
+# update a row based on id
+apps.update(set: {name: 'GitHub.com'}, where: {id: '1'})
+
+# print out the rows again, note that GitHub is updated
+pp apps.select
+
+# now we add a timestamp column
+apps.alter(add: {updated_at: :timestamp})
+
+# note that updated_at is there now, but nil
+pp apps.select
+
+apps.update(set: {updated_at: Time.now}, where: {id: '1'})
+
+# now the GitHub.com record has an updated_at
+pp apps.select
+
+# delete all data
+apps.truncate
+
+# now all the data is gone
+pp apps.select
+
+# completely drop the column family
+apps.drop
+
+begin
+  # we can no longer insert because the column family is gone
+  apps.insert(data: {id: '1', name: 'FAILBOAT'})
+
+# All errors inherit from Cassanity::Error so you can catch everything easily
+rescue Cassanity::Error => e
+  puts e.inspect
+end

data/examples/keyspaces.rb

@@ -0,0 +1,57 @@
+require_relative '_shared'
+require 'cassanity'
+
+client = CassandraCQL::Database.new('127.0.0.1:9160')
+executor = Cassanity::Executors::CassandraCql.new(client: client)
+
+connection = Cassanity::Connection.new(executor: executor)
+
+# gets instance of keyspace
+keyspace = connection['cassanity_examples']
+
+# or you can do this...
+keyspace = connection.keyspace('cassanity_examples')
+
+pp keyspace
+
+# you can also provide options
+keyspace = connection.keyspace('cassanity_examples', {
+  strategy_class: 'SimpleStrategy',
+  strategy_options: {
+    replication_factor: 1,
+  },
+})
+
+# drop keyspace if it exists
+keyspace.drop if connection.keyspace?('cassanity_examples')
+
+# create the keyspace, uses options from above
+keyspace.create
+
+# use this keyspace
+keyspace.use
+
+# get an instance of a column family
+apps = keyspace.column_family('apps')
+
+# you can also pass a schema so the column family is all knowing
+apps_schema = Cassanity::Schema.new({
+  primary_key: :id,
+  columns: {
+    id: :text,
+    name: :text,
+  },
+})
+
+apps = keyspace.column_family('apps', {
+  schema: apps_schema,
+})
+pp apps
+
+# that was basically just a shortcut for this
+apps = Cassanity::ColumnFamily.new({
+  name: 'apps',
+  keyspace: keyspace,
+  schema: apps_schema,
+})
+pp apps

data/lib/cassanity/argument_generators/batch.rb

@@ -0,0 +1,52 @@
+require 'cassanity/argument_generators/using_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class Batch
+
+      # Private: Map of command to argument generator
+      Commands = {
+        insert: ColumnFamilyInsert.new,
+        update: ColumnFamilyUpdate.new,
+        delete: ColumnFamilyDelete.new,
+      }
+
+      # Internal
+      def initialize(args = {})
+        @using_clause = args.fetch(:using_clause) { UsingClause.new }
+        @commands = args.fetch(:commands) { Commands }
+      end
+
+      # Internal
+      def call(args = {})
+        using = args[:using]
+        modifications_argument = args.fetch(:modifications) { [] }
+
+        variables = []
+        cql = "BEGIN BATCH"
+
+        using_cql, *using_variables = @using_clause.call(using: using)
+        cql << using_cql
+        variables.concat(using_variables)
+
+        modifications = []
+        modifications_argument.each do |modification|
+          command_name, command_arguments = modification
+          command = @commands.fetch(command_name)
+
+          modification_cql, *modification_variables = command.call(command_arguments)
+          modifications << modification_cql
+          variables.concat(modification_variables)
+        end
+
+        unless modifications.empty?
+          cql << " #{modifications.join(' ')}"
+        end
+
+        cql << " APPLY BATCH"
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/column_family_alter.rb

@@ -0,0 +1,47 @@
+require 'cassanity/argument_generators/with_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyAlter
+
+      # Internal
+      def initialize(args = {})
+        @with_clause = args.fetch(:with_clause) { WithClause.new }
+      end
+
+      # Internal
+      def call(args = {})
+        name = args.fetch(:name)
+        with = args[:with] || {}
+
+        variables = []
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        cql = "ALTER COLUMNFAMILY #{name}"
+
+        if (alter = args[:alter])
+          column_name, column_type = alter.keys.first, alter.values.first
+          cql << " ALTER #{column_name} TYPE #{column_type}"
+        end
+
+        if (add = args[:add])
+          column_name, column_type = add.keys.first, add.values.first
+          cql << " ADD #{column_name} #{column_type}"
+        end
+
+        if (column_name = args[:drop])
+          cql << " DROP #{column_name}"
+        end
+
+        with_cql, *with_variables = @with_clause.call(with: with)
+        cql << with_cql
+        variables.concat(with_variables)
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/column_family_create.rb

@@ -0,0 +1,44 @@
+require 'cassanity/argument_generators/with_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyCreate
+
+      # Internal
+      def initialize(args = {})
+        @with_clause = args.fetch(:with_clause) { WithClause.new }
+      end
+
+      # Internal
+      def call(args = {})
+        name        = args.fetch(:name)
+        schema      = args.fetch(:schema)
+        columns     = schema.columns
+        primary_key = schema.primary_key
+        with        = schema.with
+
+        definitions, variables = [], []
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        columns.each do |name, type|
+          definitions << "#{name} #{type}"
+        end
+
+        definitions << "PRIMARY KEY (%s)" % Array(primary_key).join(', ')
+
+        cql_definition = definitions.join(', ')
+
+        cql = "CREATE COLUMNFAMILY #{name} (%s)" % cql_definition
+
+        with_cql, *with_variables = @with_clause.call(with: with)
+        cql << with_cql
+        variables.concat(with_variables)
+
+        [cql, *variables]
+      end
+    end
+  end
+end

data/lib/cassanity/argument_generators/column_family_delete.rb

@@ -0,0 +1,65 @@
+require 'cassanity/argument_generators/where_clause'
+require 'cassanity/argument_generators/using_clause'
+
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyDelete
+
+      # Internal
+      def initialize(args = {})
+        @using_clause = args.fetch(:using_clause) { UsingClause.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
+      #        :where - The Hash of options to use to filter the delete
+      #        :columns - The Array of columns you would like to delete
+      #                   (default is all columns) (optional).
+      #        :using - The Hash of options for the query ie: consistency, ttl,
+      #                 and timestamp (default: {}) (optional).
+      #
+      # Examples
+      #
+      #   call({
+      #     name: 'apps',
+      #     where: {
+      #       id: '1',
+      #     },
+      #   })
+      #
+      # Returns Array where first element is CQL string and the rest are
+      #   bound values.
+      def call(args = {})
+        name    = args.fetch(:name)
+        where   = args.fetch(:where)
+        columns = args.fetch(:columns) { [] }
+        using   = args[:using]
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        column_clause, variables = '', []
+
+        unless columns.empty?
+          column_clause = " #{columns.join(', ')}"
+        end
+
+        cql = "DELETE#{column_clause} FROM #{name}"
+
+        using_cql, *using_variables = @using_clause.call(using: using)
+        cql << using_cql
+        variables.concat(using_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/column_family_drop.rb

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

data/lib/cassanity/argument_generators/column_family_insert.rb

@@ -0,0 +1,53 @@
+module Cassanity
+  module ArgumentGenerators
+    class ColumnFamilyInsert
+
+      # 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
+      #        :data - The Hash of keys and values to insert
+      #        :using - The Hash of options for the query ie: consistency, ttl,
+      #                 and timestamp (optional).
+      #
+      # Examples
+      #
+      #   call({
+      #     name: 'apps',
+      #     data: {id: '1', name: 'GitHub'},
+      #   })
+      #
+      #   call({
+      #     name: 'apps',
+      #     data: {id: '1', name: 'GitHub'},
+      #     using: {consistency: 'quorum'},
+      #   })
+      #
+      # Returns Array where first element is CQL string and the rest are
+      #   bound values.
+      def call(args = {})
+        name    = args.fetch(:name)
+        data    = args.fetch(:data)
+        using   = args[:using] || {}
+        keys    = data.keys
+        binders = ['?'] * keys.size
+
+        if (keyspace_name = args[:keyspace_name])
+          name = "#{keyspace_name}.#{name}"
+        end
+
+        cql = "INSERT INTO #{name} (#{keys.join(', ')}) VALUES (#{binders.join(', ')})"
+
+        unless using.empty?
+          statements = []
+          using.each do |key, value|
+            statements << "#{key.upcase} #{value}"
+          end
+          cql << " USING #{statements.join(' AND ')}"
+        end
+
+        [cql, *data.values]
+      end
+    end
+  end
+end