Correct ambiguous func / class links

:func:`.sql.expression.select`, :func:`.sql.expression.insert`
and :class:`.sql.expression.Insert` were hitting many ambiguous
symbol errors, due to future.select, as well as the PG/MySQL
variants of Insert.

Change-Id: Iac862bfc172a7f7f0cbba5353a83dc203bed376c

4 files changed, 6 insertions, 6 deletions

diff --git a/doc/build/orm/inheritance.rst b/doc/build/orm/inheritance.rst
index c5e729bcf..e401236d6 100644
--- a/doc/build/orm/inheritance.rst
+++ b/doc/build/orm/inheritance.rst
@@ -632,7 +632,7 @@ domain of concrete inheritance, and we must build a special mapper against
 
     In SQLAlchemy, a mapper for a class always has to refer to some
     "selectable", which is normally a :class:`.Table` but may also refer to any
-    :func:`.select` object as well.   While it may appear that a "single table
+    :func:`~.sql.expression.select` object as well.   While it may appear that a "single table
     inheritance" mapper does not map to a table, these mappers in fact
     implicitly refer to the table that is mapped by a superclass.
 
diff --git a/doc/build/orm/loading_relationships.rst b/doc/build/orm/loading_relationships.rst
index 9da0dfd41..7d6c72a80 100644
--- a/doc/build/orm/loading_relationships.rst
+++ b/doc/build/orm/loading_relationships.rst
@@ -1142,7 +1142,7 @@ Advanced Usage with Arbitrary Statements
 
 The ``alias`` argument can be more creatively used, in that it can be made
 to represent any set of arbitrary names to match up into a statement.
-Below it is linked to a :func:`.select` which links a set of column objects
+Below it is linked to a :func:`~.sql.expression.select` which links a set of column objects
 to a string SQL statement::
 
     # label the columns of the addresses table
diff --git a/doc/build/orm/mapped_sql_expr.rst b/doc/build/orm/mapped_sql_expr.rst
index e04abba80..e819e1ba8 100644
--- a/doc/build/orm/mapped_sql_expr.rst
+++ b/doc/build/orm/mapped_sql_expr.rst
@@ -102,7 +102,7 @@ follows::
         lastname = Column(String(50))
         fullname = column_property(firstname + " " + lastname)
 
-Correlated subqueries may be used as well.  Below we use the :func:`.select`
+Correlated subqueries may be used as well.  Below we use the :func:`~.sql.expression.select`
 construct to create a SELECT that links together the count of ``Address``
 objects available for a particular ``User``::
 
@@ -128,7 +128,7 @@ objects available for a particular ``User``::
                 correlate_except(Address)
         )
 
-In the above example, we define a :func:`.select` construct like the following::
+In the above example, we define a :func:`~.sql.expression.select` construct like the following::
 
     select([func.count(Address.id)]).\
         where(Address.user_id==id).\
@@ -141,7 +141,7 @@ also the name of a Python built in function, which is not what we want to use
 here - if we were outside of the ``User`` class definition, we'd use ``User.id``).
 
 The :meth:`.select.correlate_except` directive indicates that each element in the
-FROM clause of this :func:`.select` may be omitted from the FROM list (that is, correlated
+FROM clause of this :func:`~.sql.expression.select` may be omitted from the FROM list (that is, correlated
 to the enclosing SELECT statement against ``User``) except for the one corresponding
 to ``Address``.  This isn't strictly necessary, but prevents ``Address`` from
 being inadvertently omitted from the FROM list in the case of a long string
diff --git a/doc/build/orm/persistence_techniques.rst b/doc/build/orm/persistence_techniques.rst
index 34703bfbe..6d41f90aa 100644
--- a/doc/build/orm/persistence_techniques.rst
+++ b/doc/build/orm/persistence_techniques.rst
@@ -746,7 +746,7 @@ Comparison to Core Insert / Update Constructs
 ---------------------------------------------
 
 The bulk methods offer performance that under particular circumstances
-can be close to that of using the core :class:`.Insert` and
+can be close to that of using the core :class:`~.sql.expression.Insert` and
 :class:`.Update` constructs in an "executemany" context (for a description
 of "executemany", see :ref:`execute_multiple` in the Core tutorial).
 In order to achieve this, the