post_json 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90d8b0c0218c6e80aea604f49fe5ea5dfddff653
+  data.tar.gz: 4e8e16084b21f5909e1d1e2728e5a707483c050b
+SHA512:
+  metadata.gz: cdb0d422a3cb9ae46eb28d2dc70e9c97ff2513e88654aa729ca207da8f8e835ce546813762446aadf588e298b721b72cb24ee36b69aab0c2ade5dc4b2d3b401e
+  data.tar.gz: a7e994fced38b80d2b2644555bef27d82a62d6a6f00d92719f64f60e19871710ae6e2cbd0456f9d7624de5bd7d924840aa036740f2f1e6b9c38d02ab3ccaf3f7

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Webnuts (www.webnuts.com / hello@webnuts.com)
+
+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,194 @@
+# Welcome to PostJson
+
+PostJson is everything you expect of ActiveRecord and PostgreSQL, but with the dynamic nature of document databases 
+(free as a bird - no schemas).
+
+PostJson take full advantage of PostgreSQL 9.2+ support for JavaScript (Google's V8 engine). We started the work on 
+PostJson, because we love document databases and PostgreSQL. PostJson combine features of Ruby, ActiveRecord and 
+PostgreSQL to provide a great document database.
+
+See example of how we use PostJson as part of Jump... 
+
+
+## Getting started
+1. Add the gem to your Ruby on Rails application `Gemfile`:
+
+        gem 'post_json'
+        
+2. At the command prompt, install the gem:
+
+        bundle install
+        rails g post_json:install
+        rake db:migrate
+        
+That's it!
+
+(See POSTGRESQL_INSTALL.md if you need the install instructions for PostgreSQL with PLV8)
+
+## Using it
+
+You should feel home right away, if you already know ActiveRecord. PostJson try hard to respect the ActiveRecord 
+API, so methods work and do as you would expect from ActiveRecord.
+
+PostJson is all about collections. All models represent a collection.
+
+Also, __notice you don't have to define model attributes anywhere!__
+
+1. Lets create your first model.
+
+        class Person < PostJson::Collection["people"]
+        end
+        
+        me = Person.create(name: "Jacob")
+
+    As you can see it look the same as ActiveRecord, except you define `PostJson::Collection["people"]` instead of 
+    `ActiveRecord::Base`.
+    
+    `Person` can do the same as any model class inheriting `ActiveRecord::Base`.
+    
+    You can also skip the creation of a class:
+    
+        people = PostJson::Collection["people"]
+        me = people.create(name: "Jacob")
+
+2. Adding some validation:
+
+        class Person < PostJson::Collection["people"]
+          validates :name, presence: true
+        end
+
+    PostJson::Collection["people"] returns a class, which is based on `PostJson::Base`, which is based on 
+    `ActiveRecord::Base`. So its the exact same validation as you may know.
+    
+    Read the <a href="http://guides.rubyonrails.org/active_record_validations.html" target="_blank">Rails guide about validation</a> 
+    if you need more information.
+
+3. Lets create a more complex document and do a query:
+
+        me = Person.create(name: "Jacob", details: {age: 33})
+        
+    Now we can make a query and get the document:
+    
+        also_me_1 = Person.where(details: {age: 33}).first
+        also_me_2 = Person.where("details.age" => 33).first
+        also_me_3 = Person.where("json_details.age = ?", 33).first
+        
+   PostJson support filtering on nested attributes as you can see. The two first queries speak for themself.
+   
+   The third (and last) query is special and show it is possible to write real SQL queries. We just need to prefix 
+   the JSON attributes with `json_`.
+
+4. Accessing attributes:
+
+        person = Person.create(name: "Jacob")
+        puts person.name            # "Jacob"
+        puts person.name_was        # "Jacob"
+        puts person.name_changed?   # false
+        puts person.name_change     # nil
+
+        person.name = "Martin"
+        
+        puts person.name_was        # "Jacob"
+        puts person.name            # "Martin"
+        puts person.name_changed?   # true
+        puts person.name_change     # ["Jacob", "Martin"]
+        
+        person.save
+
+        puts person.name            # "Martin"
+        puts person.name_was        # "Martin"
+        puts person.name_changed?   # false
+        puts person.name_change     # nil
+        
+    Like you would expect with ActiveRecord.
+
+#### All of the following methods are supported
+
+        except
+        limit
+        offset
+        page(page, per_page) # translate to `offset((page-1)*per_page).limit(per_page)`
+        only
+        order
+        reorder
+        reverse_order
+        where
+        
+    And ...
+        
+        all
+        any?
+        blank?
+        count
+        delete
+        delete_all
+        destroy
+        destroy_all
+        empty?
+        exists?
+        find
+        find_by
+        find_by!
+        find_each
+        find_in_batches
+        first
+        first!
+        first_or_create
+        first_or_initialize
+        ids
+        last
+        load
+        many?
+        pluck
+        select
+        size
+        take
+        take!
+        to_a
+        to_sql
+        
+        
+        
+        
+
+
+        
+## Dynamic Indexes
+
+We have created a feature we call `Dynamic Index`. It will automatically create indexes on slow queries, so queries 
+speed up considerably.
+
+PostJson will measure the duration of each `SELECT` query and instruct PostgreSQL to create an Expression Index, 
+if the query duration is above a specified threshold.
+
+Each collection (like PostJson::Collection["people"]) have attribute `use_dynamic_index` (which is true by default) and 
+attribute `create_dynamic_index_milliseconds_threshold` (which is 50 by default).
+
+Lets say that you execute the following query and the duration is above the threshold of 50 milliseconds:
+
+`PostJson::Collection["people"].where(name: "Jacob").count`
+
+PostJson will create (unless it already exists) an Expression Index on `name` behind the scenes. The next time 
+you execute a query with `name` the performance will be much improved.
+
+## Requirements
+
+- PostgreSQL 9.2 or 9.3
+- PostgreSQL PLV8 extension.
+
+## License
+
+PostJson is released under the MIT License. See the MIT-LICENSE file.
+
+## Want to contribute?
+
+That's awesome, thank you!
+
+Do you have an idea or suggestion? Please create an issue or send us an e-mail (hello@webnuts.com). We would be happy to implement (if we like the idea) right away.
+
+You can also send us a pull request with your contribution.
+
+<a href="http://www.webnuts.com" target="_blank">
+  <img src="http://www.webnuts.com/logo/post_json/logo.png" alt="Webnuts.com">
+</a>
+##### Sponsored by Webnuts.com

data/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PostJson'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/core_ext/abstract_adapter_extend.rb

@@ -0,0 +1,16 @@
+ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+
+  attr_accessor :last_select_query, :last_select_query_duration
+  
+  def measure_select_all(arel, name = nil, binds = [])
+    result = nil
+    @last_select_query_duration = Benchmark.realtime do
+      result = original_select_all(arel, name, binds)
+    end
+    @last_select_query = to_sql(arel, binds.dup).strip
+    result
+  end
+
+  alias_method :original_select_all, :select_all
+  alias_method :select_all, :measure_select_all
+end

data/lib/core_ext/active_record_relation_extend.rb

@@ -0,0 +1,16 @@
+# See https://github.com/rails/rails/blob/master/activerecord/CHANGELOG.md - Fixes #10615
+#
+# "Usage of implicit_readonly is being removed. Please usereadonlymethod explicitly to mark records asreadonly"
+#
+# The override below can be removed in the future
+
+ActiveRecord::Relation.class_eval do
+  def exec_queries_without_implicit_readonly
+    records = original_exec_queries
+    records.each { |r| r.instance_variable_set(:@readonly, false) } unless self.readonly_value == true
+    records
+  end
+
+  alias_method :original_exec_queries, :exec_queries
+  alias_method :exec_queries, :exec_queries_without_implicit_readonly
+end

data/lib/core_ext/hash_extend.rb

@@ -0,0 +1,36 @@
+class Hash
+  def flatten_hash(prefix = nil)
+    self.inject(HashWithIndifferentAccess.new) do |result, (key, value)|
+      combined_key = [prefix, key].compact.join(".")
+      if value.is_a?(Hash)
+        result.deep_merge!(value.flatten_hash(combined_key))
+      else
+        result[combined_key] = value
+      end
+      result
+    end
+  end
+
+  def deepen_hash
+    self.inject(HashWithIndifferentAccess.new) do |result, (key, value)|
+      path_names = key.split(".")
+      if path_names.length == 1
+        result[key] = value
+      else
+        key_result = path_names.reverse.inject(nil) do |result, path_name|
+          if result == nil
+            HashWithIndifferentAccess.new(path_name => value)
+          else
+            HashWithIndifferentAccess.new(path_name => result)
+          end
+        end
+        result.deep_merge!(key_result)
+      end
+      result
+    end
+  end
+
+  def difference(h2)
+    dup.delete_if { |k, v| h2[k] == v }.merge!(h2.dup.delete_if { |k, v| has_key?(k) })
+  end
+end

data/lib/generators/post_json/install/install_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators/migration'
+
+module PostJson
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      desc "add the migrations"
+
+      def self.next_migration_number(path)
+        unless @prev_migration_nr
+          @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        else
+          @prev_migration_nr += 1
+        end
+        @prev_migration_nr.to_s
+      end
+
+      def copy_migrations
+        migration_template "enable_extensions.rb", "db/migrate/enable_extensions.rb"
+        migration_template "create_procedures.rb", "db/migrate/create_procedures.rb"
+        migration_template "create_post_json_model_settings.rb", "db/migrate/create_post_json_model_settings.rb"
+        migration_template "create_post_json_documents.rb", "db/migrate/create_post_json_documents.rb"
+        migration_template "create_post_json_dynamic_indexes.rb", "db/migrate/create_post_json_dynamic_indexes.rb"
+      end
+
+      def copy_initializer_file
+        copy_file "initializer.rb", "config/initializers/post_json.rb"
+      end
+    end
+  end
+end

data/lib/generators/post_json/install/templates/create_post_json_documents.rb

@@ -0,0 +1,13 @@
+class CreatePostJsonDocuments < ActiveRecord::Migration
+  def change
+    create_table :post_json_documents, id: false do |t|
+      t.text :id, null: false, index: true
+      t.integer :__doc__version
+      t.json :__doc__body
+      t.uuid :__doc__model_settings_id
+    end
+
+    execute "CREATE UNIQUE INDEX post_json_documents_unique_id ON post_json_documents(id, __doc__model_settings_id);"
+    execute "ALTER TABLE post_json_documents ADD PRIMARY KEY (id, __doc__model_settings_id);"
+  end
+end

data/lib/generators/post_json/install/templates/create_post_json_dynamic_indexes.rb

@@ -0,0 +1,9 @@
+class CreatePostJsonDynamicIndexes < ActiveRecord::Migration
+  def change
+    create_table :post_json_dynamic_indexes, id: :uuid do |t|
+      t.text :selector, index: true, null: false
+      t.uuid :model_settings_id, index: true
+      t.timestamps
+    end
+  end
+end

data/lib/generators/post_json/install/templates/create_post_json_model_settings.rb

@@ -0,0 +1,18 @@
+class CreatePostJsonModelSettings < ActiveRecord::Migration
+  def change
+    create_table :post_json_model_settings, id: :uuid do |t|
+      t.text :collection_name, index: true, unique: true
+      t.json :meta, default: {}, null: false
+      t.boolean :use_timestamps, default: true
+      t.text :created_at_attribute_name, default: 'created_at', null: false
+      t.text :updated_at_attribute_name, default: 'updated_at', null: false
+      t.boolean :include_version_number, default: true
+      t.text :version_attribute_name, default: 'version', null: false
+      t.boolean :use_dynamic_index, default: true
+      t.integer :create_dynamic_index_milliseconds_threshold, default: 50
+      t.timestamps
+    end
+
+    execute "CREATE INDEX post_json_model_settings_lower_collection_name ON post_json_model_settings(lower(collection_name));"
+  end
+end

data/lib/generators/post_json/install/templates/create_procedures.rb

@@ -0,0 +1,120 @@
+# http://pgxn.org/dist/plv8/doc/plv8.html
+# http://plv8-pgopen.herokuapp.com/
+# http://www.craigkerstiens.com/2013/06/25/javascript-functions-for-postgres/
+# http://www.postgresonline.com/journal/archives/272-Using-PLV8-to-build-JSON-selectors.html
+
+class CreateProcedures < ActiveRecord::Migration
+  def change
+    ActiveRecord::Base.connection.execute(json_numeric_procedure)
+    ActiveRecord::Base.connection.execute(json_text_procedure)
+    ActiveRecord::Base.connection.execute(js_filter_procedure)
+    ActiveRecord::Base.connection.execute(json_selector_procedure)
+    ActiveRecord::Base.connection.execute(json_selectors_procedure)
+    ActiveRecord::Base.connection.execute(show_all_indexes_procedure)
+    # ActiveRecord::Base.connection.execute(show_indexes_procedure)
+    # ActiveRecord::Base.connection.execute(ensure_dynamic_index_procedure)
+  end
+
+  def json_numeric_procedure
+"CREATE OR REPLACE FUNCTION json_numeric(key text, data json) RETURNS numeric AS $$
+  if (data == null) {
+    return null;
+  }
+  return data[key];
+$$ LANGUAGE plv8 IMMUTABLE STRICT;"
+  end
+
+  def json_text_procedure
+"CREATE OR REPLACE FUNCTION json_text(key text, data json) RETURNS text AS $$
+  if (data == null) {
+    return null;
+  }
+  return data[key];
+$$ LANGUAGE plv8 IMMUTABLE STRICT;"    
+  end
+
+  def js_filter_procedure
+"create or replace function js_filter(js_function text, json_arguments text, data json) returns numeric as $$
+  if (data == null) {
+    return null;
+  }
+  eval('var func = ' + js_function);
+  eval('var args = ' + (json_arguments == '' ? 'null' : json_arguments));
+  var final_args = [data].concat(args);
+  var result = func.apply(null, final_args);
+  return result == true || 0 < parseInt(result) ? 1 : 0;
+$$ LANGUAGE plv8 IMMUTABLE STRICT;"
+  end
+
+  def json_selector_procedure
+"CREATE OR REPLACE FUNCTION json_selector(selector text, data json) RETURNS text AS $$
+  if (data == null || selector == null || selector == '') {
+    return null;
+  }
+  var names = selector.split('.');
+  var result = names.reduce(function(previousValue, currentValue, index, array) {
+    if (previousValue == null) {
+      return null;
+    } else {
+      return previousValue[currentValue];
+    }
+  }, data);
+  return result;
+$$ LANGUAGE plv8 IMMUTABLE STRICT;"    
+  end
+
+  def json_selectors_procedure
+"CREATE OR REPLACE FUNCTION json_selectors(selectors text, data json) RETURNS json AS $$
+  var json_selector = plv8.find_function('json_selector');
+  var selectorArray = selectors.replace(/\s+/g, '').split(',');
+  var result = selectorArray.map(function(selector) { return json_selector(selector, data); });
+  return result;
+$$ LANGUAGE plv8 IMMUTABLE STRICT;"
+  end
+
+  def show_all_indexes_procedure
+    "CREATE OR REPLACE FUNCTION show_all_indexes() RETURNS json AS $$
+      var sql = \"SELECT c3.relname AS table, c2.relname AS index FROM pg_class c2 LEFT JOIN pg_index i ON c2.oid = i.indexrelid LEFT JOIN pg_class c1 ON c1.oid = i.indrelid RIGHT OUTER JOIN pg_class c3 ON c3.oid = c1.oid LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c3.relnamespace WHERE c3.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c3.oid) ORDER BY c3.relpages DESC;\"
+      return plv8.execute( sql );
+    $$ LANGUAGE plv8 IMMUTABLE STRICT;"
+  end
+
+#   def show_indexes_procedure
+# "CREATE OR REPLACE FUNCTION show_indexes(table_name text DEFAULT '', index_prefix text DEFAULT '') RETURNS json AS $$
+#   var show_all_indexes = plv8.find_function('show_all_indexes');
+#   var indexes = show_all_indexes();
+#   if (0 < (table_name || '').length) {
+#     indexes = indexes.filter(function(row) { return row['table'] === table_name; });
+#   }
+#   if (0 < (index_prefix || '').length) {
+#     indexes = indexes.filter(function(row) { return row['index'].lastIndexOf(index_prefix, 0) === 0; });
+#   }
+#   return indexes;
+# $$ LANGUAGE plv8 IMMUTABLE STRICT;"
+#   end
+
+#   def ensure_dynamic_index_procedure
+#     raise ArgumentError, "index name should be: dyn_col_id_md5_hash_of_selector and truncated to a length of 63"
+#     raise ArgumentError, "it should only create 1 index and not multiple"
+
+
+#     # CREATE INDEX CONCURRENTLY post_json_documents_body_age ON post_json_documents(json_selector('age', body))
+# "CREATE OR REPLACE FUNCTION ensure_dynamic_index(selectors text, collection_id text) RETURNS json AS $$
+#   var show_indexes = plv8.find_function('show_indexes');
+#   var colId = collection_id.replace('-', '');
+#   var indexPrefix = 'col_' + colId + '_';
+#   var existingIndexes = show_indexes('post_json_documents', indexPrefix).map(function(row) { return row.index; });
+#   var selectorArray = selectors.replace(/\s+/g, '').split(',');
+
+#   var indexes = selectorArray.map(function(selector) { return {'name': indexPrefix + selector.replace('.', '_'), selector: selector}; });
+#   var newIndexes = indexes.filter(function(index) { return existingIndexes.indexOf(index.name) == -1; });
+
+#   newIndexes.forEach(function(index) {
+#     var sql = \"CREATE INDEX \" + index.name + \" ON post_json_documents(json_selector('\" + index.selector + \"', body)) WHERE collection_id = '\" + colId + \"';\"
+#     plv8.execute( sql );      
+#   });
+
+#   return newIndexes;
+# $$ LANGUAGE plv8 IMMUTABLE STRICT;"
+#   end
+end