schema_plus 2.0.0.pre3 → 2.0.0.pre5

data/lib/schema_plus_views.rb

@@ -1,16 +0,0 @@
-require 'schema_monkey'
-
-require_relative 'schema_plus_views/active_record/connection_adapters/abstract_adapter'
-require_relative 'schema_plus_views/middleware'
-
-module SchemaPlusViews
-  module ActiveRecord
-    module ConnectionAdapters
-      autoload :Mysql2Adapter, 'schema_plus_views/active_record/connection_adapters/mysql2_adapter'
-      autoload :PostgresqlAdapter, 'schema_plus_views/active_record/connection_adapters/postgresql_adapter'
-      autoload :Sqlite3Adapter, 'schema_plus_views/active_record/connection_adapters/sqlite3_adapter'
-    end
-  end
-end
-
-SchemaMonkey.register(SchemaPlusViews)

data/lib/schema_plus_views/active_record/connection_adapters/abstract_adapter.rb

@@ -1,41 +0,0 @@
-module SchemaPlusViews
-  module ActiveRecord
-    module ConnectionAdapters
-      module AbstractAdapter
-        # Create a view given the SQL definition.  Specify :force => true
-        # to first drop the view if it already exists.
-        def create_view(view_name, definition, options={})
-          definition = definition.to_sql if definition.respond_to? :to_sql
-          if options[:force]
-            drop_view(view_name, if_exists: true)
-          end
-          execute "CREATE VIEW #{quote_table_name(view_name)} AS #{definition}"
-        end
-
-        # Drop the named view.  Specify :if_exists => true
-        # to fail silently if the view doesn't exist.
-        def drop_view(view_name, options = {})
-          sql = "DROP VIEW"
-          sql += " IF EXISTS" if options[:if_exists]
-          sql += " #{quote_table_name(view_name)}"
-          execute sql
-        end
-
-        #####################################################################
-        #
-        # The functions below here are abstract; each subclass should
-        # define them all. Defining them here only for reference.
-        #
-
-        # (abstract) Returns the names of all views, as an array of strings
-        def views(name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
-
-        # (abstract) Returns the SQL definition of a given view.  This is
-        # the literal SQL would come after 'CREATVE VIEW viewname AS ' in
-        # the SQL statement to create a view.
-        def view_definition(view_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; end
-      end
-    end
-  end
-end
-

data/lib/schema_plus_views/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,30 +0,0 @@
-module SchemaPlusViews
-  module ActiveRecord
-    module ConnectionAdapters
-      module Mysql2Adapter
-
-        def views(name = nil)
-          views = []
-          select_all("SELECT table_name FROM information_schema.views WHERE table_schema = SCHEMA()", name).each do |row|
-            views << row["table_name"]
-          end
-          views
-        end
-
-        def view_definition(view_name, name = nil)
-          results = select_all("SELECT view_definition, check_option FROM information_schema.views WHERE table_schema = SCHEMA() AND table_name = #{quote(view_name)}", name)
-          return nil unless results.any?
-          row = results.first
-          sql = row["view_definition"]
-          sql.gsub!(%r{#{quote_table_name(current_database)}[.]}, '')
-          case row["check_option"]
-          when "CASCADED" then sql += " WITH CASCADED CHECK OPTION"
-          when "LOCAL" then sql += " WITH LOCAL CHECK OPTION"
-          end
-          sql
-        end
-
-      end
-    end
-  end
-end

data/lib/schema_plus_views/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,31 +0,0 @@
-module SchemaPlusViews
-  module ActiveRecord
-    module ConnectionAdapters
-      module PostgresqlAdapter
-
-        def views(name = nil) #:nodoc:
-          sql = <<-SQL
-            SELECT viewname
-              FROM pg_views
-            WHERE schemaname = ANY (current_schemas(false))
-            AND viewname NOT LIKE 'pg\_%'
-          SQL
-          sql += " AND schemaname != 'postgis'" if adapter_name == 'PostGIS'
-          query(sql, name).map { |row| row[0] }
-        end
-
-        def view_definition(view_name, name = nil) #:nodoc:
-          result = query(<<-SQL, name)
-        SELECT pg_get_viewdef(oid)
-          FROM pg_class
-         WHERE relkind = 'v'
-           AND relname = '#{view_name}'
-          SQL
-          row = result.first
-          row.first.chomp(';') unless row.nil?
-        end
-
-      end
-    end
-  end
-end

data/lib/schema_plus_views/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,18 +0,0 @@
-module SchemaPlusViews
-  module ActiveRecord
-    module ConnectionAdapters
-      module Sqlite3Adapter
-
-        def views(name = nil)
-          execute("SELECT name FROM sqlite_master WHERE type='view'", name).collect{|row| row["name"]}
-        end
-
-        def view_definition(view_name, name = nil)
-          sql = execute("SELECT sql FROM sqlite_master WHERE type='view' AND name=#{quote(view_name)}", name).collect{|row| row["sql"]}.first
-          sql.sub(/^CREATE VIEW \S* AS\s+/im, '') unless sql.nil?
-        end
-
-      end
-    end
-  end
-end

data/lib/schema_plus_views/middleware.rb

@@ -1,49 +0,0 @@
-module SchemaPlusViews
-  module Middleware
-
-    module Dumper
-      module Tables
-
-        # Dump views
-        def after(env)
-          re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(\S+)\b}
-          env.connection.views.each do |view_name|
-            next if env.dumper.ignored?(view_name)
-            view = View.new(name: view_name, definition: env.connection.view_definition(view_name))
-            env.dump.tables[view.name] = view
-            env.dump.depends(view.name, view.definition.scan(re_view_referent).flatten)
-          end
-        end
-
-        # quacks like a SchemaMonkey Dump::Table
-        class View < KeyStruct[:name, :definition]
-          def assemble(stream)
-            stream.puts("  create_view #{name.inspect}, #{definition.inspect}, :force => true\n")
-          end
-        end
-      end
-    end
-
-    module Query
-      module Tables
-
-        module Mysql
-          def after(env)
-            Tables.filter_out_views(env)
-          end
-        end
-
-        module Sqlite3
-          def after(env)
-            Tables.filter_out_views(env)
-          end
-        end
-
-        def self.filter_out_views(env)
-          env.tables -= env.connection.views(env.query_name)
-        end
-      end
-    end
-  end
-
-end

data/spec/schema_plus_views/named_schemas_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe "with multiple schemas" do
-  def connection
-    ActiveRecord::Base.connection
-  end
-
-  before(:all) do
-    newdb = case connection.adapter_name
-            when /^mysql/i then      "CREATE SCHEMA IF NOT EXISTS schema_plus_views_test2"
-            when /^postgresql/i then "CREATE SCHEMA schema_plus_views_test2"
-            when /^sqlite/i then     "ATTACH ':memory:' AS schema_plus_views_test2"
-            end
-    begin
-      ActiveRecord::Base.connection.execute newdb
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless e.message =~ /already exists/
-    end
-
-    class User < ::ActiveRecord::Base ; end
-  end
-
-  before(:each) do
-    define_schema(:auto_create => false) do
-      create_table :users, :force => true do |t|
-        t.string :login
-      end
-    end
-
-    connection.execute 'DROP TABLE IF EXISTS schema_plus_views_test2.users'
-    connection.execute 'CREATE TABLE schema_plus_views_test2.users (id ' + case connection.adapter_name
-          when /^mysql/i then      "integer primary key auto_increment"
-          when /^postgresql/i then "serial primary key"
-          when /^sqlite/i then     "integer primary key autoincrement"
-          end + ", login varchar(255))"
-  end
-
-  context "with views in each schema" do
-    around(:each) do  |example|
-      begin
-        example.run
-      ensure
-        connection.execute 'DROP VIEW schema_plus_views_test2.myview' rescue nil
-        connection.execute 'DROP VIEW myview' rescue nil
-      end
-    end
-
-    before(:each) do
-      connection.views.each { |view| connection.drop_view view }
-      connection.execute 'CREATE VIEW schema_plus_views_test2.myview AS SELECT * FROM users'
-    end
-
-    it "should not find views in other schema" do
-      expect(connection.views).to be_empty
-    end
-
-    it "should find views in this schema" do
-      connection.execute 'CREATE VIEW myview AS SELECT * FROM users'
-      expect(connection.views).to eq(['myview'])
-    end
-  end
-
-  context "when using PostGIS", :postgresql => :only do
-    before(:all) do
-      begin
-        connection.execute "CREATE SCHEMA postgis"
-      rescue ActiveRecord::StatementInvalid => e
-        raise unless e.message =~ /already exists/
-      end
-    end
-
-    around(:each) do |example|
-      begin
-        connection.execute "SET search_path to '$user','public','postgis'"
-        example.run
-      ensure
-        connection.execute "SET search_path to '$user','public'"
-      end
-    end
-
-    before(:each) do
-      allow(connection).to receive(:adapter_name).and_return('PostGIS')
-    end
-
-    it "should hide views in postgis schema" do
-      begin
-        connection.create_view "postgis.hidden", "select 1", :force => true
-        connection.create_view :myview, "select 2", :force => true
-        expect(connection.views).to eq(["myview"])
-      ensure
-        connection.execute 'DROP VIEW postgis.hidden' rescue nil
-        connection.execute 'DROP VIEW myview' rescue nil
-      end
-    end
-  end
-
-end

data/spec/schema_plus_views/views_spec.rb

@@ -1,194 +0,0 @@
-require 'spec_helper'
-
-class Item < ActiveRecord::Base
-end
-
-class AOnes < ActiveRecord::Base
-end
-
-class ABOnes < ActiveRecord::Base
-end
-
-describe ActiveRecord do
-
-  let(:schema) { ActiveRecord::Schema }
-
-  let(:migration) { ActiveRecord::Migration }
-
-  let(:connection) { ActiveRecord::Base.connection }
-
-  context "views" do
-
-    around(:each) do |example|
-      define_schema_and_data
-      example.run
-      drop_definitions
-    end
-
-    it "should query correctly" do
-      expect(AOnes.all.collect(&:s)).to eq(%W[one_one one_two])
-      expect(ABOnes.all.collect(&:s)).to eq(%W[one_one])
-    end
-
-    it "should instrospect" do
-      # for postgresql, ignore views named pg_*
-      expect(connection.views.sort).to eq(%W[a_ones ab_ones])
-      expect(connection.view_definition('a_ones')).to match(%r{^ ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}mi)
-      expect(connection.view_definition('ab_ones')).to match(%r{^ ?SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}mi)
-    end
-
-    it "should not be listed as a table" do
-      expect(connection.tables).not_to include('a_ones')
-      expect(connection.tables).not_to include('ab_ones')
-    end
-
-
-    it "should be included in schema dump" do
-      expect(dump).to match(%r{create_view "a_ones", " ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}mi)
-      expect(dump).to match(%r{create_view "ab_ones", " ?SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1.*, :force => true}mi)
-    end
-
-    it "should be included in schema dump in dependency order" do
-      expect(dump).to match(%r{create_table "items".*create_view "a_ones".*create_view "ab_ones"}m)
-    end
-
-    it "should not be included in schema if listed in ignore_tables" do
-      dump(ignore_tables: /b_/) do |dump|
-        expect(dump).to match(%r{create_view "a_ones", " ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}mi)
-        expect(dump).not_to match(%r{"ab_ones"})
-      end
-    end
-
-
-    it "dump should not reference current database" do
-      # why check this?  mysql default to providing the view definition
-      # with tables explicitly scoped to the current database, which
-      # resulted in the dump being bound to the current database.  this
-      # caused trouble for rails, in which creates the schema dump file
-      # when in the (say) development database, but then uses it to
-      # initialize the test database when testing.  this meant that the
-      # test database had views into the development database.
-      db = connection.respond_to?(:current_database)? connection.current_database : SchemaDev::Rspec.db_configuration[:database]
-      expect(dump).not_to match(%r{#{connection.quote_table_name(db)}[.]})
-    end
-
-    context "duplicate view creation" do
-      around(:each) do |example|
-        migration.suppress_messages do
-          begin
-            migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=1)')
-            example.run
-          ensure
-            migration.drop_view('dupe_me')
-          end
-        end
-      end
-
-
-      it "should raise an error by default" do
-        expect {migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)')}.to raise_error ActiveRecord::StatementInvalid
-      end
-
-      it "should override existing definition if :force true" do
-        migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', :force => true)
-        expect(connection.view_definition('dupe_me')).to match(%r{WHERE .*a.*=.*2}i)
-      end
-    end
-
-    context "dropping views" do
-      it "should raise an error if the view doesn't exist" do
-        expect { migration.drop_view('doesnt_exist') }.to raise_error ActiveRecord::StatementInvalid
-      end
-
-      it "should fail silently when using if_exists option" do
-        expect { migration.drop_view('doesnt_exist', :if_exists => true) }.not_to raise_error
-      end
-
-      context "with a view that exists" do
-        before { migration.create_view('view_that_exists', 'SELECT * FROM items WHERE (a=1)') }
-
-        it "should succeed" do
-          migration.drop_view('view_that_exists')
-          expect(connection.views).not_to include('view_that_exists')
-        end
-      end
-    end
-
-    context "in mysql", :mysql => :only do
-
-      around(:each) do |example|
-        migration.suppress_messages do
-          begin
-            migration.drop_view :check if connection.views.include? 'check'
-            example.run
-          ensure
-            migration.drop_view :check if connection.views.include? 'check'
-          end
-        end
-      end
-
-      it "should introspect WITH CHECK OPTION" do
-        migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CHECK OPTION'
-        expect(connection.view_definition('check')).to match(%r{WITH CASCADED CHECK OPTION$})
-      end
-
-      it "should introspect WITH CASCADED CHECK OPTION" do
-        migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CASCADED CHECK OPTION'
-        expect(connection.view_definition('check')).to match(%r{WITH CASCADED CHECK OPTION$})
-      end
-
-      it "should introspect WITH LOCAL CHECK OPTION" do
-        migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH LOCAL CHECK OPTION'
-        expect(connection.view_definition('check')).to match(%r{WITH LOCAL CHECK OPTION$})
-      end
-    end
-  end
-
-  protected
-
-  def define_schema_and_data
-    migration.suppress_messages do
-      connection.views.each do |view| connection.drop_view view end
-      connection.tables.each do |table| connection.drop_table table, cascade: true end
-
-      schema.define do
-
-        create_table :items, :force => true do |t|
-          t.integer :a
-          t.integer :b
-          t.string  :s
-        end
-
-        create_view :a_ones, Item.select('b, s').where(:a => 1)
-        create_view :ab_ones, "select s from a_ones where b = 1"
-        create_view :pg_dummy_internal, "select 1" if SchemaDev::Rspec::Helpers.postgresql?
-      end
-    end
-    connection.execute "insert into items (a, b, s) values (1, 1, 'one_one')"
-    connection.execute "insert into items (a, b, s) values (1, 2, 'one_two')"
-    connection.execute "insert into items (a, b, s) values (2, 1, 'two_one')"
-    connection.execute "insert into items (a, b, s) values (2, 2, 'two_two')"
-
-  end
-
-  def drop_definitions
-    migration.suppress_messages do
-      schema.define do
-        drop_view "ab_ones"
-        drop_view "a_ones"
-        drop_table "items"
-        drop_view :pg_dummy_internal if SchemaDev::Rspec::Helpers.postgresql?
-      end
-    end
-  end
-
-  def dump(opts={})
-    StringIO.open { |stream|
-      ActiveRecord::SchemaDumper.ignore_tables = Array.wrap(opts[:ignore_tables])
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      yield stream.string if block_given?
-      stream.string
-    }
-  end
-
-end