robdimarco_rails_sql_views 0.9.0

data/CHANGELOG

@@ -0,0 +1,22 @@
+0.1.0 - Released Dec 27, 2006
+ * Initial release
+
+0.5.0 - Released Dec 29, 2006
+ * Added support for PostgreSQL (Michael Schuerig)
+ * Fixed the schema dumper
+ 
+0.5.1 - Released Jan 10, 2007
+ * Patch by Clifford T. Matthews to use String.dump to dump out the view select statement
+ 
+0.6.0 - Released May 9, 2007
+ * Added support for SQL Server (Seth Ladd)-
+ * Added support for using views to map non-friendly database field names to AR-friendly names (Nathan Vack)
+ * Added support for Oracle (Alistair Davidson)
+
+0.6.1 - Released June 6, 2007
+ * Added test for union support
+ * Updated tests to include new table to support union test
+
+0.7.0
+ * Updated dependency versions to get on ActiveRecord 2.x. May not be compatible with Rails versions less than 2.x.
+ * Add nonview_tables support to *all* of the adapters (was missing from Postgres and SQLServer)

data/CONTRIB

@@ -0,0 +1,8 @@
+The following people have kindly contributed to improve Rails SQL Views:
+
+  Anthony Eden
+  Michael Schuerig
+  Clifford T. Matthews
+  Seth Ladd
+  
+So if you see them in the halls of your local Ruby or Rails gatherings please remember to say Hi and Thanks. ;-)

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006-2008 Anthony Eden
+
+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

@@ -0,0 +1,51 @@
+== Rails SQL Views
+
+Library which adds SQL Views to Rails. Adds create_view and drop_view to the ActiveRecord::ConnectionAdapters::AbstractAdapter (which makes them available to migrations) and adds support for dumping views in the ActiveRecord::SchemaDumper.
+
+== Installation
+
+To install:
+
+  gem install rails_sql_views
+ 
+Then add the following to your Rails config/environment.rb:
+
+  require_gem 'rails_sql_views'
+  require 'rails_sql_views'
+
+== Usage
+
+You can then use create_view and drop_view in your migrations. For example:
+
+  class CreatePersonView < ActiveRecord::Migration
+    def self.up
+      create_view :v_people, "select * from people" do |t|
+        t.column :id
+        t.column :name
+        t.column :social_security
+      end
+    end
+
+    def self.down
+      drop_view :v_people
+    end
+  end
+  
+This extension also adds support for views in the ActiveRecord::SchemaDumper class.
+
+The following drivers are supported:
+
+ MySQL
+ PostgreSQL (Native and Pure Ruby)
+ Oracle
+ SQL Server
+
+== Known Issues
+
+* Drivers not mentioned above are not supported.
+
+If you find any issues please send an email to anthonyeden@gmail.com .
+
+== Contributing
+
+If you would like to implement view support for other adapters then please drop me an email. Better yet, write up the adapter modifications and send them to me. :-)

data/Rakefile

@@ -0,0 +1,41 @@
+#!/usr/bin/env rake
+#
+# Development tasks
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+# Documentation
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsSqlViews'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Gem building
+Bundler::GemHelper.install_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', 'release']

data/TODO

@@ -0,0 +1,2 @@
+
+- Use pre-existing Adapter#supports_views? where possible

data/init.rb

@@ -0,0 +1 @@
+require 'rails_sql_views'

data/lib/active_record/view.rb

@@ -0,0 +1,76 @@
+
+# A base class for database views.
+# It is primarily useful for views that are centered around a single table/model.
+module ActiveRecord # :nodoc:
+  class View < Base
+    self.abstract_class = true
+    
+    def readonly?
+      true
+    end
+    
+    class << self
+      # Clones all applicable associations from +model+ to this view
+      # and provides an instance method
+      # <tt>to_<em>model</em></tt>
+      # that casts a view object to an object of the kind view is
+      # based on. This latter object may be missing attributes; to fill
+      # them in, call #reload.
+      def based_on(model)
+        define_method("to_#{model.name.demodulize.underscore}") do
+          becomes(model)
+        end
+        
+        model.reflect_on_all_associations.each do |assoc|
+          clone_association(model, assoc)
+        end
+      end
+      
+      # Clone one or more associations from +model+ to this view class.
+      #
+      # NOTE: Currently only <tt>belongs_to</tt>, <tt>has_many</tt> (withouth
+      # <tt>:through</tt>), and <tt>has_and_belongs_to_many</tt> associations
+      # are supported.
+      def clone_association(model, *associations)
+        associations.each do |association|
+          r = case association
+              when String, Symbol
+                model.reflect_on_association(association.to_sym)
+              when ActiveRecord::Reflection::AssociationReflection
+                association
+              else
+                raise ArgumentError, "Unrecognized association #{association.inspect}; must be a Symbol, String, or AssociationReflection."
+              end
+          case r.macro
+          when :belongs_to
+            if self.column_names.include?(r.primary_key_name.to_s)
+              if !r.options[:foreign_type] || self.column_names.include?(r.options[:foreign_type])
+                options = r.options.merge(
+                  :class_name => r.class_name,
+                  :foreign_key => r.primary_key_name
+                )
+                belongs_to r.name, options
+              end
+            end
+          when :has_many
+            ### TODO :through assocications
+            options = r.options.merge(
+              :class_name => r.class_name,
+              :foreign_key => r.primary_key_name
+            )
+            has_many r.name, options
+          when :has_and_belongs_to_many
+            options = r.options.merge(
+              :class_name => r.class_name,
+              :foreign_key => r.primary_key_name,
+              :association_foreign_key => r.association_foreign_key
+            )
+            has_and_belongs_to_many r.name, options
+          when :has_one
+            ### TODO
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/module.rb

@@ -0,0 +1,13 @@
+# This is required for 1.1.6 support
+unless Module.respond_to?(:alias_method_chain)
+  class Module
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+      alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+  end
+end

data/lib/rails_sql_views.rb

@@ -0,0 +1,51 @@
+#--
+# Copyright (c) 2006 Anthony Eden
+#
+# 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.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'active_record'
+
+require 'core_ext/module'
+
+require 'rails_sql_views/connection_adapters/abstract/schema_definitions'
+require 'rails_sql_views/connection_adapters/abstract/schema_statements'
+require 'rails_sql_views/connection_adapters/abstract_adapter'
+require 'rails_sql_views/schema_dumper'
+require 'rails_sql_views/loader'
+
+$rails_sql_views_included = false
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+  include RailsSqlViews::ConnectionAdapters::SchemaStatements
+  def self.inherited(sub)
+    unless $rails_sql_views_included && (Rails.env.test? || Rails.env.cucumber?)
+      RailsSqlViews::Loader.load_extensions 
+    end
+  end
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  include RailsSqlViews::SchemaDumper
+end
+
+RailsSqlViews::Loader.load_extensions

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

@@ -0,0 +1,63 @@
+module RailsSqlViews
+  module ConnectionAdapters #:nodoc:
+    # Abstract definition of a View
+    class ViewDefinition
+      attr_accessor :columns, :select_query
+      
+      def initialize(base, select_query)
+        @columns = []
+        @base = base
+        @select_query = select_query
+      end
+      
+      def column(name)
+        column = name.to_s
+        @columns << column unless @columns.include? column
+        self
+      end
+      
+      def to_sql
+        @columns.collect { |c| @base.quote_column_name(c) } * ', '
+      end
+      
+    end
+    
+    class MappingDefinition
+      
+      # Generates a hash of the form :old_column => :new_column
+      # Initially, it'll map column names to themselves.
+      # use map_column to modify the list.
+      def initialize(columns)
+        @columns = columns
+        @map = Hash.new()
+        columns.each do |c|
+          @map[c] = c
+        end
+        
+      end
+      
+      # Create a mapping from an old column name to a new one.
+      # If the new name is nil, specify that the old column shouldn't
+      # appear in this new view.
+      def map_column(old_name, new_name)
+        unless @map.include?(old_name)
+          raise ActiveRecord::ActiveRecordError, "column #{old_name} not found, can't be mapped"
+        end
+        if new_name.nil?
+          @map.delete old_name
+          @columns.delete old_name
+        else
+          @map[old_name] = new_name
+        end
+      end
+      
+      def select_cols
+        @columns
+      end
+      
+      def view_cols
+        @columns.map { |c| @map[c] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module RailsSqlViews
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      def self.included(base)
+        base.alias_method_chain :drop_table, :cascade
+      end
+
+      # Create a view.
+      # The +options+ hash can include the following keys:
+      # [<tt>:check_option</tt>]
+      #   Specify restrictions for inserts or updates in updatable views. ANSI SQL 92 defines two check option
+      #   values: CASCADED and LOCAL. See your database documentation for allowed values.
+      # [<tt>:replace</tt>]
+      #   Specify we should use CREATE OR REPLACE VIEW not just CREATE VIEW
+      def create_view(name, select_query, options={})
+        if supports_views?
+          view_definition = ViewDefinition.new(self, select_query)
+          
+          if block_given?
+            yield view_definition
+          end
+
+          if options[:force]
+            drop_view(name) rescue nil
+          end
+
+          create_sql = options[:replace] ? "CREATE OR REPLACE VIEW " : "CREATE VIEW "
+          create_sql << "#{quote_table_name(name)} "
+          if supports_view_columns_definition? && !view_definition.to_sql.blank?
+            create_sql << "("
+            create_sql << view_definition.to_sql
+            create_sql << ") " 
+          end
+          create_sql << "AS #{view_definition.select_query}"
+          create_sql << " WITH #{options[:check_option]} CHECK OPTION" if options[:check_option]
+          execute create_sql
+        end
+      end
+
+      # Also creates a view, with the specific purpose of remapping column names
+      # to make non-ActiveRecord tables friendly with the naming
+      # conventions, while maintaining legacy app compatibility.
+      def create_mapping_view(old_name, new_name, options = {})
+        return unless supports_views?
+        
+        col_names = columns(old_name).collect { |col| col.name.to_sym }
+        mapper = MappingDefinition.new(col_names)
+        
+        yield mapper
+        
+        if options[:force]
+          drop_view(new_name) rescue nil
+        end
+
+        view_sql = "CREATE VIEW #{new_name} "
+        if supports_view_columns_definition?
+          view_sql << "(#{mapper.view_cols.collect { |c| quote_column_name(c) }.join(', ')}) "
+        end
+        view_sql << "AS SELECT #{mapper.select_cols.collect { |c| quote_column_name(c) }.join(', ')} FROM #{old_name}"
+        execute view_sql
+      end
+
+      def drop_table_with_cascade(table_name, options = {})
+        execute "DROP TABLE #{quote_table_name(table_name)} CASCADE"
+      end
+      
+      # Drop a view.
+      # The +options+ hash can include the following keys:
+      # [<tt>:drop_behavior</tt>]
+      #   Specify the drop behavior. ANSI SQL 92 defines two drop behaviors, CASCADE and RESTRICT. See your
+      #   database documentation to determine what drop behaviors are available.
+      def drop_view(name, options={})
+        if supports_views?
+          drop_sql = "DROP VIEW #{quote_table_name(name)}"
+          drop_sql << " #{options[:drop_behavior]}" if options[:drop_behavior]
+          execute drop_sql
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,41 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module AbstractAdapter
+      def self.included(base)
+        base.alias_method_chain :disable_referential_integrity, :views_excluded
+      end
+
+      # Subclasses should override and return true if they support views.
+      def supports_views?
+        return false
+      end
+
+      # Subclasses should override and return false if they don't support CASCADE
+      def supports_drop_table_cascade?
+        return true
+      end
+      
+      def disable_referential_integrity_with_views_excluded(&block)
+        self.class.send(:alias_method, :original_tables_method, :tables)
+        self.class.send(:alias_method, :tables, :base_tables)
+        disable_referential_integrity_without_views_excluded(&block)
+      ensure
+        self.class.send(:alias_method, :tables, :original_tables_method)
+      end
+      
+      def supports_view_columns_definition?
+        true
+      end
+      
+      # Get a list of all views for the current database
+      def views(name = nil)
+        raise NotImplementedError, "views is an abstract method"
+      end
+      
+      # Get the select statement for the specified view
+      def view_select_statement(view, name=nil)
+        raise NotImplementedError, "view_select_statement is an abstract method"
+      end
+    end
+  end
+end