superstore 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed0f1d714b1ce3f33ed3fd382d6460dfb4e09024
-  data.tar.gz: 643444b1b23de94b5f3e1ec08b787c40fcee253a
+  metadata.gz: 2e09c0c96fee4aa9bbe63b30515cea262876069d
+  data.tar.gz: f045d35fdb783ec088617d8b3e1fff9c32c26394
 SHA512:
-  metadata.gz: 59e383fdb469396d92e243b51b0247ac8ff6184c373ce92a62ee0d32776c8d9ba77a23db139ac5b80988b4919ad5efd3fd38c5e351e6c44a4b48291bc394fff1
-  data.tar.gz: 34effeb3db2d42fa94c2d4bece8b4bb5982f70251b8c7d1f0409ab7e86ae043e2ad6bf6d031a35edf06398012dae1bb944ef7ef72e185adce7d399fcdd92e465
+  metadata.gz: 7d479634ee3bf4b165a495038f19e8c0ba50ea2f4bbcba6674306d71d2cd3142266a22e4971de3af4c2af7241cbcfe2147425a0c4b2bcb76f6e2f6eaef64a9bd
+  data.tar.gz: 972a07eeb6a39fbd07a7cfef12203d23a34dd1a616e87434e8d5b3b5b1995872c237256d47165e7f3a48dfd55dd57b185bebd1d55982c76c9d6e59d1d60cf37f

data/.travis.yml

@@ -1,16 +1,9 @@
 language: ruby
 rvm:
-- 1.9.3
-- 2.0.0
-- 2.1.0
-- 2.2.0
+- 2.0.0-p647
+- 2.1.7
+- 2.2.3
 sudo: false
-env:
-  global:
-  - CQLSH=/usr/local/cassandra/bin/cqlsh
-  - KS_VERSION=1.2.19
-  - KS_NAME=apache-cassandra-$KS_VERSION
-before_install:
-- if [[ ! -f $KS_NAME/conf/cassandra.yaml ]]; then wget http://archive.apache.org/dist/cassandra/$KS_VERSION/$KS_NAME-bin.tar.gz; tar xf $KS_NAME-bin.tar.gz; sh -c "echo 'JVM_OPTS=\"\${JVM_OPTS} -Xss256k -Djava.net.preferIPv4Stack=false\"' >> $KS_NAME/conf/cassandra-env.sh"; fi
-- sed -i -e 's:/var/.*\?/cassandra:/tmp/cassandra-store:g' $KS_NAME/conf/{cassandra.yaml,log4j-server.properties}
-- (cd $KS_NAME && ./bin/cassandra 2>&1 >> cassandra.log)
+cache: bundler
+addons:
+  postgresql: '9.4'

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 2.0.0
+
+Released YYYY-MM-DD.
+
+## New Features
+
+* **Added Postgres JSONB adapter.** (#9)
+* Added support for `has_many` association. (#13)
+* Added support for `has_one` association. (#14)
+
+## Breaking Changes
+
+* **Removed Cassandra and Postgres hstore adapters.** (#12)
+* `find_each` now uses SQL cursors, so it's not constrained by the limitations of ActiveRecord's
+  implementation. (#11)
+* Default values have been re-implemented correctly. (#15)

data/Gemfile

@@ -2,7 +2,6 @@ source "http://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'thin'
 
 group :test do
   gem 'rails'
@@ -10,7 +9,3 @@ group :test do
   gem 'activerecord', '~> 4.2.0'
   gem 'mocha', require: false
 end
-
-group :cassandra do
-  gem 'cassandra-cql', "1.1.4"
-end

data/README.md

@@ -1,17 +1,15 @@
 # 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)
+[![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/badges/gpa.svg)](https://codeclimate.com/github/data-axle/superstore)
 
-Cassandra Object uses ActiveModel to mimic much of the behavior in ActiveRecord.
+Superstore uses ActiveModel to mimic much of the behavior in ActiveRecord.
 
 ## Installation
 
-Add the following to your Gemfile:
+Add the following to the `Gemfile`:
 ```ruby
 gem 'superstore'
 ```
 
-Change the version of Cassandra accordingly. Recent versions have not been backward compatible.
-
 ## Defining Models
 
 ```ruby
@@ -30,51 +28,34 @@ end
 ```
 
 The table name defaults to the case-sensitive, pluralized name of the model class. To specify a
-custom name, set the ```table_name``` attribute on the class:
+custom name, set the `table_name` attribute on the class:
 
 ```ruby
 class MyWidget < Superstore::Base
   table_name = 'my_widgets'
 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
+## Using the PostgreSQL JSONB adapter
 
-Add the pg gem to your Gemfile:
+Add the `pg` gem to the `Gemfile`:
 
 ```ruby
 gem 'pg'
 ```
 
-And a config/superstore.yml:
+Add a `config/superstore.yml`:
 
 ```yaml
 development:
-  adapter: hstore
+  adapter: jsonb
 ```
 
+Superstore will share the existing ActiveRecord database connection.
+
 ## Creating and updating records
 
-Cassandra Object has equivalent methods as ActiveRecord:
+Superstore has equivalent methods to ActiveRecord:
 
 ```ruby
 widget = Widget.new
@@ -102,8 +83,9 @@ end
 ## Scoping
 
 Some lightweight scoping features are available:
+
 ```ruby
-  Widget.where('color' => 'red')
-  Widget.select(['name', 'color'])
-  Widget.limit(10)
+Widget.where('color' => 'red')
+Widget.select(['name', 'color'])
+Widget.limit(10)
 ```

data/lib/superstore/adapters/jsonb_adapter.rb

@@ -0,0 +1,245 @@
+gem 'pg'
+require 'pg'
+
+module Superstore
+  module Adapters
+    class JsonbAdapter < AbstractAdapter
+      class QueryBuilder
+        def initialize(adapter, scope)
+          @adapter  = adapter
+          @scope    = scope
+        end
+
+        def to_query
+          [
+            "SELECT #{select_string} FROM #{@scope.klass.table_name}",
+            where_string,
+            order_string,
+            limit_string
+          ].delete_if(&:blank?) * ' '
+        end
+
+        def select_string
+          if @scope.select_values.any?
+            "id, jsonb_slice(document, #{@adapter.fields_to_postgres_array(@scope.select_values)}) as document"
+          else
+            '*'
+          end
+        end
+
+        def where_string
+          wheres = where_values_as_strings
+
+          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.order_values.any?
+            orders = @scope.order_values.join(', ')
+            "ORDER BY #{orders}"
+          elsif @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
+
+        def where_values_as_strings
+          @scope.where_values.map do |where_value|
+            if where_value.is_a?(Hash)
+              key = where_value.keys.first
+              value = where_value.values.first
+
+              if value.nil?
+                "(document->>'#{key}') IS NULL"
+              elsif value.is_a?(Array)
+                typecasted_values = value.map { |v| "'#{v}'" }.join(',')
+                "document->>'#{key}' IN (#{typecasted_values})"
+              else
+                "document->>'#{key}' = '#{value}'"
+              end
+            else
+              where_value
+            end
+          end
+        end
+      end
+
+      def primary_key_column
+        'id'
+      end
+
+      def connection
+        active_record_klass.connection
+      end
+
+      def active_record_klass=(klass)
+        @active_record_klass = klass
+      end
+
+      def active_record_klass
+        @active_record_klass ||= ActiveRecord::Base
+      end
+
+      def execute(statement)
+        connection.execute statement
+      end
+
+      def select(scope)
+        statement = QueryBuilder.new(self, scope).to_query
+
+        connection.execute(statement).each do |result|
+          yield result[primary_key_column], Oj.compat_load(result['document'])
+        end
+      end
+
+      def scroll(scope, batch_size)
+        statement   = QueryBuilder.new(self, scope).to_query
+        cursor_name = "cursor_#{SecureRandom.hex(6)}"
+        fetch_sql   = "FETCH FORWARD #{batch_size} FROM #{cursor_name}"
+
+        connection.transaction do
+          connection.execute "DECLARE #{cursor_name} NO SCROLL CURSOR FOR (#{statement})"
+
+          while (batch = connection.execute(fetch_sql)).any?
+            batch.each do |result|
+              yield result[primary_key_column], Oj.compat_load(result['document'])
+            end
+          end
+        end
+      end
+
+      def insert(table, id, attributes)
+        not_nil_attributes = attributes.reject { |key, value| value.nil? }
+        statement = "INSERT INTO #{table} (#{primary_key_column}, document) VALUES (#{quote(id)}, #{to_quoted_jsonb(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 = "jsonb_merge(jsonb_delete(document, #{fields_to_postgres_array(nil_attributes.keys)}), #{to_quoted_jsonb(not_nil_attributes)})"
+        elsif not_nil_attributes.any?
+          value_update = "jsonb_merge(document, #{to_quoted_jsonb(not_nil_attributes)})"
+        elsif nil_attributes.any?
+          value_update = "jsonb_delete(document, #{fields_to_postgres_array(nil_attributes.keys)})"
+        end
+
+        statement = "UPDATE #{table} SET document = #{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)
+        connection.transaction do
+          execute(statements * ";\n")
+        end
+      end
+
+      def create_table(table_name, options = {})
+        ActiveRecord::Migration.create_table table_name, id: false do |t|
+          t.string :id, null: false
+          t.jsonb :document, 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| quote(field) }.join(',')
+        "ARRAY[#{quoted_fields}]"
+      end
+
+      OJ_OPTIONS = {mode: :compat}
+      def to_quoted_jsonb(data)
+        "#{quote(Oj.dump(data, OJ_OPTIONS))}::JSONB"
+      end
+
+      JSON_FUNCTIONS = {
+        # SELECT jsonb_slice('{"b": 2, "c": 3, "a": 4}', '{b, c}');
+        'jsonb_slice(data jsonb, keys text[])' => %{
+          SELECT json_object_agg(key, value)::jsonb
+          FROM (
+            SELECT * FROM jsonb_each(data)
+          ) t
+          WHERE key =ANY(keys);
+        },
+
+        # SELECT jsonb_merge('{"a": 1}', '{"b": 2, "c": 3, "a": 4}');
+        'jsonb_merge(data jsonb, merge_data jsonb)' => %{
+          SELECT json_object_agg(key, value)::jsonb
+          FROM (
+            WITH to_merge AS (
+              SELECT * FROM jsonb_each(merge_data)
+            )
+            SELECT *
+            FROM jsonb_each(data)
+            WHERE key NOT IN (SELECT key FROM to_merge)
+            UNION ALL
+            SELECT * FROM to_merge
+          ) t;
+        },
+
+        # SELECT jsonb_delete('{"b": 2, "c": 3, "a": 4}', '{b, c}');
+        'jsonb_delete(data jsonb, keys text[])' => %{
+          SELECT json_object_agg(key, value)::jsonb
+          FROM (
+            SELECT * FROM jsonb_each(data)
+            WHERE key <>ALL(keys)
+          ) t;
+        },
+      }
+      def define_jsonb_functions!
+        JSON_FUNCTIONS.each do |signature, body|
+          connection.execute %{
+            CREATE OR REPLACE FUNCTION public.#{signature}
+            RETURNS jsonb
+            IMMUTABLE
+            LANGUAGE sql
+            AS $$
+              #{body}
+            $$;
+          }
+        end
+      end
+    end
+  end
+end

data/lib/superstore/associations/association.rb

@@ -0,0 +1,38 @@
+module Superstore
+  module Associations
+    class Association
+      attr_reader :owner, :reflection
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        @owner = owner
+        @reflection = reflection
+      end
+
+      def association_class
+        association_class_name.constantize
+      end
+
+      def association_class_name
+        reflection.polymorphic? ? owner.send(reflection.polymorphic_column) : reflection.class_name
+      end
+
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def target
+        @target
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded!
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/superstore/associations/belongs_to.rb

@@ -0,0 +1,35 @@
+module Superstore
+  module Associations
+    class BelongsTo < Association
+      def reader
+        unless loaded?
+          self.target = get_record
+        end
+
+        target
+      end
+
+      def writer(record)
+        self.target = record
+        owner.send("#{reflection.foreign_key}=", record.try(reflection.primary_key))
+        if reflection.polymorphic?
+          owner.send("#{reflection.polymorphic_column}=", record.class.name)
+        end
+      end
+
+      private
+
+        def get_record
+          record_id = owner.send(reflection.foreign_key).presence
+          return unless record_id
+
+          if reflection.default_primary_key?
+            association_class.find_by_id(record_id)
+          else
+            association_class.find_by(reflection.primary_key => record_id)
+          end
+        end
+
+    end
+  end
+end

data/lib/superstore/associations/builder/association.rb

@@ -0,0 +1,38 @@
+module Superstore::Associations::Builder
+  class Association
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    attr_reader :model, :name, :options
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+
+    def build
+      define_writer
+      define_reader
+
+      reflection = Superstore::Associations::Reflection.new(macro, name, model, options)
+      model.association_reflections = model.association_reflections.merge(name => reflection)
+    end
+
+    def mixin
+      model.generated_association_methods
+    end
+
+    def define_writer
+      name = self.name
+      mixin.redefine_method("#{name}=") do |records|
+        association(name).writer(records)
+      end
+    end
+
+    def define_reader
+      name = self.name
+      mixin.redefine_method(name) do
+        association(name).reader
+      end
+    end
+  end
+end

data/lib/superstore/associations/builder/belongs_to.rb

@@ -0,0 +1,7 @@
+module Superstore::Associations::Builder
+  class BelongsTo < Association
+    def macro
+      :belongs_to
+    end
+  end
+end

data/lib/superstore/associations/builder/has_many.rb

@@ -0,0 +1,7 @@
+module Superstore::Associations::Builder
+  class HasMany < Association
+    def macro
+      :has_many
+    end
+  end
+end

data/lib/superstore/associations/builder/has_one.rb

@@ -0,0 +1,7 @@
+module Superstore::Associations::Builder
+  class HasOne < Association
+    def macro
+      :has_one
+    end
+  end
+end

data/lib/superstore/associations/has_many.rb

@@ -0,0 +1,26 @@
+module Superstore
+  module Associations
+    class HasMany < Association
+      def reader
+        unless loaded?
+          self.target = load_collection
+        end
+
+        target
+      end
+
+      def writer(records)
+        reader.instance_variable_set :@records, records
+        reader.instance_variable_set :@loaded, true
+        loaded!
+      end
+
+      private
+
+        def load_collection
+          association_class.where(reflection.foreign_key => owner.try(reflection.primary_key))
+        end
+
+    end
+  end
+end

data/lib/superstore/associations/has_one.rb

@@ -0,0 +1,24 @@
+module Superstore
+  module Associations
+    class HasOne < Association
+      def reader
+        unless loaded?
+          self.target = load_target
+        end
+
+        target
+      end
+
+      def writer(record)
+        self.target = record
+      end
+
+      private
+
+        def load_target
+          association_class.where(reflection.foreign_key => owner.try(reflection.primary_key)).first
+        end
+
+    end
+  end
+end

data/lib/superstore/associations/reflection.rb

@@ -0,0 +1,65 @@
+module Superstore
+  module Associations
+    class Reflection
+      attr_reader :macro, :name, :model, :options
+      def initialize(macro, name, model, options)
+        @macro  = macro
+        @name   = name
+        @model  = model
+        @options = options
+      end
+
+      def association_class
+        case macro
+        when :belongs_to
+          Superstore::Associations::BelongsTo
+        when :has_many
+          Superstore::Associations::HasMany
+        when :has_one
+          Superstore::Associations::HasOne
+        end
+        
+      end
+
+      def instance_variable_name
+        "@#{name}"
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      def primary_key
+        options[:primary_key] || "id"
+      end
+
+      def default_primary_key?
+        primary_key == "id"
+      end
+
+      def polymorphic_column
+        "#{name}_type"
+      end
+
+      def polymorphic?
+        options[:polymorphic]
+      end
+
+      def class_name
+        @class_name ||= (options[:class_name] || name.to_s.classify)
+      end
+
+      private
+      
+      def derive_foreign_key
+        case macro
+        when :has_many, :has_one
+          model.name.foreign_key
+        when :belongs_to
+          "#{name}_id"
+        end
+      end
+
+    end
+  end
+end