partitionable 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45ffa6ac52a4391ae901589f8ee0b341b85760d1
+  data.tar.gz: b6d738345cb33c37c6d425ba8042bf24a76b91d0
+SHA512:
+  metadata.gz: 24ad2fe29382796d7052deee0406373bd988b5f5a5e77fd6855beb95859ef746815130e4bd01751846613b21f5c2908c5207154ed90067352d68945cb6dd33b1
+  data.tar.gz: 31c56321fc983331220e08fb8f00f9774db0606c453bc1c3a2bcd88694e492b0afd2fe1ef433804f1056671baab844eb7163b971fe142f44153b6eeaad7d734e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Pablo Acuña
+
+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,68 @@
+[![Build Status](https://travis-ci.org/pacuna/partitionable.svg?branch=master)](https://travis-ci.org/pacuna/partitionable)
+
+# Partitionable
+
+This gem adds support for using the PostgreSQL partitioning mechanism
+describe [here](https://www.postgresql.org/docs/9.1/static/ddl-partitioning.html).
+
+## Usage
+
+Partitionable assumes the model you want to partition has a date attribute which will be
+used for checking the partitions constraints and triggers.
+
+### Example
+
+Let's say you have a model named `ArticleStat` and its respective table named `article_stats`.
+Suppose this model also has a `logdate` attribute of type date. We want to partition
+the data by year and month using this attribute.
+
+Add the `acts_as_partitionable` module and method to the model. The `index_fields` and `logdate_attr` are mandatory
+options. The first one adds an index for those attributes when creating the partitions and the latter
+is the date attribute used for routing the records to the correct partitions:
+
+```ruby
+class ArticleStat < ApplicationRecord
+  include Partitionable::ActsAsPartitionable
+
+  acts_as_partitionable index_fields: ['id', 'site'], logdate_attr: 'logdate'
+end
+```
+
+And that's it. Now every time you create a new record, the gem will create
+the correspondent partition table if doesn't exists. It also will update the trigger
+function so every other new record that should go into this partition gets correctly
+routed.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "partitionable", '~> 0.1.0'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Tests
+
+First, create the database for the dummy embedded application:
+
+```bash
+cd test/dummy
+bin/rails db:setup
+cd ../..
+```
+Then you can run the tests with:
+
+```bash
+bin/test
+```
+
+## Contributing
+
+PR
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+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    = 'Partitionable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/partitionable.rb

@@ -0,0 +1,5 @@
+require 'partitionable/acts_as_partitionable'
+
+module Partitionable
+  # Your code goes here...
+end

data/lib/partitionable/acts_as_partitionable.rb

@@ -0,0 +1,141 @@
+module Partitionable
+  module ActsAsPartitionable
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :create_partition_from_record
+    end
+
+    module ClassMethods
+      def acts_as_partitionable(options = {})
+        cattr_accessor :index_fields
+        cattr_accessor :logdate_attr
+        self.index_fields = options[:index_fields]
+        self.logdate_attr = options[:logdate_attr]
+
+        def partition_name(month, year)
+          formatted_month = sprintf('%02d', month.to_i)
+          "#{self.table_name}_y#{year}m#{formatted_month}"
+        end
+
+        def create_partition(month, year)
+          ActiveRecord::Base.connection.execute create_table_statement(month, year)
+        end
+
+        def create_table_statement(month, year)
+          table = partition_name(month, year)
+          index_name = "#{table}_#{index_fields.join('_')}"
+          first_day_of_month = Date.civil(year, month, 1)
+          first_day_next_month = (first_day_of_month + 1.month)
+          <<-SQL
+          CREATE TABLE #{table} (
+              CHECK ( #{self.logdate_attr} >= DATE '#{first_day_of_month.to_s}' AND #{self.logdate_attr} < DATE '#{first_day_next_month.to_s}' )
+          ) INHERITS (#{self.table_name});
+          CREATE INDEX #{index_name} ON #{table} (#{index_fields.join(',')});
+          SQL
+        end
+
+        def drop_partition(month, year)
+          name = partition_name(month, year)
+          index_name = "#{name}_#{index_fields.join('_')}"
+          function_name = "#{name}_insert_trigger_function()"
+          trigger_name = "#{name}_trigger"
+          ActiveRecord::Base.connection.execute(
+            <<-SQL
+          DROP TABLE IF EXISTS #{name};
+          DROP INDEX IF EXISTS #{index_name};
+          DROP FUNCTION IF EXISTS #{function_name} CASCADE;
+          DROP TRIGGER IF EXISTS #{trigger_name} ON #{self.table_name} CASCADE;
+            SQL
+          )
+        end
+
+        def trigger_statement months_and_years
+          trigger_body = get_trigger_body(months_and_years)
+          statement = ""
+          statement += <<-SQL
+          CREATE OR REPLACE FUNCTION #{self.table_name}_insert_trigger()
+          RETURNS TRIGGER AS $$
+          SQL
+
+          statement += trigger_body
+          statement += <<-SQL
+          $$
+          LANGUAGE plpgsql;
+
+          DROP TRIGGER IF EXISTS insert_#{self.table_name}_trigger ON #{self.table_name};
+          CREATE TRIGGER insert_#{self.table_name}_trigger
+              BEFORE INSERT ON #{self.table_name}
+              FOR EACH ROW EXECUTE PROCEDURE #{self.table_name}_insert_trigger();
+          SQL
+          statement
+        end
+
+        def get_trigger_body months_and_years
+
+          statement = ""
+          statement += <<-eos
+          BEGIN
+          eos
+
+          months_and_years.each_with_index do |data, index|
+
+            first_day_of_month = Date.civil(data[1].to_i, data[0].to_i, 1)
+            first_day_next_month = (first_day_of_month + 1.month)
+            if index == 0
+              statement += <<-eos
+              IF ( NEW.#{self.logdate_attr} >= DATE '#{first_day_of_month}' AND
+                   NEW.#{self.logdate_attr} < DATE '#{first_day_next_month}' ) THEN
+                  INSERT INTO #{partition_name(data[0], data[1])} VALUES (NEW.*);
+              eos
+            else
+              statement += <<-eos
+              ELSIF ( NEW.#{self.logdate_attr} >= DATE '#{first_day_of_month}' AND
+                   NEW.#{self.logdate_attr} < DATE '#{first_day_next_month}' ) THEN
+                  INSERT INTO #{partition_name(data[0], data[1])} VALUES (NEW.*);
+              eos
+            end
+          end
+          statement += <<-eos
+              END IF;
+              RETURN NULL;
+          END;
+          eos
+        end
+
+        def partition_exists?(month, year)
+          ActiveRecord::Base.connection.data_source_exists? partition_name(month, year)
+        end
+
+        def update_trigger
+          ActiveRecord::Base.connection.execute updated_trigger_statement
+        end
+
+        def updated_trigger_statement
+          tables = ActiveRecord::Base.connection.tables.select{|t| t =~ /#{self.table_name}_y[0-9]{4}m[0-9]{2}/}
+          months_and_years = tables.map {|t| [t.match(/m\K[0-9]{2}/)[0], t.match(/y\K[0-9]{4}/)[0]]}
+          trigger_statement months_and_years.sort_by{|month, year| [year.to_i, month.to_i]}
+        end
+
+        include Partitionable::ActsAsPartitionable::LocalInstanceMethods
+      end
+    end
+
+    module LocalInstanceMethods
+      def has_partition?
+        month = self.send(self.class.logdate_attr.to_sym).month
+        year = self.send(self.class.logdate_attr.to_sym).year
+        self.class.partition_exists? month,year
+      end
+
+      def create_partition_from_record
+        return if has_partition?
+
+        month = self.send(self.class.logdate_attr.to_sym).month
+        year = self.send(self.class.logdate_attr.to_sym).year
+        self.class.create_partition(month,year)
+        self.class.update_trigger
+      end
+    end
+  end
+end

data/lib/partitionable/version.rb

@@ -0,0 +1,3 @@
+module Partitionable
+  VERSION = '0.2.0'
+end

data/lib/tasks/partitionable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :partitionable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: partitionable
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Pablo Acuña
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- pabloacuna88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/partitionable.rb
+- lib/partitionable/acts_as_partitionable.rb
+- lib/partitionable/version.rb
+- lib/tasks/partitionable_tasks.rake
+homepage: http://www.archdaily.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Seamless PostgreSQL date partitioning for your Rails models.
+test_files: []