sqlite-foreigner 0.5.0

data/README.textile

@@ -0,0 +1,126 @@
+h1. Sqlite Foreigner
+
+Sqlite Foreigner is a Rails foreign key migration helper which supports adding
+AND enforcing foreign key constraints on Sqlite3 databases.
+
+h2. The Story
+
+With a lack of support for easily adding foreign key constraints to sqlite databases
+I decided to create my own based on "Matt Higgins Foreigner":http://github.com/matthuhiggins/foreigner/
+
+h2. Some Examples
+
+Sqlite Foreigner allows you to do the following in your migration files
+<pre>
+  create_table :comments do |t|
+    t.references :posts, :foreign_key => true, :null => false
+  end
+</pre>
+Which will generate the following SQL:
+<pre>
+  CREATE TABLE "comments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "post_id" integer NOT NULL,
+  FOREIGN KEY ("post_id") REFERENCES "posts"(id));
+</pre>
+
+Go a different column name?
+<pre>
+  create_table :comments do |t|
+    t.references :article, :null => false
+    t.foreign_key :posts, :column => :article_id
+  end
+</pre>
+Which generates:
+<pre>
+  CREATE TABLE "comments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "article_id" integer NOT NULL,
+  FOREIGN KEY ("article_id") REFERENCES "posts"(id));
+</pre>
+
+Want to specify a dependency (nullify or delete)?
+<pre>
+  create_table :comments do |t|
+    t.references :posts, :foreign_key => {:dependent => :delete}, :null => false
+  end
+</pre>
+Generates:
+<pre>
+  CREATE TABLE "comments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "post_id" integer NOT NULL,
+  FOREIGN KEY ("post_id") REFERENCES "posts"(id) ON DELETE CASCADE);
+</pre>
+Or:
+<pre>
+  create_table :comments do |t|
+    t.references :article, :null => false
+    t.foreign_key :posts, :column => :article_id, :dependent => :nullify
+  end
+</pre>
+Which generates:
+<pre>
+  CREATE TABLE "comments" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "article_id" integer NOT NULL,
+  FOREIGN KEY ("article_id") REFERENCES "posts"(id) ON DELETE SET NULL);
+</pre>
+
+h2. Enforcing constraints
+
+SQLite does not enforce database constraints out of the box
+This provides you with the flexibility in choosing whether or not to enforce
+constraints at the DB level or not.
+
+In order to enforce your constraints:
+<pre>
+  script/dbconsole
+  .genfkey --exec
+</pre>
+
+While your in the console run:
+<pre>
+  .schema
+</pre>
+to see your constraints implemented as triggers
+
+h2. schema.rb
+
+All of the constrants are updated in schema.rb
+when you run:
+<pre>
+  rake db:migrate
+  rake db:schema:dump
+</pre>
+
+This allows you to see the state of your migratons and
+take advantage of using <pre>rake db:schema:load</pre>
+
+h2. Limitations
+
+Since SQLite does not have complete ALTER TABLE support
+you cannot use the following syntax:
+<pre>
+  add_foreign_key
+  remove_foreign_key
+</pre>
+
+Therefore you must add your foreign keys when you define your table,
+which may involve editing existing migration files instead of generating new ones
+
+h2. Installation
+
+Add the following to environment.rb:
+<pre>
+  config.gem "sqlite-foreigner", :lib => "foreigner", :source => "http://gemcutter.org"
+</pre>
+
+Then run:
+<pre>
+  sudo rake gems:install
+</pre>
+
+h2. See also
+
+Need support for other databases?
+Check out "dwilkie-foreigner":http://github.com/dwilkie/foreigner/tree/master
+
+Copyright (c) 2009 David Wilkie, released under the MIT license
+

data/lib/foreigner.rb

@@ -0,0 +1,22 @@
+require 'foreigner/connection_adapters/abstract/schema_definitions'
+require 'foreigner/connection_adapters/abstract/schema_statements'
+require 'foreigner/connection_adapters/sql_2003'
+require 'foreigner/schema_dumper'
+
+module ActiveRecord
+  module ConnectionAdapters
+    include Foreigner::ConnectionAdapters::SchemaStatements
+    include Foreigner::ConnectionAdapters::SchemaDefinitions
+  end
+
+  SchemaDumper.class_eval do
+    include Foreigner::SchemaDumper
+  end
+
+  Base.class_eval do
+    if connection_pool.spec.config[:adapter].downcase == "sqlite3"
+      require "foreigner/connection_adapters/sqlite3_adapter"
+    end
+  end
+end
+

data/lib/foreigner/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,84 @@
+module Foreigner
+  module ConnectionAdapters
+    class ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+    end
+
+    module SchemaDefinitions
+      def self.included(base)
+        base::TableDefinition.class_eval do
+          include Foreigner::ConnectionAdapters::TableDefinition
+        end
+      end
+    end
+
+    module TableDefinition
+      class ForeignKey < Struct.new(:base, :to_table, :options)
+        def to_sql
+          base.foreign_key_definition(to_table, options)
+        end
+        alias to_s :to_sql
+      end
+
+      def self.included(base)
+        base.class_eval do
+          include InstanceMethods
+          alias_method_chain :references, :foreign_keys
+          alias_method_chain :to_sql, :foreign_keys
+        end
+      end
+      module InstanceMethods
+        # Adds a :foreign_key option to TableDefinition.references.
+        # If :foreign_key is true, a foreign key constraint is added to the table.
+        # You can also specify a hash, which is passed as foreign key options.
+        #
+        # ===== Examples
+        # ====== Add goat_id column and a foreign key to the goats table.
+        #  t.references(:goat, :foreign_key => true)
+        # ====== Add goat_id column and a cascading foreign key to the goats table.
+        #  t.references(:goat, :foreign_key => {:dependent => :delete})
+        #
+        # Note: No foreign key is created if :polymorphic => true is used.
+        def references_with_foreign_keys(*args)
+          options = args.extract_options!
+          fk_options = options.delete(:foreign_key)
+
+          if fk_options && !options[:polymorphic]
+            fk_options = {} if fk_options == true
+            args.each { |to_table| foreign_key(to_table, fk_options) }
+          end
+
+          references_without_foreign_keys(*(args << options))
+        end
+
+        # Defines a foreign key for the table. +to_table+ can be a single Symbol, or
+        # an Array of Symbols.
+        #
+        # ===== Examples
+        # ====== Creating a simple foreign key
+        #  t.foreign_key(:people)
+        # ====== Defining the column
+        #  t.foreign_key(:people, :column => :sender_id)
+        # ====== Specify cascading foreign key
+        #  t.foreign_key(:people, :dependent => :delete)
+        def foreign_key(to_table, options = {})
+          if @base.supports_foreign_keys?
+            to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+            foreign_keys << ForeignKey.new(@base, to_table, options)
+          end
+        end
+
+        def to_sql_with_foreign_keys
+          sql = to_sql_without_foreign_keys
+          sql << ', ' << (foreign_keys * ', ') if foreign_keys.present?
+          sql
+        end
+
+        private
+          def foreign_keys
+            @foreign_keys ||= []
+          end
+      end
+    end
+  end
+end
+

data/lib/foreigner/connection_adapters/abstract/schema_statements.rb

@@ -0,0 +1,23 @@
+module Foreigner
+  module ConnectionAdapters
+    module SchemaStatements
+      def self.included(base)
+        base::AbstractAdapter.class_eval do
+          include Foreigner::ConnectionAdapters::AbstractAdapter
+        end
+      end
+    end
+
+    module AbstractAdapter
+      def supports_foreign_keys?
+        false
+      end
+
+      # Return the foreign keys for the schema_dumper
+      def foreign_keys(table_name)
+        []
+      end
+    end
+  end
+end
+

data/lib/foreigner/connection_adapters/sql_2003.rb

@@ -0,0 +1,28 @@
+module Foreigner
+  module ConnectionAdapters
+    module Sql2003
+      def supports_foreign_keys?
+        true
+      end
+
+      def foreign_key_definition(to_table, options = {})
+        column  = options[:column] || "#{to_table.to_s.singularize}_id"
+        dependency = dependency_sql(options[:dependent])
+
+        sql = "FOREIGN KEY (#{quote_column_name(column)}) REFERENCES #{quote_table_name(to_table)}(id)"
+        sql << " #{dependency}" unless dependency.blank?
+        sql
+      end
+
+      private
+        def dependency_sql(dependency)
+          case dependency
+            when :nullify then "ON DELETE SET NULL"
+            when :delete  then "ON DELETE CASCADE"
+            else ""
+          end
+        end
+    end
+  end
+end
+

data/lib/foreigner/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,46 @@
+require 'foreigner/connection_adapters/sql_2003'
+
+module Foreigner
+  module ConnectionAdapters
+    module SQLite3Adapter
+      include Foreigner::ConnectionAdapters::Sql2003
+
+      def foreign_keys(table_name)
+        foreign_keys = []
+        create_table_info = select_value %{
+SELECT sql
+FROM sqlite_master
+WHERE sql LIKE '%FOREIGN KEY%'
+AND name = '#{table_name}'
+}
+      unless create_table_info.nil?
+        fk_columns = create_table_info.scan(/FOREIGN KEY\s*\(\"([^\"]+)\"\)/)
+        fk_tables = create_table_info.scan(/REFERENCES\s*\"([^\"]+)\"/)
+        fk_references = create_table_info.scan(/REFERENCES[^\,]+/)
+        if fk_columns.size == fk_tables.size && fk_references.size == fk_columns.size
+          fk_columns.each_with_index do |fk_column, index|
+            if fk_references[index] =~ /ON DELETE CASCADE/
+              fk_references[index] = :delete
+            elsif fk_references[index] =~ /ON DELETE SET NULL/
+              fk_references[index] = :nullify
+            else
+              fk_references[index] = nil
+            end
+            foreign_keys << ForeignKeyDefinition.new(table_name, fk_tables[index][0], :column => fk_column[0], :dependent => fk_references[index])
+          end
+        end
+      end
+      foreign_keys
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    SQLite3Adapter.class_eval do
+      include Foreigner::ConnectionAdapters::SQLite3Adapter
+    end
+  end
+end
+

data/lib/foreigner/schema_dumper.rb

@@ -0,0 +1,122 @@
+module Foreigner
+  module SchemaDumper
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        alias_method_chain :table,  :foreign_keys
+      end
+    end
+
+    module InstanceMethods
+
+      def table_with_foreign_keys(table, stream)
+        if @connection.class == ActiveRecord::ConnectionAdapters::SQLite3Adapter
+          foreign_key_table(table, stream)
+        else
+          table_without_foreign_keys(table, stream)
+        end
+      end
+
+      private
+        # This is almost direct copy from
+        # active_record/schema.dumper with the add_foreign_keys method
+        # inserted into the middle
+        def foreign_key_table(table, stream)
+          columns = @connection.columns(table)
+          begin
+            tbl = StringIO.new
+
+            # first dump primary key column
+            if @connection.respond_to?(:pk_and_sequence_for)
+              pk, pk_seq = @connection.pk_and_sequence_for(table)
+            elsif @connection.respond_to?(:primary_key)
+              pk = @connection.primary_key(table)
+            end
+            pk ||= 'id'
+
+            tbl.print "  create_table #{table.inspect}"
+            if columns.detect { |c| c.name == pk }
+              if pk != 'id'
+                tbl.print %Q(, :primary_key => "#{pk}")
+              end
+            else
+              tbl.print ", :id => false"
+            end
+            tbl.print ", :force => true"
+            tbl.puts " do |t|"
+
+            # then dump all non-primary key columns
+            column_specs = columns.map do |column|
+              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+              next if column.name == pk
+              spec = {}
+              spec[:name]      = column.name.inspect
+              spec[:type]      = column.type.to_s
+              spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+              spec[:precision] = column.precision.inspect if !column.precision.nil?
+              spec[:scale]     = column.scale.inspect if !column.scale.nil?
+              spec[:null]      = 'false' if !column.null
+              spec[:default]   = default_string(column.default) if column.has_default?
+              (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+              spec
+            end.compact
+
+            # find all migration keys used in this table
+            keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+
+            # figure out the lengths for each column based on above keys
+            lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+            # the string we're going to sprintf our values against, with standardized column widths
+            format_string = lengths.map{ |len| "%-#{len}s" }
+
+            # find the max length for the 'type' column, which is special
+            type_length = column_specs.map{ |column| column[:type].length }.max
+
+            # add column type definition to our format string
+            format_string.unshift "    t.%-#{type_length}s "
+
+            format_string *= ''
+
+            column_specs.each do |colspec|
+              values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+              values.unshift colspec[:type]
+              tbl.print((format_string % values).gsub(/,\s*$/, ''))
+              tbl.puts
+            end
+
+            # add the foreign keys
+            add_foreign_keys(table, tbl)
+
+            tbl.puts "  end"
+            tbl.puts
+
+            indexes(table, tbl)
+
+            tbl.rewind
+            stream.print tbl.read
+          rescue => e
+            stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
+
+          stream
+        end
+
+        def add_foreign_keys(table_name, stream)
+          if (foreign_keys = @connection.foreign_keys(table_name)).any?
+            add_foreign_key_statements = foreign_keys.map do |foreign_key|
+              statement_parts = ["  t.foreign_key " + foreign_key.to_table.inspect]
+              statement_parts << (':column => ' + foreign_key.options[:column].inspect)
+              statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
+              '  ' + statement_parts.join(', ')
+            end
+
+            stream.puts add_foreign_key_statements.sort.join("\n")
+          end
+        end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: sqlite-foreigner
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- David Wilkie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-01 00:00:00 +07:00
+default_executable: 
+dependencies: []
+
+description: Enforcable foreign key constraints for Rails migrations and SQLite databases
+email: dwilkie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- lib/foreigner.rb
+- lib/foreigner/schema_dumper.rb
+- lib/foreigner/connection_adapters/sql_2003.rb
+- lib/foreigner/connection_adapters/sqlite3_adapter.rb
+- lib/foreigner/connection_adapters/abstract/schema_definitions.rb
+- lib/foreigner/connection_adapters/abstract/schema_statements.rb
+has_rdoc: true
+homepage: http://github.com/dwilkie/sqlite3-foreigner/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --main
+- README.textile
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 1
+summary: Enforcable foreign key constraints for Rails migrations and SQLite databases
+test_files: []
+