pg_sequencer 0.0.2

data/README.rdoc

@@ -0,0 +1,96 @@
+= pg_sequencer
+
+pg_sequencer adds methods to your migrations to allow you to create, drop and change sequence objects in PostgreSQL. It also dumps sequences to schema.rb.
+
+This is especially useful if you are connecting to a legacy database where the primary key field is declared as an INTEGER and a sequence is queried for the value of the next record.
+
+The design of pg_sequencer is heavily influenced on Matthew Higgins' Foreigner gem:
+* https://github.com/matthuhiggins/foreigner
+
+== Installation
+
+Add this to your Gemfile:
+
+  gem 'pg_sequencer'
+  
+== API
+
+pg_sequencer adds the following methods to migrations:
+
+* create_sequence(sequence_name, options)
+* change_sequence(sequence_name, options)
+* drop_sequence(sequence_name)
+
+The methods closely mimic the syntax of the PostgreSQL SQL for CREATE SEQUENCE, DROP SEQUENCE and ALTER SEQUENCE. See the REFERENCES section below for more information.
+
+== Options
+
+For create_sequence and change_sequence, all options are the same, except create_sequence will look for :start or :start_with, and 
+change_sequence will look for :restart or :restart_with.
+
+* :increment/:increment_by (integer) - The value to increment the sequence by.
+* :min (integer/false) - The minimum value of the sequence. If specified as false (e.g. :min => false), "NO MINVALUE" is sent to Postgres.
+* :max (integer/false) - The maximum value of the sequence. May be specified as ":max => false" to generate "NO MAXVALUE"
+* :start/:start_with (integer) - The starting value of the sequence (create_sequence only)
+* :restart/:restart_with (integer) The value to restart the sequence with (change_sequence only)
+* :cache (integer) - The number of values the sequence should cache.
+* :cycle (boolean) - Whether the sequence should cycle. Generated at "CYCLE" or "NO CYCLE"
+
+== Examples
+
+=== Creating a sequence
+
+Create a sequence called "seq_user", incrementing by 1, min of 1, max of 2000000, starts at 1, caches 10 values, and disallows cycles:
+
+  create_sequence("seq_user", {
+    :increment => 1,
+    :min => 1,
+    :max => 2000000,
+    :start => 1,
+    :cache => 10,
+    :cycle => false
+  })
+  
+This is equivalent of the following query:
+
+  CREATE SEQUENCE seq_user INCREMENT BY 1 MIN 1 MAX 2000000 START 1 CACHE 10 NO CYCLE
+
+=== Reset a sequence's value:
+
+  change_sequence "seq_accounts", :restart_with => 50
+
+This is equivalent to:
+  
+  ALTER SEQUENCE seq_accounts RESTART WITH 50
+  
+=== Removing a sequence:
+
+  drop_sequence "seq_products"
+
+== Caveats / Bugs
+* Tested with postgres 9.0.4, should work down to 8.1.
+* Listing all the sequences in a database creates n+1 queries (1 to get the names and n to describe each sequence). Is there a way to fully describe all sequences in a database in one query?
+* The "SET SCHEMA" fragment of the ALTER command is not implemented.
+* Oracle/other databases not supported
+* Other unknown bugs :)
+  
+== References
+* http://www.postgresql.org/docs/8.1/static/sql-createsequence.html
+* http://www.postgresql.org/docs/8.1/static/sql-altersequence.html
+* http://www.alberton.info/postgresql_meta_info.html
+
+== License
+
+Copyright (c) 2011 Code 42 Software.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+# begin
+#   require 'bundler/setup'
+# rescue LoadError
+#   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+# end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+require 'rake/testtask'
+desc 'Test the foreigner plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/pg_sequencer.rb

@@ -0,0 +1,11 @@
+require 'active_support/all'
+
+module PgSequencer
+  extend ActiveSupport::Autoload
+  autoload :SchemaDumper
+  
+  module ConnectionAdapters
+  end
+end
+
+require 'pg_sequencer/railtie' if defined?(Rails)

data/lib/pg_sequencer/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,146 @@
+module PgSequencer
+  module ConnectionAdapters
+    
+    class SequenceDefinition < Struct.new(:name, :options)
+    end
+    
+    module PostgreSQLAdapter
+      def create_sequence(name, options = {})
+        execute create_sequence_sql(name, options)
+      end
+      
+      def drop_sequence(name)
+        execute drop_sequence_sql(name)
+      end
+      
+      def change_sequence(name, options = {})
+        execute change_sequence_sql(name, options)
+      end
+      
+      # CREATE [ TEMPORARY | TEMP ] SEQUENCE name [ INCREMENT [ BY ] increment ]
+      #     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+      #     [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
+      #
+      # create_sequence "seq_user",
+      #   :increment => 1,
+      #   :min       => (1|false),
+      #   :max       => (20000|false),
+      #   :start     => 1,
+      #   :cache     => 5,
+      #   :cycle     => true
+      def create_sequence_sql(name, options = {})
+        options.delete(:restart)
+        "CREATE SEQUENCE #{name}#{sequence_options_sql(options)}"
+      end
+      
+      def drop_sequence_sql(name)
+        "DROP SEQUENCE #{name}"
+      end
+      
+      def change_sequence_sql(name, options = {})
+        return "" if options.blank?
+        options.delete(:start)
+        "ALTER SEQUENCE #{name}#{sequence_options_sql(options)}"
+      end
+      
+      def sequence_options_sql(options = {})
+        sql = ""
+        sql << increment_option_sql(options)  if options[:increment] or options[:increment_by]
+        sql << min_option_sql(options)
+        sql << max_option_sql(options)
+        sql << start_option_sql(options)      if options[:start]    or options[:start_with]
+        sql << restart_option_sql(options)    if options[:restart]  or options[:restart_with]
+        sql << cache_option_sql(options)      if options[:cache]
+        sql << cycle_option_sql(options)
+        sql
+      end
+      
+      def sequences
+        # sequence_temp=# select * from temp;
+        # -[ RECORD 1 ]-+--------------------
+        # sequence_name | temp
+        # last_value    | 7
+        # start_value   | 1
+        # increment_by  | 1
+        # max_value     | 9223372036854775807
+        # min_value     | 1
+        # cache_value   | 1
+        # log_cnt       | 26
+        # is_cycled     | f
+        # is_called     | t
+        sequence_names = select_all("SELECT c.relname FROM pg_class c WHERE c.relkind = 'S' order by c.relname asc").map { |row| row['relname'] }
+        
+        all_sequences = []
+        
+        sequence_names.each do |sequence_name|
+          row = select_one("SELECT * FROM #{sequence_name}")
+          
+          options = {
+            :increment => row['increment_by'].to_i,
+            :min       => row['min_value'].to_i,
+            :max       => row['max_value'].to_i,
+            :start     => row['start_value'].to_i,
+            :cache     => row['cache_value'].to_i,
+            :cycle     => row['is_cycled'] == 't'
+          }
+          
+          all_sequences << SequenceDefinition.new(sequence_name, options)
+        end
+        
+        all_sequences
+      end
+      
+      protected
+      def increment_option_sql(options = {})
+        " INCREMENT BY #{options[:increment] || options[:increment_by]}"
+      end
+      
+      def min_option_sql(options = {})
+        case options[:min]
+        when nil then ""
+        when false then " NO MINVALUE"
+        else " MINVALUE #{options[:min]}"
+        end
+      end
+      
+      def max_option_sql(options = {})
+        case options[:max]
+        when nil then ""
+        when false then " NO MAXVALUE"
+        else " MAXVALUE #{options[:max]}"
+        end
+      end
+      
+      def restart_option_sql(options = {})
+        " RESTART WITH #{options[:restart] || options[:restart_with]}"
+      end
+      
+      def start_option_sql(options = {})
+        " START WITH #{options[:start] || options[:start_with]}"
+      end
+      
+      def cache_option_sql(options = {})
+        " CACHE #{options[:cache]}"
+      end
+      
+      def cycle_option_sql(options = {})
+        case options[:cycle]
+        when nil then ""
+        when false then " NO CYCLE"
+        else " CYCLE"
+        end
+      end
+      
+    end
+  end
+end
+
+# todo: add JDBCAdapter?
+[:PostgreSQLAdapter].each do |adapter|
+  begin
+    ActiveRecord::ConnectionAdapters.const_get(adapter).class_eval do
+      include PgSequencer::ConnectionAdapters::PostgreSQLAdapter
+    end
+  rescue
+  end
+end

data/lib/pg_sequencer/railtie.rb

@@ -0,0 +1,28 @@
+module PgSequencer
+  class Railtie < Rails::Railtie
+    initializer "pg_sequencer.load_adapter" do
+      ActiveSupport.on_load :active_record do
+        require 'pg_sequencer/connection_adapters/postgresql_adapter'
+        
+        ActiveRecord::ConnectionAdapters.module_eval do
+          include PgSequencer::ConnectionAdapters::PostgreSQLAdapter
+        end
+      
+        ActiveRecord::SchemaDumper.class_eval do
+          include PgSequencer::SchemaDumper
+        end
+        
+      end
+
+  #     if defined?(ActiveRecord::Migration::CommandRecorder)
+  #       ActiveRecord::Migration::CommandRecorder.class_eval do
+  #         include PgSequencer::Migration::CommandRecorder
+  #       end
+  #     end
+  # 
+  #     # PgSequencer::Adapter.load!
+  #   end
+  
+    end # initializer
+  end
+end

data/lib/pg_sequencer/schema_dumper.rb

@@ -0,0 +1,32 @@
+module PgSequencer
+  module SchemaDumper
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :tables, :sequences
+    end
+    
+    def tables_with_sequences(stream)
+      tables_without_sequences(stream)
+      sequences(stream)
+    end
+    
+    private
+    def sequences(stream)
+      sequence_statements = @connection.sequences.map do |sequence|
+        statement_parts = [ ('create_sequence ') + sequence.name.inspect ]
+        statement_parts << (':increment => ' + sequence.options[:increment].inspect)
+        statement_parts << (':min => ' + sequence.options[:min].inspect)
+        statement_parts << (':max => ' + sequence.options[:max].inspect)
+        statement_parts << (':start => ' + sequence.options[:start].inspect)
+        statement_parts << (':cache => ' + sequence.options[:cache].inspect)
+        statement_parts << (':cycle => ' + sequence.options[:cycle].inspect)
+        
+        '  ' + statement_parts.join(', ')
+      end
+      
+      stream.puts sequence_statements.sort.join("\n")
+      stream.puts
+    end
+  end
+end

data/lib/pg_sequencer/version.rb

@@ -0,0 +1,3 @@
+module PgSequencer
+  VERSION = "0.0.2"
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'shoulda-context'
+require File.expand_path('../../lib/pg_sequencer', __FILE__)

data/test/unit/postgresql_adapter_test.rb

@@ -0,0 +1,138 @@
+require 'helper'
+require 'pg_sequencer/connection_adapters/postgresql_adapter'
+
+class PostgreSQLAdapterTest < ActiveSupport::TestCase
+  include PgSequencer::ConnectionAdapters::PostgreSQLAdapter
+  
+  setup do
+    @options = {
+      :increment => 1,
+      :min       => 1,
+      :max       => 2_000_000,
+      :cache     => 5,
+      :cycle     => true
+    }
+  end
+  
+  context "generating sequence option SQL" do
+    context "for :increment" do
+      should "include 'INCREMENT BY' in the SQL" do
+        assert_equal(" INCREMENT BY 1", sequence_options_sql(:increment => 1))
+        assert_equal(" INCREMENT BY 2", sequence_options_sql(:increment => 2))
+      end
+      
+      should "not include the option if nil value specified" do
+        assert_equal("", sequence_options_sql(:increment => nil))
+      end
+    end
+    
+    context "for :min" do
+      should "include 'MINVALUE' in the SQL if specified" do
+        assert_equal(" MINVALUE 1", sequence_options_sql(:min => 1))
+        assert_equal(" MINVALUE 2", sequence_options_sql(:min => 2))
+      end
+      
+      should "not include 'MINVALUE' in SQL if set to nil" do
+        assert_equal("", sequence_options_sql(:min => nil))
+      end
+      
+      should "set 'NO MINVALUE' if :min specified as false" do
+        assert_equal(" NO MINVALUE", sequence_options_sql(:min => false))
+      end
+    end
+    
+    context "for :max" do
+      should "include 'MAXVALUE' in the SQL if specified" do
+        assert_equal(" MAXVALUE 1", sequence_options_sql(:max => 1))
+        assert_equal(" MAXVALUE 2", sequence_options_sql(:max => 2))
+      end
+      
+      should "not include 'MAXVALUE' in SQL if set to nil" do
+        assert_equal("", sequence_options_sql(:max => nil))
+      end
+      
+      should "set 'NO MAXVALUE' if :min specified as false" do
+        assert_equal(" NO MAXVALUE", sequence_options_sql(:max => false))
+      end
+    end
+    
+    context "for :start" do
+      should "include 'START WITH' in SQL if specified" do
+        assert_equal(" START WITH 1", sequence_options_sql(:start => 1))
+        assert_equal(" START WITH 2", sequence_options_sql(:start => 2))
+        assert_equal(" START WITH 500", sequence_options_sql(:start => 500))
+      end
+      
+      should "not include 'START WITH' in SQL if specified as nil" do
+        assert_equal("", sequence_options_sql(:start => nil))
+      end
+    end
+    
+    context "for :cache" do
+      should "include 'CACHE' in SQL if specified" do
+        assert_equal(" CACHE 1", sequence_options_sql(:cache => 1))
+        assert_equal(" CACHE 2", sequence_options_sql(:cache => 2))
+        assert_equal(" CACHE 500", sequence_options_sql(:cache => 500))
+      end
+    end
+    
+    context "for :cycle" do
+      should "include 'CYCLE' option if specified" do
+        assert_equal(" CYCLE", sequence_options_sql(:cycle => true))
+      end
+      
+      should "include 'NO CYCLE' option if set as false" do
+        assert_equal(" NO CYCLE", sequence_options_sql(:cycle => false))
+      end
+      
+      should "not include 'CYCLE' statement if specified as nil" do
+        assert_equal("", sequence_options_sql(:cycle => nil))
+      end
+    end
+
+    should "include all options" do
+      assert_equal " INCREMENT BY 1 MINVALUE 1 MAXVALUE 2000000 START WITH 1 CACHE 5 CYCLE", sequence_options_sql(@options.merge(:start => 1))
+    end
+  end # generating sequence option SQL
+  
+  context "creating sequences" do
+    context "without options" do
+      should "generate the proper SQL" do
+        assert_equal("CREATE SEQUENCE things", create_sequence_sql('things'))
+        assert_equal("CREATE SEQUENCE blahs", create_sequence_sql('blahs'))
+      end
+    end
+    
+    context "with options" do
+      should "include options at the end" do
+        assert_equal("CREATE SEQUENCE things INCREMENT BY 1 MINVALUE 1 MAXVALUE 2000000 START WITH 1 CACHE 5 CYCLE", create_sequence_sql('things', @options.merge(:start => 1)))
+      end
+    end
+  end # creating sequences
+  
+  context "altering sequences" do
+    context "without options" do
+      should "return a blank SQL statement" do
+        assert_equal("", change_sequence_sql('things'))
+        assert_equal("", change_sequence_sql('things', {}))
+        assert_equal("", change_sequence_sql('things', nil))
+      end
+    end
+    
+    context "with options" do
+      
+      should "include options at the end" do
+        assert_equal("ALTER SEQUENCE things INCREMENT BY 1 MINVALUE 1 MAXVALUE 2000000 RESTART WITH 1 CACHE 5 CYCLE", change_sequence_sql('things', @options.merge(:restart => 1)))
+      end
+    end
+    
+  end # altering sequences
+  
+  context "dropping sequences" do
+    should "generate the proper SQL" do
+      assert_equal("DROP SEQUENCE seq_users", drop_sequence_sql('seq_users'))
+      assert_equal("DROP SEQUENCE seq_items", drop_sequence_sql('seq_items'))
+    end
+  end # dropping sequences
+  
+end

data/test/unit/schema_dumper_test.rb

@@ -0,0 +1,111 @@
+require 'helper'
+
+class SchemaDumperTest < ActiveSupport::TestCase
+  
+  class SequenceDefinition < Struct.new(:name, :options); end
+  
+  class MockConnection
+    attr_accessor :sequences
+    
+    def initialize(sequences = [])
+      @sequences = sequences
+    end
+    
+  end
+  
+  class MockStream
+    attr_accessor :output
+    def initialize; @output = []; end
+    def puts(str = ""); @output << str; end
+    def to_s; @output.join("\n"); end
+  end
+  
+  class MockSchemaDumper
+    def initialize(connection)
+      @connection = connection
+    end
+    
+    def self.dump(conn, stream)
+      new(conn).dump(stream)
+    end
+    
+    def header(stream)
+      stream.puts '# Fake Schema Header'
+    end
+    
+    def tables(stream)
+      stream.puts '# (No Tables)'
+    end
+    
+    def dump(stream)
+      header(stream)
+      tables(stream)
+      trailer(stream)
+      stream
+    end
+    
+    def trailer(stream)
+      stream.puts '# Fake Schema Trailer'
+    end
+    
+    include PgSequencer::SchemaDumper
+  end
+  
+  context "dumping the schema" do
+    setup do
+      @options = {
+        :increment => 1,
+        :min       => 1,
+        :max       => 2_000_000,
+        :start     => 1,
+        :cache     => 5,
+        :cycle     => true
+      }
+
+      @stream = MockStream.new
+    end
+
+    should "output all sequences correctly" do
+      sequences = ['seq_t_user', 'seq_t_item'].map do |name|
+        SequenceDefinition.new(name, @options)
+      end
+
+      @conn = MockConnection.new(sequences)
+      
+      expected_output = <<-SCHEMAEND
+# Fake Schema Header
+# (No Tables)
+  create_sequence "seq_t_item", :increment => 1, :min => 1, :max => 2000000, :start => 1, :cache => 5, :cycle => true
+  create_sequence "seq_t_user", :increment => 1, :min => 1, :max => 2000000, :start => 1, :cache => 5, :cycle => true
+
+# Fake Schema Trailer
+SCHEMAEND
+
+      MockSchemaDumper.dump(@conn, @stream)
+      assert_equal(expected_output.strip, @stream.to_s)
+    end
+
+    context "when min specified as false" do
+      setup do
+        sequences = ['seq_t_user', 'seq_t_item'].map do |name|
+          SequenceDefinition.new(name, @options.merge(:min => false))
+        end
+        @conn = MockConnection.new(sequences)
+      end
+
+      should "properly quote false values in schema output" do
+        expected_output = <<-SCHEMAEND
+# Fake Schema Header
+# (No Tables)
+  create_sequence "seq_t_item", :increment => 1, :min => false, :max => 2000000, :start => 1, :cache => 5, :cycle => true
+  create_sequence "seq_t_user", :increment => 1, :min => false, :max => 2000000, :start => 1, :cache => 5, :cycle => true
+
+# Fake Schema Trailer
+SCHEMAEND
+
+        MockSchemaDumper.dump(@conn, @stream)
+        assert_equal(expected_output.strip, @stream.to_s)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: pg_sequencer
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Tony Collen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70303200278560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70303200278560
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70303200278060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *70303200278060
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &70303200310860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :development
+  prerelease: false
+  version_requirements: *70303200310860
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &70303200310480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70303200310480
+- !ruby/object:Gem::Dependency
+  name: guard-test
+  requirement: &70303200310020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70303200310020
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: &70303200309600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70303200309600
+description: Sequences need some love. pg_sequencer teaches Rails what sequences are,
+  and will dump them to schema.rb, and also lets you create/drop sequences in migrations.
+email:
+- tonyc@code42.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pg_sequencer/connection_adapters/postgresql_adapter.rb
+- lib/pg_sequencer/railtie.rb
+- lib/pg_sequencer/schema_dumper.rb
+- lib/pg_sequencer/version.rb
+- lib/pg_sequencer.rb
+- Rakefile
+- README.rdoc
+- test/helper.rb
+- test/unit/postgresql_adapter_test.rb
+- test/unit/schema_dumper_test.rb
+homepage: https://github.com/code42/pg_sequencer/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Manage postgres sequences in Rails migrations
+test_files:
+- test/helper.rb
+- test/unit/postgresql_adapter_test.rb
+- test/unit/schema_dumper_test.rb