superstore 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8332e4f8d43a68c737e31ae1a88a89c360782a88
+  data.tar.gz: 9cbbc5a3fa095a0af7ef48fb265460530a2a5191
+SHA512:
+  metadata.gz: b09a471630f8a389b2cb250ab70b4d5f1ed48e67ebceb828d9fe1b13236d88bda6ca89c09b3153a70a41f225c6ef25861b7857c3cfeb9bf68bd37c7440e39dad
+  data.tar.gz: 6d68424187b262902591482f8f2db73a40cf7f0bcba670b6eea343538d0c7ca8cd09ff56d8fd11e1955c944a517353fa3243654600f431c21405a97c929aa161

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+env: CQLSH=/usr/local/cassandra/bin/cqlsh
+before_install:
+  - wget http://archive.apache.org/dist/cassandra/1.2.9/apache-cassandra-1.2.9-bin.tar.gz
+  - tar xfz apache-cassandra-1.2.9-bin.tar.gz
+  - sh -c "echo 'JVM_OPTS=\"\${JVM_OPTS} -Xss256k -Djava.net.preferIPv4Stack=false\"' >> apache-cassandra-1.2.9/conf/cassandra-env.sh"
+  - cd apache-cassandra-1.2.9 && sudo ./bin/cassandra 2>&1 >> cassandra.log &

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+gemspec
+
+gem 'rake'
+gem 'thin'
+
+group :test do
+  gem 'rails'
+  gem 'mocha', require: false
+end
+
+group :cassandra do
+  gem 'cassandra-cql'
+end
+
+group :hstore do
+  gem 'activerecord'
+  gem 'pg'
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2009 Koziarski Software Ltd
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [Michael Koziarski]
+
+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,100 @@
+# Superstore
+[![Build Status](https://secure.travis-ci.org/data-axle/superstore.png?rvm=2.0.0)](http://travis-ci.org/data-axle/superstore) [![Code Climate](https://codeclimate.com/github/data-axle/superstore.png)](https://codeclimate.com/github/data-axle/superstore)
+
+Cassandra Object uses ActiveModel to mimic much of the behavior in ActiveRecord.
+
+## Installation
+
+Add the following to your Gemfile:
+```ruby
+gem 'superstore'
+```
+
+Change the version of Cassandra accordingly. Recent versions have not been backward compatible.
+
+## Defining Models
+
+```ruby
+class Widget < Superstore::Base
+  string :name
+  string :description
+  integer :price
+  array :colors, unique: true
+
+  validates :name, presence: :true
+
+  before_create do
+    self.description = "#{name} is the best product ever"
+  end
+end
+```
+## Using with Cassandra
+
+Add the cassandra-cql gem to Gemfile:
+
+```ruby
+gem 'cassandra-cql'
+```
+  
+Add a config/superstore.yml:
+
+```yaml
+development:
+  adapter: cassandra
+  keyspace: my_app_development
+  servers: 127.0.0.1:9160
+  thrift:
+    timeout: 20
+    retries: 2
+```
+
+## Using with Postgres HStore
+
+Add the pg gem to your Gemfile:
+
+```ruby
+gem 'pg'
+```
+  
+And a config/superstore.yml:
+
+```yaml
+development:
+  adapter: hstore
+```
+
+## Creating and updating records
+
+Cassandra Object has equivalent methods as ActiveRecord:
+
+```ruby
+widget = Widget.new
+widget.valid?
+widget = Widget.create(name: 'Acme', price: 100)
+widget.update_attribute(:price, 1200)
+widget.update_attributes(price: 1200, name: 'Acme Corporation')
+widget.attributes = {price: 300}
+widget.price_was
+widget.save
+widget.save!
+```
+
+## Finding records
+
+```ruby
+widget = Widget.find(uuid)
+widget = Widget.first
+widgets = Widget.all
+Widget.find_each do |widget|
+  # Codez
+end
+```
+
+## Scoping
+
+Some lightweight scoping features are available:
+```ruby
+  Widget.where('color' => 'red')
+  Widget.select(['name', 'color'])
+  Widget.limit(10)
+```

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'rake'
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/unit/**/*_test.rb'
+  t.verbose = true
+end

data/lib/superstore/adapters/abstract_adapter.rb

@@ -0,0 +1,49 @@
+module Superstore
+  module Adapters
+    class AbstractAdapter
+      attr_reader :config
+      def initialize(config)
+        @config = config
+      end
+
+      # Read records from a instance of Superstore::Scope
+      def select(scope) # abstract
+      end
+
+      # Insert a new row
+      def insert(table, id, attributes) # abstract
+      end
+
+      # Update an existing row
+      def update(table, id, attributes) # abstract
+      end
+
+      # Delete rows by an array of ids
+      def delete(table, ids) # abstract
+      end
+
+      def execute_batch(statements) # abstract
+      end
+
+      def batching?
+        !@batch_statements.nil?
+      end
+
+      def batch
+        @batch_statements = []
+        yield
+        execute_batch(@batch_statements) if @batch_statements.any?
+      ensure
+        @batch_statements = nil
+      end
+
+      def execute_batchable(statement)
+        if @batch_statements
+          @batch_statements << statement
+        else
+          execute statement
+        end
+      end
+    end
+  end
+end

data/lib/superstore/adapters/cassandra_adapter.rb

@@ -0,0 +1,181 @@
+gem 'cassandra-cql'
+require 'cassandra-cql'
+
+module Superstore
+  module Adapters
+    class CassandraAdapter < AbstractAdapter
+      class QueryBuilder
+        def initialize(adapter, scope)
+          @adapter  = adapter
+          @scope    = scope
+        end
+
+        def to_query
+          [
+            "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+            @adapter.write_option_string,
+            where_string,
+            limit_string
+          ].delete_if(&:blank?) * ' '
+        end
+
+        def select_string
+          if @scope.select_values.any?
+            (['KEY'] | @scope.select_values) * ','
+          else
+            '*'
+          end
+        end
+
+        def where_string
+          wheres = @scope.where_values.dup
+          if @scope.id_values.any?
+            wheres << @adapter.create_ids_where_clause(@scope.id_values)
+          end
+
+          if wheres.any?
+            "WHERE #{wheres * ' AND '}"
+          end
+        end
+
+        def limit_string
+          if @scope.limit_value
+            "LIMIT #{@scope.limit_value}"
+          else
+            ""
+          end
+        end
+      end
+
+      def primary_key_column
+        'KEY'
+      end
+
+      def connection
+        @connection ||= begin
+          thrift_options = (config[:thrift] || {})
+          CassandraCQL::Database.new(servers, {keyspace: config[:keyspace]}, thrift_options)
+        end
+      end
+
+      def servers
+        Array.wrap(config[:servers] || "127.0.0.1:9160")
+      end
+
+      def execute(statement)
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          connection.execute statement
+        end
+      end
+
+      def select(scope)
+        statement = QueryBuilder.new(self, scope).to_query
+
+        execute(statement).fetch do |cql_row|
+          attributes = cql_row.to_hash
+          key = attributes.delete(primary_key_column)
+          yield(key, attributes) unless attributes.empty?
+        end
+      end
+
+      def insert(table, id, attributes)
+        write(table, id, attributes)
+      end
+
+      def update(table, id, attributes)
+        write(table, id, attributes)
+      end
+
+      def write(table, id, attributes)
+        if (not_nil_attributes = attributes.reject { |key, value| value.nil? }).any?
+          insert_attributes = {primary_key_column => id}.update(not_nil_attributes)
+          statement = "INSERT INTO #{table} (#{quote_columns(insert_attributes.keys) * ','}) VALUES (#{Array.new(insert_attributes.size, '?') * ','})#{write_option_string}"
+          execute_batchable sanitize(statement, *insert_attributes.values)
+        end
+
+        if (nil_attributes = attributes.select { |key, value| value.nil? }).any?
+          execute_batchable sanitize("DELETE #{quote_columns(nil_attributes.keys) * ','} FROM #{table}#{write_option_string} WHERE #{primary_key_column} = ?", id)
+        end
+      end
+
+      def delete(table, ids)
+        statement = "DELETE FROM #{table}#{write_option_string} WHERE #{create_ids_where_clause(ids)}"
+
+        execute_batchable statement
+      end
+
+      def execute_batch(statements)
+        raise 'No can do' if statements.empty?
+
+        stmt = [
+          "BEGIN BATCH#{write_option_string(true)}",
+          statements * "\n",
+          'APPLY BATCH'
+        ] * "\n"
+
+        execute stmt
+      end
+
+      # SCHEMA
+      def create_table(table_name, options = {})
+        stmt = "CREATE COLUMNFAMILY #{table_name} " +
+               "(KEY varchar PRIMARY KEY)"
+
+        schema_execute statement_with_options(stmt, options), config[:keyspace]
+      end
+
+      def drop_table(table_name)
+        schema_execute "DROP TABLE #{table_name}", config[:keyspace]
+      end
+
+      def schema_execute(cql, keyspace)
+        schema_db = CassandraCQL::Database.new(Superstore::Base.adapter.servers, {keyspace: keyspace}, {connect_timeout: 30, timeout: 30})
+        schema_db.execute cql
+      end
+      # /SCHEMA
+
+      def consistency
+        @consistency ||= config[:consistency]
+      end
+
+      def consistency=(val)
+        @consistency = val
+      end
+
+      def write_option_string(ignore_batching = false)
+        if (ignore_batching || !batching?) && consistency
+          " USING CONSISTENCY #{consistency}"
+        end
+      end
+
+      def statement_with_options(stmt, options)
+        if options.any?
+          with_stmt = options.map do |k,v|
+            "#{k} = #{CassandraCQL::Statement.quote(v)}"
+          end.join(' AND ')
+
+          "#{stmt} WITH #{with_stmt}"
+        else
+          stmt
+        end
+      end
+
+      def create_ids_where_clause(ids)
+        ids = ids.first if ids.is_a?(Array) && ids.one?
+        sql = ids.is_a?(Array) ? "#{primary_key_column} IN (?)" : "#{primary_key_column} = ?"
+        sanitize(sql, ids)
+      end
+
+      private
+
+        def sanitize(statement, *bind_vars)
+          CassandraCQL::Statement.sanitize(statement, bind_vars).force_encoding(Encoding::UTF_8)
+        end
+
+        def quote_columns(column_names)
+          column_names.map { |name| "'#{name}'" }
+        end
+
+    end
+  end
+end

data/lib/superstore/adapters/hstore_adapter.rb

@@ -0,0 +1,163 @@
+gem 'pg'
+require 'pg'
+
+module Superstore
+  module Adapters
+    class HstoreAdapter < AbstractAdapter
+      class QueryBuilder
+        def initialize(adapter, scope)
+          @adapter  = adapter
+          @scope    = scope
+        end
+
+        def to_query
+          [
+            "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+            where_string,
+            order_string,
+            limit_string,
+          ].delete_if(&:blank?) * ' '
+        end
+
+        def select_string
+          if @scope.select_values.any?
+            "id, slice(attribute_store, #{@adapter.fields_to_postgres_array(@scope.select_values)}) as attribute_store"
+          else
+            '*'
+          end
+        end
+
+        def where_string
+          wheres = @scope.where_values.dup
+          if @scope.id_values.any?
+            wheres << @adapter.create_ids_where_clause(@scope.id_values)
+          end
+
+          if wheres.any?
+            "WHERE #{wheres * ' AND '}"
+          end
+        end
+
+        def order_string
+          if @scope.id_values.many?
+            id_orders = @scope.id_values.map { |id| "ID=#{@adapter.quote(id)} DESC" }.join(',')
+            "ORDER BY #{id_orders}"
+          end
+        end
+
+        def limit_string
+          if @scope.limit_value
+            "LIMIT #{@scope.limit_value}"
+          end
+        end
+      end
+
+      def primary_key_column
+        'id'
+      end
+
+      def connection
+        # conf = {:adapter=>"postgresql", :encoding=>"unicode", :database=>"axle_place_test", :pool=>5, :username=>"postgres"}
+        # @connection ||= ActiveRecord::Base.postgresql_connection(conf)
+        ActiveRecord::Base.connection
+      end
+
+      def execute(statement)
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          connection.exec_query statement
+        end
+      end
+
+      def select(scope)
+        statement = QueryBuilder.new(self, scope).to_query
+
+        connection.execute(statement).each do |attributes|
+          yield attributes[primary_key_column], hstore_to_attributes(attributes['attribute_store'])
+        end
+      end
+
+      def insert(table, id, attributes)
+        not_nil_attributes = attributes.reject { |key, value| value.nil? }
+        statement = "INSERT INTO #{table} (#{primary_key_column}, attribute_store) VALUES (#{quote(id)}, #{attributes_to_hstore(not_nil_attributes)})"
+        execute_batchable statement
+      end
+
+      def update(table, id, attributes)
+        return if attributes.empty?
+
+        not_nil_attributes = attributes.reject { |key, value| value.nil? }
+        nil_attributes = attributes.select { |key, value| value.nil? }
+
+        if not_nil_attributes.any? && nil_attributes.any?
+          value_update = "(attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}) || #{attributes_to_hstore(not_nil_attributes)}"
+        elsif not_nil_attributes.any?
+          value_update = "attribute_store || #{attributes_to_hstore(not_nil_attributes)}"
+        elsif nil_attributes.any?
+          value_update = "attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}"
+        end
+
+        statement = "UPDATE #{table} SET attribute_store = #{value_update} WHERE #{primary_key_column} = #{quote(id)}"
+        execute_batchable statement
+      end
+
+      def delete(table, ids)
+        statement = "DELETE FROM #{table} WHERE #{create_ids_where_clause(ids)}"
+
+        execute_batchable statement
+      end
+
+      def execute_batch(statements)
+        stmt = [
+          "BEGIN",
+          statements * ";\n",
+          'COMMIT'
+        ] * ";\n"
+
+        execute stmt
+      end
+
+      def create_table(table_name, options = {})
+        connection.execute 'CREATE EXTENSION IF NOT EXISTS hstore'
+        ActiveRecord::Migration.create_table table_name, id: false do |t|
+          t.string :id, null: false
+          t.hstore :attribute_store, null: false
+        end
+        connection.execute "ALTER TABLE \"#{table_name}\" ADD CONSTRAINT #{table_name}_pkey PRIMARY KEY (id)"
+      end
+
+      def drop_table(table_name)
+        ActiveRecord::Migration.drop_table table_name
+      end
+
+      def create_ids_where_clause(ids)
+        ids = ids.first if ids.is_a?(Array) && ids.one?
+
+        if ids.is_a?(Array)
+          id_list = ids.map { |id| quote(id) }.join(',')
+          "#{primary_key_column} IN (#{id_list})"
+        else
+          "#{primary_key_column} = #{quote(ids)}"
+        end
+      end
+
+      def quote(value)
+        connection.quote(value)
+      end
+
+      def fields_to_postgres_array(fields)
+        quoted_fields = fields.map { |field| "'#{field}'" }.join(',')
+        "ARRAY[#{quoted_fields}]"
+      end
+
+      private
+
+        def attributes_to_hstore(attributes)
+          quote ActiveRecord::ConnectionAdapters::PostgreSQLColumn.hstore_to_string(attributes)
+        end
+
+        def hstore_to_attributes(string)
+          ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_hstore(string)
+        end
+    end
+  end
+end

data/lib/superstore/attribute_methods/definition.rb

@@ -0,0 +1,22 @@
+module Superstore
+  module AttributeMethods
+    class Definition
+      attr_reader :name, :coder
+      def initialize(name, coder, options)
+        @name   = name.to_s
+        @coder  = coder.new(options)
+      end
+
+      def default
+        coder.default
+      end
+
+      def instantiate(record, value)
+        value = value.nil? ? coder.default : value
+        return if value.nil?
+
+        value.kind_of?(String) ? coder.decode(value) : coder.typecast(value)
+      end
+    end
+  end
+end

data/lib/superstore/attribute_methods/dirty.rb

@@ -0,0 +1,36 @@
+module Superstore
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
+
+      # Attempts to +save+ the record and clears changed attributes if successful.
+      def save(*) #:nodoc:
+        if status = super
+          @previously_changed = changes
+          @changed_attributes = {}
+        end
+        status
+      end
+
+      # <tt>reload</tt> the record and clears changed attributes.
+      def reload
+        super.tap do
+          @previously_changed.try :clear
+          @changed_attributes.try :clear
+        end
+      end
+
+      def write_attribute(name, value)
+        name = name.to_s
+        old = read_attribute(name)
+
+        super
+
+        unless attribute_changed?(name) || old == read_attribute(name)
+          changed_attributes[name] = old
+        end
+      end
+    end
+  end
+end

data/lib/superstore/attribute_methods/primary_key.rb

@@ -0,0 +1,25 @@
+module Superstore
+  module AttributeMethods
+    module PrimaryKey
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def primary_key
+          'id'
+        end
+      end
+
+      def id
+        @id ||= self.class._generate_key(self)
+      end
+
+      def id=(id)
+        @id = id
+      end
+
+      def attributes
+        super.update(self.class.primary_key => id)
+      end
+    end
+  end
+end