qubole_rails_sql_views 0.10.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/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,74 @@
+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 = "rails_sql_views"
+    s.summary = "Library which adds SQL Views to ActiveRecord."
+    s.email = "josh@technicalpickles.com"
+    s.homepage = "http://activewarehouse.rubyforge.org/rails_sql_views"
+    s.description = "Adds support for using SQL views within ActiveRecord"
+    s.authors = ["Anthony Eden"]
+    s.files =  FileList[
+      "CHANGELOG", 
+      "README",
+      "Rakefile",
+      "{bin,lib}/**/*"
+    ]
+    s.add_dependency 'activerecord'
+  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/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,79 @@
+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.
+      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
+
+      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

data/lib/rails_sql_views/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,62 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module MysqlAdapter
+      def self.included(base)
+        if base.private_method_defined?(:supports_views?)
+          base.send(:public, :supports_views?)
+        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 USER_TABLES", 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 USER_VIEWS", 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 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/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