lunks-rails_sql_views 0.9.2

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/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,78 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+require File.join(File.dirname(__FILE__), 'lib/rails_sql_views', 'version')
+
+PKG_BUILD       = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME        = 'rails_sql_views'
+PKG_VERSION     = RailsSqlViews::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_DESTINATION = ENV["PKG_DESTINATION"] || "../#{PKG_NAME}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "activewarehouse"
+RUBY_FORGE_USER    = "aeden"
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the library.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+namespace :rcov do
+  desc 'Measures test coverage'
+  task :test do
+    rm_f 'coverage.data'
+    mkdir 'coverage' unless File.exist?('coverage')
+    rcov = "rcov --aggregate coverage.data --text-summary -Ilib"
+    system("#{rcov} test/*_test.rb test/**/*_test.rb")
+    system("open coverage/index.html") if PLATFORM['darwin']
+  end
+end
+
+desc 'Generate documentation library.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rails SQL Views'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "ctreatma-rails_sql_views"
+    s.summary = "Library which adds SQL Views to ActiveRecord."
+    s.email = "charles.treatman@gmail.com"
+    s.homepage = "http://github.com/ctreatma/rails_sql_views"
+    s.description = "Adds support for using SQL views within ActiveRecord"
+    s.authors = ["Charles Treatman", "Anthony Eden"]
+    s.files =  FileList[
+      "CHANGELOG", 
+      "README",
+      "Rakefile",
+      "{bin,lib}/**/*"
+    ]
+    s.add_dependency 'activerecord'
+    s.add_development_dependency 'flexmock'
+    s.add_development_dependency 'pg'
+    s.add_development_dependency 'mysql'
+    s.add_development_dependency 'mysql2'
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("aeden@rubyforge.org", "/var/www/gforge-projects/activewarehouse/rails_sql_views/rdoc", "rdoc").upload
+end

data/TODO

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

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/ctreatma-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,71 @@
+module RailsSqlViews
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      # 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.
+      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 = "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
+      
+      # 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,36 @@
+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
+
+      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

data/lib/rails_sql_views/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,66 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module MysqlAdapter
+      REQUIRED_METHODS = [:supports_views?]
+
+      def self.included(base)
+        base.class_eval do
+          def self.method_added(method)
+            public(method) if REQUIRED_METHODS.include?(method) && !self.public_method_defined?(method)
+          end
+        end
+      end
+
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def base_tables(name = nil) #:nodoc:
+        tables = []
+        execute("SHOW FULL TABLES WHERE TABLE_TYPE='BASE TABLE'").each{|row| tables << row[0]}
+        tables
+      end
+      alias nonview_tables base_tables
+
+      def views(name = nil) #:nodoc:
+        views = []
+        execute("SHOW FULL TABLES WHERE TABLE_TYPE='VIEW'").each{|row| views << row[0]}
+        views
+      end
+
+      def tables_with_views_included(name = nil)
+        nonview_tables(name) + views(name)
+      end
+
+      def structure_dump
+        structure = ""
+        base_tables.each do |table|
+          structure += select_one("SHOW CREATE TABLE #{quote_table_name(table)}")["Create Table"] + ";\n\n"
+        end
+
+        views.each do |view|
+          structure += select_one("SHOW CREATE VIEW #{quote_table_name(view)}")["Create View"] + ";\n\n"
+        end
+
+        return structure
+      end
+
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name=nil)
+        begin
+          row = execute("SHOW CREATE VIEW #{view}", name).each do |row|
+            return convert_statement(row[1]) if row[0] == view
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          raise "No view called #{view} found"
+        end
+      end
+
+      private
+      def convert_statement(s)
+        s.gsub!(/.* AS (select .*)/, '\1')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/oci_adapter.rb

@@ -0,0 +1,33 @@
+module RailsSqlViews
+ module ConnectionAdapters
+   module OciAdapter
+     # Returns true as this adapter supports views.
+     def supports_views?
+       true
+     end
+
+     def base_tables(name = nil) #:nodoc:
+       tables = []
+       execute("SELECT TABLE_NAME FROM USER_TABLES", name).each { |row| tables << row[0]  }
+       tables
+     end
+     alias nonview_tables base_tables
+
+     def views(name = nil) #:nodoc:
+       views = []
+       execute("SELECT VIEW_NAME FROM USER_VIEWS", name).each { |row| views << row[0] }
+       views
+     end
+
+     # Get the view select statement for the specified table.
+     def view_select_statement(view, name=nil)
+       row = execute("SELECT TEXT FROM USER_VIEWS WHERE VIEW_NAME = '#{view}'", name).each do |row|
+         return row[0]
+       end
+       raise "No view called #{view} found"
+     end
+
+
+   end
+ end
+end

data/lib/rails_sql_views/connection_adapters/oracle_adapter.rb

@@ -0,0 +1,33 @@
+module RailsSqlViews
+ module ConnectionAdapters
+   module OracleAdapter
+     # Returns true as this adapter supports views.
+     def supports_views?
+       true
+     end
+
+     def base_tables(name = nil) #:nodoc:
+       tables = []
+       execute("SELECT TABLE_NAME FROM USER_TABLES", name).each { |row| tables << row[0]  }
+       tables
+     end
+     alias nonview_tables base_tables
+
+     def views(name = nil) #:nodoc:
+       views = []
+       execute("SELECT VIEW_NAME FROM USER_VIEWS", name).each { |row| views << row[0] }
+       views
+     end
+
+     # Get the view select statement for the specified table.
+     def view_select_statement(view, name=nil)
+       row = execute("SELECT TEXT FROM USER_VIEWS WHERE VIEW_NAME = '#{view}'", name).each do |row|
+         return row[0]
+       end
+       raise "No view called #{view} found"
+     end
+
+
+   end
+ end
+end

data/lib/rails_sql_views/connection_adapters/oracleenhanced_adapter.rb

@@ -0,0 +1,39 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module OracleEnhancedAdapter
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def base_tables(name = nil) #:nodoc:
+        tables = []
+        cursor = execute("SELECT TABLE_NAME FROM ALL_TABLES WHERE owner = SYS_CONTEXT('userenv', 'current_schema') AND secondary = 'N'", name)
+        while row = cursor.fetch
+          tables << row[0]
+        end
+        tables
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        views = []
+        cursor = execute("SELECT VIEW_NAME FROM ALL_VIEWS WHERE owner = SYS_CONTEXT('userenv', 'current_schema')", name)
+        while row = cursor.fetch
+          views << row[0]
+        end
+        views
+      end
+      
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name=nil)
+        cursor = execute("SELECT TEXT FROM ALL_VIEWS WHERE VIEW_NAME = '#{view}' AND owner = SYS_CONTEXT('userenv', 'current_schema')", name)
+        if row = cursor.fetch
+          return row[0]
+        else
+          raise "No view called #{view} found"
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/oracleenhanced_adapter.rb.orig

@@ -0,0 +1,72 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module OracleEnhancedAdapter
+<<<<<<< HEAD
+      def self.included(base)
+        base.alias_method_chain :tables, :views_included
+      end
+=======
+>>>>>>> Add support for oracle_enhanced adapter. Don't alias tables in PostgreSQL adapter if it's already been aliased.
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+<<<<<<< HEAD
+      def tables_with_views_included(name = nil)
+        tables = []
+        sql = " SELECT TABLE_NAME FROM USER_TABLES
+                UNION
+                SELECT VIEW_NAME AS TABLE_NAME FROM USER_VIEWS"
+        cursor = execute(sql, name)
+        while row = cursor.fetch
+          tables << row[0].downcase
+        end
+        tables
+      end
+      
+=======
+>>>>>>> Add support for oracle_enhanced adapter. Don't alias tables in PostgreSQL adapter if it's already been aliased.
+      def base_tables(name = nil) #:nodoc:
+        tables = []
+        cursor = execute("SELECT TABLE_NAME FROM USER_TABLES", name)
+        while row = cursor.fetch
+<<<<<<< HEAD
+          tables << row[0].downcase
+=======
+          tables << row[0]
+>>>>>>> Add support for oracle_enhanced adapter. Don't alias tables in PostgreSQL adapter if it's already been aliased.
+        end
+        tables
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        views = []
+        cursor = execute("SELECT VIEW_NAME FROM USER_VIEWS", name)
+        while row = cursor.fetch
+<<<<<<< HEAD
+          views << row[0].downcase
+=======
+          views << row[0]
+>>>>>>> Add support for oracle_enhanced adapter. Don't alias tables in PostgreSQL adapter if it's already been aliased.
+        end
+        views
+      end
+      
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name=nil)
+<<<<<<< HEAD
+        view.upcase!
+=======
+>>>>>>> Add support for oracle_enhanced adapter. Don't alias tables in PostgreSQL adapter if it's already been aliased.
+        cursor = execute("SELECT TEXT FROM USER_VIEWS WHERE VIEW_NAME = '#{view}'", name)
+        if row = cursor.fetch
+          return row[0]
+        else
+          raise "No view called #{view} found"
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,65 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+      def self.included(base)
+        base.alias_method_chain :tables, :views_included unless method_defined?(:tables_with_views_included)
+      end
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def tables_with_views_included(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type IN ('BASE TABLE', 'VIEW')
+        SQL
+
+        query(q, name).map { |row| row[0] }
+      end
+      
+      def base_tables(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'BASE TABLE'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'VIEW'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+
+      def view_select_statement(view, name = nil)
+        q = <<-SQL
+        SELECT view_definition
+          FROM information_schema.views 
+         WHERE table_catalog = (SELECT catalog_name FROM information_schema.information_schema_catalog_name)
+           AND table_schema IN (#{schemas})
+           AND table_name = '#{view}'
+        SQL
+        
+        select_value(q, name) or raise "No view called #{view} found"
+      end
+
+      private
+        
+      def schemas
+        schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/postgresql_adapter.rb.orig

@@ -0,0 +1,69 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+      def self.included(base)
+<<<<<<< HEAD
+        base.alias_method_chain :tables, :views_included unless method_defined?(:tables_with_views_included)
+=======
+        base.alias_method_chain :tables, :views_included
+>>>>>>> Make tests pass again for PostgreSQL and MySQL adapters.
+      end
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def tables_with_views_included(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type IN ('BASE TABLE', 'VIEW')
+        SQL
+
+        query(q, name).map { |row| row[0] }
+      end
+      
+      def base_tables(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'BASE TABLE'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'VIEW'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+
+      def view_select_statement(view, name = nil)
+        q = <<-SQL
+        SELECT view_definition
+          FROM information_schema.views 
+         WHERE table_catalog = (SELECT catalog_name FROM information_schema.information_schema_catalog_name)
+           AND table_schema IN (#{schemas})
+           AND table_name = '#{view}'
+        SQL
+        
+        select_value(q, name) or raise "No view called #{view} found"
+      end
+
+      private
+        
+      def schemas
+        schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,62 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module SQLiteAdapter
+      def supports_views?
+        true
+      end
+
+      def tables(name = nil) #:nodoc:
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE (type = 'table' OR type = 'view') AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end
+      end
+
+      def base_tables(name = nil)
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE (type = 'table') AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end        
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil)
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'view' AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end
+      end
+      
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name = nil)
+        sql = <<-SQL
+          SELECT sql
+          FROM sqlite_master
+          WHERE name = '#{view}' AND NOT name = 'sqlite_sequence'
+        SQL
+        
+        (select_value(sql, name).gsub("CREATE VIEW #{view} AS ", "")) or raise "No view called #{view} found"
+      end
+      
+      def supports_view_columns_definition?
+        false
+      end
+      
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,43 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module SQLServerAdapter
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      # Get all of the non-view tables from the currently connected schema
+      def base_tables(name = nil)
+        # this is untested
+        select_values("SELECT table_name FROM information_schema.tables", name)
+      end
+      alias nonview_tables base_tables
+      
+      # Returns all the view names from the currently connected schema.
+      def views(name = nil)
+        select_values("SELECT table_name FROM information_schema.views", name)
+      end
+      
+      # Get the view select statement for the specified view.
+      def view_select_statement(view, name=nil)
+        q =<<-ENDSQL
+          SELECT view_definition FROM information_schema.views
+          WHERE table_name = '#{view}'
+        ENDSQL
+        
+        view_def = select_value(q, name)
+        
+        if view_def
+          return convert_statement(view_def)
+        else
+          raise "No view called #{view} found"
+        end
+      end
+      
+      private
+      def convert_statement(s)
+        s.sub(/^CREATE.* AS (select .*)/i, '\1').gsub(/\n/, '')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/loader.rb

@@ -0,0 +1,20 @@
+
+module RailsSqlViews
+  module Loader
+    SUPPORTED_ADAPTERS = %w( Mysql Mysql2 PostgreSQL SQLServer SQLite OracleEnhanced )
+
+    def self.load_extensions
+      SUPPORTED_ADAPTERS.each do |db|
+        if ActiveRecord::ConnectionAdapters.const_defined?("#{db}Adapter")
+          require "rails_sql_views/connection_adapters/#{db.downcase}_adapter"
+          ActiveRecord::ConnectionAdapters.const_get("#{db}Adapter").class_eval do
+            include RailsSqlViews::ConnectionAdapters::AbstractAdapter
+            include RailsSqlViews::ConnectionAdapters.const_get("#{db}Adapter")
+            # prevent reloading extension when the environment is reloaded
+            $rails_sql_views_included = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/schema_dumper.rb

@@ -0,0 +1,112 @@
+module RailsSqlViews
+  module SchemaDumper
+    def self.included(base)
+      base.alias_method_chain :trailer, :views
+      base.alias_method_chain :dump, :views
+      base.alias_method_chain :tables, :views_excluded
+      
+      # A list of views which should not be dumped to the schema. 
+      # Acceptable values are strings as well as regexp.
+      # This setting is only used if ActiveRecord::Base.schema_format == :ruby
+      base.cattr_accessor :ignore_views
+      base.ignore_views = []
+      # Optional: specify the order that in which views are created.
+      # This allows views to depend on and include fields from other views.
+      # It is not necessary to specify all the view names, just the ones that 
+      # need to be created first
+      base.cattr_accessor :view_creation_order
+      base.view_creation_order = []
+    end
+    
+    def trailer_with_views(stream)
+      # do nothing...we'll call this later
+    end
+    
+    # Add views to the end of the dump stream
+    def dump_with_views(stream)
+      dump_without_views(stream)
+      begin
+        if @connection.supports_views?
+          views(stream)
+        end
+      rescue => e
+        if ActiveRecord::Base.logger
+          ActiveRecord::Base.logger.error "Unable to dump views: #{e}"
+        else
+          raise e
+        end
+      end
+      trailer_without_views(stream)
+      stream
+    end
+    
+    # Add views to the stream
+    def views(stream)
+      if view_creation_order.empty?
+        sorted_views = @connection.views.sort
+      else
+        # set union, merge by joining arrays, removing dups
+        # this will float the view name sin view_creation_order to the top
+        # without requiring all the views to be specified
+        sorted_views = view_creation_order | @connection.views
+      end
+      sorted_views.each do |v|
+        next if [ActiveRecord::Migrator.schema_migrations_table_name, ignore_views].flatten.any? do |ignored|
+          case ignored
+          when String then v == ignored
+          when Symbol then v == ignored.to_s
+          when Regexp then v =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_views accepts an array of String and / or Regexp values.'
+          end
+        end 
+        view(v, stream)
+      end
+    end
+    
+    # Add the specified view to the stream
+    def view(view, stream)
+      columns = @connection.columns(view).collect { |c| c.name }
+      begin
+        v = StringIO.new
+
+        v.print "  create_view #{view.inspect}"
+        v.print ", #{@connection.view_select_statement(view).dump}"
+        v.print ", :force => true"
+        v.puts " do |v|"
+
+        columns.each do |column|
+          v.print "    v.column :#{column}"
+          v.puts
+        end
+
+        v.puts "  end"
+        v.puts
+        
+        v.rewind
+        stream.print v.read
+      rescue => e
+        stream.puts "# Could not dump view #{view.inspect} because of following #{e.class}"
+        stream.puts "#   #{e.message}"
+        stream.puts
+      end
+      
+      stream
+    end
+
+    def tables_with_views_excluded(stream)
+      @connection.base_tables.sort.each do |tbl|
+        next if [ActiveRecord::Migrator.schema_migrations_table_name, ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String then tbl == ignored
+          when Regexp then tbl =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+          end
+        end
+        table(tbl, stream)
+      end
+    end
+
+  end
+end

data/lib/rails_sql_views/version.rb

@@ -0,0 +1,9 @@
+module RailsSqlViews
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: lunks-rails_sql_views
+version: !ruby/object:Gem::Version
+  version: 0.9.2
+  prerelease: 
+platform: ruby
+authors:
+- Charles Treatman
+- Anthony Eden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70363715386660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70363715386660
+description: Adds support for using SQL views within ActiveRecord
+email: charles.treatman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README
+- TODO
+files:
+- CHANGELOG
+- README
+- Rakefile
+- lib/active_record/view.rb
+- lib/core_ext/module.rb
+- lib/ctreatma-rails_sql_views.rb
+- lib/rails_sql_views/connection_adapters/abstract/schema_definitions.rb
+- lib/rails_sql_views/connection_adapters/abstract/schema_statements.rb
+- lib/rails_sql_views/connection_adapters/abstract_adapter.rb
+- lib/rails_sql_views/connection_adapters/mysql_adapter.rb
+- lib/rails_sql_views/connection_adapters/oci_adapter.rb
+- lib/rails_sql_views/connection_adapters/oracle_adapter.rb
+- lib/rails_sql_views/connection_adapters/oracleenhanced_adapter.rb
+- lib/rails_sql_views/connection_adapters/oracleenhanced_adapter.rb.orig
+- lib/rails_sql_views/connection_adapters/postgresql_adapter.rb
+- lib/rails_sql_views/connection_adapters/postgresql_adapter.rb.orig
+- lib/rails_sql_views/connection_adapters/sqlite_adapter.rb
+- lib/rails_sql_views/connection_adapters/sqlserver_adapter.rb
+- lib/rails_sql_views/loader.rb
+- lib/rails_sql_views/schema_dumper.rb
+- lib/rails_sql_views/version.rb
+- LICENSE
+- TODO
+homepage: http://github.com/lunks/rails_sql_views
+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.15
+signing_key: 
+specification_version: 3
+summary: Library which adds SQL Views to ActiveRecord.
+test_files: []