schema_plus 0.4.1 → 1.0.0

data/gemfiles/rails-3.2/Gemfile.base

@@ -0,0 +1,4 @@
+source :rubygems
+
+gemspec :path => File.expand_path('../../..', __FILE__)
+gem "rails", "~> 3.2.0"

data/gemfiles/rails-3.2/Gemfile.mysql

@@ -0,0 +1,4 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+gem "mysql", "~> 2.8.1"

data/gemfiles/rails-3.2/Gemfile.mysql2

@@ -0,0 +1,4 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+gem "mysql2"

data/gemfiles/rails-3.2/Gemfile.postgresql

@@ -0,0 +1,4 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+gem "pg"

data/gemfiles/rails-3.2/Gemfile.sqlite3

@@ -0,0 +1,4 @@
+require "pathname"
+eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
+
+gem "sqlite3"

data/lib/schema_plus.rb

@@ -3,6 +3,7 @@ require 'valuable'
 require 'schema_plus/version'
 require 'schema_plus/active_record/base'
 require 'schema_plus/active_record/column_options_handler'
+require 'schema_plus/active_record/db_default'
 require 'schema_plus/active_record/foreign_keys'
 require 'schema_plus/active_record/connection_adapters/table_definition'
 require 'schema_plus/active_record/connection_adapters/schema_statements'
@@ -132,6 +133,7 @@ module SchemaPlus
     ::ActiveRecord::Base.send(:include, SchemaPlus::ActiveRecord::Base)
     ::ActiveRecord::Schema.send(:include, SchemaPlus::ActiveRecord::Schema)
     ::ActiveRecord::SchemaDumper.send(:include, SchemaPlus::ActiveRecord::SchemaDumper)
+    ::ActiveRecord.const_set(:DB_DEFAULT, SchemaPlus::ActiveRecord::DB_DEFAULT)
   end
 
 end

data/lib/schema_plus/active_record/column_options_handler.rb

@@ -2,48 +2,80 @@ module SchemaPlus::ActiveRecord
   module ColumnOptionsHandler
     def schema_plus_handle_column_options(table_name, column_name, column_options, opts = {}) #:nodoc:
       config = opts[:config] || SchemaPlus.config
-      if references = get_references(table_name, column_name, column_options, config)
-        if index = column_options.fetch(:index, config.foreign_keys.auto_index?)
-          column_index(table_name, column_name, index)
-        end
-        add_foreign_key(table_name, column_name, references.first, references.last,
-                                    column_options.reverse_merge(:on_update => config.foreign_keys.on_update,
-                                                                 :on_delete => config.foreign_keys.on_delete))
-      elsif column_options[:index]
-        column_index(table_name, column_name, column_options[:index])
+      fk_args = get_fk_args(table_name, column_name, column_options, config)
+
+      # remove existing fk and auto-generated index in case of change to existing column
+      if fk_args # includes :none for explicitly off
+        remove_foreign_key_if_exists(table_name, column_name)
+        remove_auto_index_if_exists(table_name, column_name)
+      end
+
+      fk_args = nil if fk_args == :none
+
+      # create index if requested explicity or implicitly due to auto_index
+      index = column_options[:index]
+      if index.nil? and fk_args && config.foreign_keys.auto_index?
+        index = { :name => auto_index_name(table_name, column_name) }
+      end
+      column_index(table_name, column_name, index) if index
+
+      if fk_args
+        references = fk_args.delete(:references)
+        add_foreign_key(table_name, column_name, references.first, references.last, fk_args)
       end
     end
 
     protected
 
-    # If auto_create is true:
-    #   get_references('comments', 'post_id') # => ['posts', 'id']
-    #
-    # And if <tt>column_name</tt> is parent_id it references to the same table
-    #   get_references('pages', 'parent_id')  # => ['pages', 'id']
-    #
-    # If :references option is given, it is used (whether or not auto_create is true)
-    #   get_references('widgets', 'main_page_id', :references => 'pages')) => ['pages', 'id']
-    #
-    # Also the referenced id column may be specified:
-    #   get_references('addresses', 'member_id', :references => ['users', 'uuid']) => ['users', 'uuid']
-    #
-    def get_references(table_name, column_name, column_options = {}, config = {}) #:nodoc:
+    def get_fk_args(table_name, column_name, column_options = {}, config = {}) #:nodoc:
+
+      args = nil
+
+      if column_options.has_key?(:foreign_key)
+        args = column_options[:foreign_key]
+        return :none unless args
+        args = {} if args == true
+        return :none if args.has_key?(:references) and not args[:references]
+      end
+
       if column_options.has_key?(:references)
         references = column_options[:references]
-        references = [references, :id] unless references.nil? || references.is_a?(Array)
-        references
-      elsif config.foreign_keys.auto_create?
-        case column_name.to_s
-        when 'parent_id'
-          [table_name, :id]
-        when /^(.*)_id$/
-          determined_table_name = ActiveRecord::Base.pluralize_table_names ? $1.to_s.pluralize : $1
-          [determined_table_name, :id]
-        end
+        return :none unless references
+        args = (args || {}).reverse_merge(:references => references)
+      end
+
+      args ||= {} if config.foreign_keys.auto_create? and column_name =~ /_id$/
+
+      return nil if args.nil?
+
+      args[:references] ||= case column_name.to_s
+                            when 'parent_id'
+                              [table_name, :id]
+                            when /^(.*)_id$/
+                              references_table_name = ActiveRecord::Base.pluralize_table_names ? $1.to_s.pluralize : $1
+                              [references_table_name, :id]
+                            else
+                              references_table_name = ActiveRecord::Base.pluralize_table_names ? column_name.to_s.pluralize : column_name
+                            end
+      args[:references] = [args[:references], :id] unless args[:references].is_a? Array
+
+      [:on_update, :on_delete, :deferrable].each do |shortcut|
+        args[shortcut] ||= column_options[shortcut] if column_options.has_key? shortcut
       end
+
+      args[:on_update] ||= config.foreign_keys.on_update
+      args[:on_delete] ||= config.foreign_keys.on_delete
+
+      args
+    end
+
+    def remove_foreign_key_if_exists(table_name, column_name) #:nodoc:
+      foreign_keys = ActiveRecord::Base.connection.foreign_keys(table_name.to_s) rescue [] # no fks if table_name doesn't exist
+      fk = foreign_keys.detect { |fk| fk.table_name == table_name.to_s && fk.column_names == Array(column_name).collect(&:to_s) }
+      remove_foreign_key(table_name, fk.name) if fk
     end
 
+
     def column_index(table_name, column_name, options) #:nodoc:
       options = {} if options == true
       options = { :unique => true } if options == :unique
@@ -51,5 +83,14 @@ module SchemaPlus::ActiveRecord
       add_index(table_name, column_name, options)
     end
 
+    def remove_auto_index_if_exists(table_name, column_name)
+      name = auto_index_name(table_name, column_name)
+      remove_index(table_name, :name => name) if index_exists?(table_name, column_name, :name => name)
+    end
+
+    def auto_index_name(table_name, column_name)
+      ConnectionAdapters::ForeignKeyDefinition.auto_index_name(table_name, column_name)
+    end
+
   end
 end

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

@@ -35,14 +35,6 @@ module SchemaPlus
             adapter_module = SchemaPlus::ActiveRecord::ConnectionAdapters.const_get(adapter)
             self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
             self.post_initialize if self.respond_to? :post_initialize
-            # rails 3.1 defines a separate Mysql2IndexDefinition which is
-            # compatible with the monkey patches; but the definition only
-            # appears once the adapter is loaded.  so wait til now to check
-            # if that constant exists, then include the patches
-            if mysql2index = ::ActiveRecord::ConnectionAdapters::Mysql2IndexDefinition rescue nil # rescues NameError
-              monkeypatch = SchemaPlus::ActiveRecord::ConnectionAdapters::IndexDefinition
-              mysql2index.send(:include, monkeypatch) unless mysql2index.include? monkeypatch
-            end
 
             if adapter == 'PostgresqlAdapter'
               ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.send(:include, SchemaPlus::ActiveRecord::ConnectionAdapters::PostgreSQLColumn) unless ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.include?(SchemaPlus::ActiveRecord::ConnectionAdapters::PostgreSQLColumn)
@@ -57,6 +49,7 @@ module SchemaPlus
         # 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
           execute "DROP VIEW IF EXISTS #{quote_table_name(view_name)}" if options[:force]
           execute "CREATE VIEW #{quote_table_name(view_name)} AS #{definition}"
         end
@@ -66,21 +59,6 @@ module SchemaPlus
           execute "DROP VIEW #{quote_table_name(view_name)}"
         end
 
-        #--
-        # these are all expected to be defined by subclasses, listing them
-        # here only as templates.
-        #++
-        # Returns a list of all views (abstract)
-        def views(name = nil) [] end
-        # Returns the SQL definition of a given view (abstract)
-        def view_definition(view_name, name = nil) end
-        # Return the ForeignKeyDefinition objects for foreign key
-        # constraints defined on this table (abstract)
-        def foreign_keys(table_name, name = nil) [] end
-        # Return the ForeignKeyDefinition objects for foreign key
-        # constraints defined on other tables that reference this table
-        # (abstract)
-        def reverse_foreign_keys(table_name, name = nil) [] end
 
         # Define a foreign key constraint.  Valid options are :on_update,
         # :on_delete, and :deferrable, with values as described at
@@ -117,6 +95,31 @@ module SchemaPlus
           drop_table_without_schema_plus(name)
         end
 
+        # called from individual adpaters, after renaming table from old
+        # name to
+        def rename_indexes_and_foreign_keys(oldname, newname) #:nodoc:
+          indexes(newname).select{|index| index.name == index_name(oldname, index.columns)}.each do |index|
+            rename_index(newname, index.name, index_name(newname, index.columns))
+          end
+          foreign_keys(newname).each do |fk|
+            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, index.columns)}
+            begin
+              remove_foreign_key(newname, fk.name)
+            rescue NotImplementedError
+              # sqlite3 can't remove foreign keys, so just skip it
+            end
+            # rename the index only when the fk constraint doesn't exist.
+            # mysql doesn't allow the rename (which is a delete & add)
+            # if the index is on a foreign key constraint
+            rename_index(newname, index.name, ForeignKeyDefinition.auto_index_name(newname, index.columns)) if index
+            begin
+              add_foreign_key(newname, fk.column_names, fk.references_table_name, fk.references_column_names, :name => newname, :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
+            rescue NotImplementedError
+              # sqlite3 can't add foreign keys, so just skip it
+            end
+          end
+        end
+
         # Returns true if the database supports parital indexes (abstract; only
         # Postgresql returns true)
         def supports_partial_indexes?
@@ -146,14 +149,6 @@ module SchemaPlus
           end
         end
 
-        def default_expr_valid?(expr)
-          # override in database specific adaptor
-        end
-
-        def sql_for_function(function_name)
-          # override in database specific adaptor
-        end
-
         # This is define in rails 3.x, but not in rails2.x
         unless defined? ::ActiveRecord::ConnectionAdapters::SchemaStatements::index_name_exists?
           # File activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb, line 403
@@ -163,6 +158,40 @@ module SchemaPlus
             indexes(table_name).detect { |i| i.name == index_name }
           end
         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
+
+        # (abstract) Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on this table
+        def foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
+
+        # (abstract) Return the ForeignKeyDefinition objects for foreign key
+        # constraints defined on other tables that reference this table
+        def reverse_foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
+
+        # (abstract) Return true if the passed expression can be used as a column
+        # default value.  (For most databases the specific expression
+        # doesn't matter, and the adapter's function would return a
+        # constant true if default expressions are supported or false if
+        # they're not.)
+        def default_expr_valid?(expr) raise "Internal Error: Connection adapter didn't override abstract function"; end
+
+        # (abstract) Return SQL definition for a given canonical function_name symbol.
+        # Currently, the only function to support is :now, which should
+        # return a DATETIME object for the current time.
+        def sql_for_function(function_name) raise "Internal Error: Connection adapter didn't override abstract function"; end
 
       end
     end

data/lib/schema_plus/active_record/connection_adapters/foreign_key_definition.rb

@@ -31,7 +31,7 @@ module SchemaPlus
         # possible values.
         attr_reader :on_update
 
-        # The ON_UPDATE behavior for the constraint.  See above for the
+        # The ON_DELETE behavior for the constraint.  See above for the
         # possible values.
         attr_reader :on_delete
 
@@ -39,7 +39,7 @@ module SchemaPlus
         attr_reader :deferrable
 
         # :enddoc:
-        
+
         ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :set_null => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
 
         def initialize(name, table_name, column_names, references_table_name, references_column_names, on_update = nil, on_delete = nil, deferrable = nil)
@@ -105,6 +105,11 @@ module SchemaPlus
         def __unquote(value)
           value.to_s.sub(/^["`](.*)["`]$/, '\1')
         end
+
+        def self.auto_index_name(table_name, column_name)
+          "fk__#{table_name}_#{Array.wrap(column_name).join('_and_')}"
+        end
+
       end
     end
   end

data/lib/schema_plus/active_record/connection_adapters/index_definition.rb

@@ -22,7 +22,7 @@ module SchemaPlus
           # same args as add_index(table_name, column_names, options)
           if args.length == 3 and Hash === args.last
             table_name, column_names, options = args + [{}]
-            initialize_without_schema_plus(table_name, options[:name], options[:unique], column_names, options[:lengths])
+            initialize_without_schema_plus(table_name, options[:name], options[:unique], column_names, options[:lengths], options[:orders])
             @conditions = options[:conditions]
             @expression = options[:expression]
             @kind = options[:kind]
@@ -48,6 +48,7 @@ module SchemaPlus
 
         # tests if the corresponding indexes would be the same
         def ==(other)
+          return false if other.nil?
           return false unless self.name == other.name
           return false unless Array.wrap(self.columns).collect(&:to_s).sort == Array.wrap(other.columns).collect(&:to_s).sort
           return false unless !!self.unique == !!other.unique

data/lib/schema_plus/active_record/connection_adapters/mysql_adapter.rb

@@ -12,6 +12,8 @@ module SchemaPlus
           base.class_eval do
             alias_method_chain :tables, :schema_plus
             alias_method_chain :remove_column, :schema_plus
+            alias_method_chain :rename_table, :schema_plus
+            alias_method_chain :exec_stmt, :schema_plus rescue nil # only defined for mysql not mysql2
           end
         end
 
@@ -26,11 +28,27 @@ module SchemaPlus
           remove_column_without_schema_plus(table_name, column_name)
         end
 
+        def rename_table_with_schema_plus(oldname, newname)
+          rename_table_without_schema_plus(oldname, newname)
+          rename_indexes_and_foreign_keys(oldname, newname)
+        end
+
+        def exec_stmt_with_schema_plus(sql, name, binds, &block)
+          if binds.any?{ |col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+            binds.each_with_index do |(col, val), i|
+              if val.equal? ::ActiveRecord::DB_DEFAULT
+                sql = sql.sub(/(([^?]*?){#{i}}[^?]*)\?/, "\\1DEFAULT")
+              end
+            end
+            binds = binds.reject{|col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+          end
+          exec_stmt_without_schema_plus(sql, name, binds, &block)
+        end
+
         def remove_foreign_key(table_name, foreign_key_name, options = {})
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{foreign_key_name}"
         end
 
-
         def foreign_keys(table_name, name = nil)
           results = execute("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
 

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

@@ -25,10 +25,10 @@ module SchemaPlus
 
         module ClassMethods
           def extract_value_from_default_with_schema_plus(default)
-            
+
 
             value = extract_value_from_default_without_schema_plus(default)
-            
+
             # in some cases (e.g. if change_column_default(table, column,
             # nil) is used), postgresql will return NULL::xxxxx (rather
             # than nil) for a null default -- make sure we treat it as nil,
@@ -50,6 +50,8 @@ module SchemaPlus
         def self.included(base) #:nodoc:
           base.class_eval do
             remove_method :indexes
+            alias_method_chain :rename_table, :schema_plus
+            alias_method_chain :exec_cache, :schema_plus
           end
         end
 
@@ -74,13 +76,24 @@ module SchemaPlus
           index_type = options[:unique] ? "UNIQUE" : ""
           index_name = options[:name] || index_name(table_name, column_names)
           conditions = options[:conditions]
+          kind       = options[:kind]
 
-          if options[:expression] then
-            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{options[:expression]}"
+          if expression = options[:expression] then
+            # Wrap expression in parentheses if necessary
+            expression = "(#{expression})" if expression !~ /(using|with|tablespace|where)/i
+            expression = "USING #{kind} #{expression}" if kind
+            expression = "#{expression} WHERE #{conditions}" if conditions
+
+            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{expression}"
           else
-            quoted_column_names = column_names.map { |e| options[:case_sensitive] == false && e.to_s !~ /_id$/ ? "LOWER(#{quote_column_name(e)})" : quote_column_name(e) }
+            option_strings = Hash[column_names.map {|name| [name, '']}]
+            option_strings = add_index_sort_order(option_strings, column_names, options)
+
+            quoted_column_names = column_names.map { |e| (options[:case_sensitive] == false && e.to_s !~ /_id$/ ? "LOWER(#{quote_column_name(e)})" : quote_column_name(e)) + option_strings[e] }
+            expression = "(#{quoted_column_names.join(', ')})"
+            expression = "USING #{kind} #{expression}" if kind
 
-            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names.join(", ")})"
+            sql = "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{expression}"
             sql += " WHERE (#{ ::ActiveRecord::Base.send(:sanitize_sql, conditions, quote_table_name(table_name)) })" if conditions
           end
           execute sql
@@ -92,23 +105,28 @@ module SchemaPlus
           true
         end
 
+        # This method entirely duplicated from AR's postgresql_adapter.c,
+        # but includes the extra bit to determine the column name for a
+        # case-insensitive index.  (Haven't come up with any clever way to
+        # only code up the case-insensitive column name bit here and
+        # otherwise use the existing method.)
         def indexes(table_name, name = nil) #:nodoc:
-          schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
           result = query(<<-SQL, name)
-           SELECT distinct i.relname, d.indisunique, d.indkey, m.amname, t.oid, 
-                    pg_get_expr(d.indpred, t.oid), pg_get_expr(d.indexprs, t.oid)
-             FROM pg_class t, pg_class i, pg_index d, pg_am m
+
+           SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
+                  m.amname, pg_get_expr(d.indpred, t.oid), pg_get_expr(d.indexprs, t.oid)
+           FROM pg_class t
+           INNER JOIN pg_index d ON t.oid = d.indrelid
+           INNER JOIN pg_class i ON d.indexrelid = i.oid
+           INNER JOIN pg_am m ON i.relam = m.oid
            WHERE i.relkind = 'i'
-             AND i.relam = m.oid
-             AND d.indexrelid = i.oid
              AND d.indisprimary = 'f'
-             AND t.oid = d.indrelid
              AND t.relname = '#{table_name}'
-             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname IN (#{schemas}) )
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
           ORDER BY i.relname
           SQL
 
-          result.map do |(index_name, is_unique, indkey, kind, oid, conditions, expression)|
+          result.map do |(index_name, is_unique, indkey, inddef, oid, kind, conditions, expression)|
             unique = (is_unique == 't')
             index_keys = indkey.split(" ")
 
@@ -120,12 +138,20 @@ module SchemaPlus
             SQL
 
             column_names = columns.values_at(*index_keys).compact
+            # extract column name from the expression, for a
+            # case-insensitive 
             if md = expression.try(:match, /^lower\(\(?([^)]+)\)?(::text)?\)$/i)
               column_names << md[1]
             end
+            
+            # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+            desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
+            orders = desc_order_columns.any? ? Hash[column_names.map {|column| [column, desc_order_columns.include?(column) ? :desc : :asc]}] : {}
+
             ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, column_names,
                                                                     :name => index_name,
                                                                     :unique => unique,
+                                                                    :orders => orders,
                                                                     :conditions => conditions,
                                                                     :case_sensitive => !(expression =~ /lower/i),
                                                                     :kind => kind.downcase == "btree" ? nil : kind,
@@ -133,6 +159,30 @@ module SchemaPlus
           end
         end
 
+        def rename_table_with_schema_plus(oldname, newname) #:nodoc:
+          rename_table_without_schema_plus(oldname, newname)
+          rename_indexes_and_foreign_keys(oldname, newname)
+        end
+
+        # Prepass to replace each ActiveRecord::DB_DEFAULT with a literal
+        # DEFAULT in the sql string.  (The underlying pg gem provides no
+        # way to bind a value that will replace $n with DEFAULT)
+        def exec_cache_with_schema_plus(sql, binds)
+          if binds.any?{ |col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+            j = 0
+            binds.each_with_index do |(col, val), i|
+            if val.equal? ::ActiveRecord::DB_DEFAULT
+              sql = sql.sub(/\$#{i+1}/, 'DEFAULT')
+            else
+              sql = sql.sub(/\$#{i+1}/, "$#{j+1}") if i != j
+              j += 1
+            end
+            end
+            binds = binds.reject{|col, val| val.equal? ::ActiveRecord::DB_DEFAULT}
+          end
+          exec_cache_without_schema_plus(sql, binds)
+        end
+
         def foreign_keys(table_name, name = nil) #:nodoc:
           load_foreign_keys(<<-SQL, name)
         SELECT f.conname, pg_get_constraintdef(f.oid), t.relname
@@ -140,6 +190,7 @@ module SchemaPlus
          WHERE f.conrelid = t.oid
            AND f.contype = 'f'
            AND t.relname = '#{table_name}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
           SQL
         end
 
@@ -151,15 +202,15 @@ module SchemaPlus
            AND f.conrelid = t2.oid
            AND f.contype = 'f'
            AND t.relname = '#{table_name}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
           SQL
         end
 
         def views(name = nil) #:nodoc:
-          schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
           query(<<-SQL, name).map { |row| row[0] }
         SELECT viewname
           FROM pg_views
-         WHERE schemaname IN (#{schemas})
+         WHERE schemaname = ANY (current_schemas(false))
           SQL
         end