- some doc reorg

- change engine.Connection to _connection_cls so sphinx doesn't get upset
- globally add "." to all :class:`Foo`
- start naming sections that are mostly docstrings "API Documentation - blah blah"
- move some ad-hoc docstrings into "API" sections, there is some inconsistency here
and it may be that we just have to leave it that way
- add "internals" rsts to core, orm, I'm not super thrilled how these look but they are
targeted by some of the public api docs, users typically become aware of these anyway

19 files changed, 250 insertions, 250 deletions

diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py
index 77c736f20..ae544584f 100644
--- a/lib/sqlalchemy/dialects/mssql/base.py
+++ b/lib/sqlalchemy/dialects/mssql/base.py
@@ -56,7 +56,7 @@ MSNVarchar, MSText, and MSNText. For example::
     from sqlalchemy.dialects.mssql import VARCHAR
     Column('login', VARCHAR(32, collation='Latin1_General_CI_AS'))
 
-When such a column is associated with a :class:`Table`, the
+When such a column is associated with a :class:`.Table`, the
 CREATE TABLE statement for this column will yield::
 
     login VARCHAR(32) COLLATE Latin1_General_CI_AS NULL
diff --git a/lib/sqlalchemy/dialects/sqlite/base.py b/lib/sqlalchemy/dialects/sqlite/base.py
index 32fe4e612..eb7c6de21 100644
--- a/lib/sqlalchemy/dialects/sqlite/base.py
+++ b/lib/sqlalchemy/dialects/sqlite/base.py
@@ -16,7 +16,7 @@ SQLite does not have built-in DATE, TIME, or DATETIME types, and pysqlite does n
 out of the box functionality for translating values between Python `datetime` objects
 and a SQLite-supported format.  SQLAlchemy's own :class:`~sqlalchemy.types.DateTime`
 and related types provide date formatting and parsing functionality when SQlite is used.
-The implementation classes are :class:`DATETIME`, :class:`DATE` and :class:`TIME`.
+The implementation classes are :class:`.DATETIME`, :class:`.DATE` and :class:`.TIME`.
 These types represent dates and times as ISO formatted strings, which also nicely
 support ordering.   There's no reliance on typical "libc" internals for these functions
 so historical dates are fully supported.
diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index e88ad8265..64dc653ca 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -79,7 +79,7 @@ class Dialect(object):
      initial connection to the database.
 
     execution_ctx_cls
-      a :class:`ExecutionContext` class used to handle statement execution
+      a :class:`.ExecutionContext` class used to handle statement execution
 
     execute_sequence_format
       either the 'tuple' or 'list' type, depending on what cursor.execute()
@@ -213,7 +213,7 @@ class Dialect(object):
     def reflecttable(self, connection, table, include_columns=None):
         """Load table description from the database.
 
-        Given a :class:`~sqlalchemy.engine.Connection` and a
+        Given a :class:`.Connection` and a
         :class:`~sqlalchemy.schema.Table` object, reflect its columns and
         properties from the database.  If include_columns (a list or
         set) is specified, limit the autoload to the given column
@@ -222,7 +222,7 @@ class Dialect(object):
         The default implementation uses the 
         :class:`~sqlalchemy.engine.reflection.Inspector` interface to 
         provide the output, building upon the granular table/column/
-        constraint etc. methods of :class:`Dialect`.
+        constraint etc. methods of :class:`.Dialect`.
 
         """
 
@@ -231,7 +231,7 @@ class Dialect(object):
     def get_columns(self, connection, table_name, schema=None, **kw):
         """Return information about columns in `table_name`.
 
-        Given a :class:`~sqlalchemy.engine.Connection`, a string
+        Given a :class:`.Connection`, a string
         `table_name`, and an optional string `schema`, return column
         information as a list of dictionaries with these keys:
 
@@ -262,7 +262,7 @@ class Dialect(object):
     def get_primary_keys(self, connection, table_name, schema=None, **kw):
         """Return information about primary keys in `table_name`.
 
-        Given a :class:`~sqlalchemy.engine.Connection`, a string
+        Given a :class:`.Connection`, a string
         `table_name`, and an optional string `schema`, return primary
         key information as a list of column names.
 
@@ -288,7 +288,7 @@ class Dialect(object):
     def get_foreign_keys(self, connection, table_name, schema=None, **kw):
         """Return information about foreign_keys in `table_name`.
 
-        Given a :class:`~sqlalchemy.engine.Connection`, a string
+        Given a :class:`.Connection`, a string
         `table_name`, and an optional string `schema`, return foreign
         key information as a list of dicts with these keys:
 
@@ -328,7 +328,7 @@ class Dialect(object):
     def get_view_definition(self, connection, view_name, schema=None, **kw):
         """Return view definition.
 
-        Given a :class:`~sqlalchemy.engine.Connection`, a string
+        Given a :class:`.Connection`, a string
         `view_name`, and an optional string `schema`, return the view
         definition.
         """
@@ -338,7 +338,7 @@ class Dialect(object):
     def get_indexes(self, connection, table_name, schema=None, **kw):
         """Return information about indexes in `table_name`.
 
-        Given a :class:`~sqlalchemy.engine.Connection`, a string
+        Given a :class:`.Connection`, a string
         `table_name` and an optional string `schema`, return index
         information as a list of dictionaries with these keys:
 
@@ -377,7 +377,7 @@ class Dialect(object):
     def has_table(self, connection, table_name, schema=None):
         """Check the existence of a particular table in the database.
 
-        Given a :class:`~sqlalchemy.engine.Connection` object and a string
+        Given a :class:`.Connection` object and a string
         `table_name`, return True if the given table (possibly within
         the specified `schema`) exists in the database, False
         otherwise.
@@ -388,7 +388,7 @@ class Dialect(object):
     def has_sequence(self, connection, sequence_name, schema=None):
         """Check the existence of a particular sequence in the database.
 
-        Given a :class:`~sqlalchemy.engine.Connection` object and a string
+        Given a :class:`.Connection` object and a string
         `sequence_name`, return True if the given sequence exists in
         the database, False otherwise.
         """
@@ -767,11 +767,11 @@ class TypeCompiler(object):
 class Connectable(object):
     """Interface for an object which supports execution of SQL constructs.
 
-    The two implementations of ``Connectable`` are :class:`Connection` and
-    :class:`Engine`.
+    The two implementations of ``Connectable`` are :class:`.Connection` and
+    :class:`.Engine`.
 
     Connectable must also implement the 'dialect' member which references a
-    :class:`Dialect` instance.
+    :class:`.Dialect` instance.
     """
 
     def contextual_connect(self):
@@ -864,7 +864,7 @@ class Connection(Connectable):
         usually an INSERT statement.
         """
 
-        return self.engine.Connection(
+        return self.engine._connection_cls(
                                 self.engine, 
                                 self.__connection, _branch=True)
 
@@ -880,10 +880,10 @@ class Connection(Connectable):
         """ Set non-SQL options for the connection which take effect 
         during execution.
 
-        The method returns a copy of this :class:`Connection` which references
+        The method returns a copy of this :class:`.Connection` which references
         the same underlying DBAPI connection, but also defines the given
         execution options which will take effect for a call to
-        :meth:`execute`. As the new :class:`Connection` references the same
+        :meth:`execute`. As the new :class:`.Connection` references the same
         underlying resource, it is probably best to ensure that the copies
         would be discarded immediately, which is implicit if used as in::
 
@@ -1241,7 +1241,7 @@ class Connection(Connectable):
         * a textual SQL string
         * any :class:`.ClauseElement` construct that is also
           a subclass of :class:`.Executable`, such as a 
-          :func:`.select` construct
+          :func:`expression.select` construct
         * a :class:`.FunctionElement`, such as that generated
           by :attr:`.func`, will be automatically wrapped in
           a SELECT statement, which is then executed.
@@ -1827,14 +1827,14 @@ class Engine(Connectable, log.Identified):
     :class:`~sqlalchemy.engine.base.Dialect` together to provide a source 
     of database connectivity and behavior.
 
-    An :class:`Engine` object is instantiated publically using the 
+    An :class:`.Engine` object is instantiated publically using the 
     :func:`~sqlalchemy.create_engine` function.
 
     """
 
     _execution_options = util.immutabledict()
     _has_events = False
-    Connection = Connection
+    _connection_cls = Connection
 
     def __init__(self, pool, dialect, url, 
                         logging_name=None, echo=None, proxy=None,
@@ -1863,7 +1863,7 @@ class Engine(Connectable, log.Identified):
     dispatch = event.dispatcher(events.ConnectionEvents)
 
     def update_execution_options(self, **opt):
-        """update the execution_options dictionary of this :class:`Engine`.
+        """update the execution_options dictionary of this :class:`.Engine`.
 
         For details on execution_options, see
         :meth:`Connection.execution_options` as well as
@@ -1893,7 +1893,7 @@ class Engine(Connectable, log.Identified):
         return 'Engine(%s)' % str(self.url)
 
     def dispose(self):
-        """Dispose of the connection pool used by this :class:`Engine`.
+        """Dispose of the connection pool used by this :class:`.Engine`.
 
         A new connection pool is created immediately after the old one has
         been disposed.   This new pool, like all SQLAlchemy connection pools,
@@ -2039,7 +2039,7 @@ class Engine(Connectable, log.Identified):
 
         """
 
-        return self.Connection(self, **kwargs)
+        return self._connection_cls(self, **kwargs)
 
     def contextual_connect(self, close_with_result=False, **kwargs):
         """Return a :class:`.Connection` object which may be part of some ongoing context.
@@ -2056,7 +2056,7 @@ class Engine(Connectable, log.Identified):
 
         """
 
-        return self.Connection(self, 
+        return self._connection_cls(self, 
                                     self.pool.connect(), 
                                     close_with_result=close_with_result, 
                                     **kwargs)
diff --git a/lib/sqlalchemy/engine/threadlocal.py b/lib/sqlalchemy/engine/threadlocal.py
index f3e84bef2..45780ad06 100644
--- a/lib/sqlalchemy/engine/threadlocal.py
+++ b/lib/sqlalchemy/engine/threadlocal.py
@@ -36,7 +36,7 @@ class TLConnection(base.Connection):
 class TLEngine(base.Engine):
     """An Engine that includes support for thread-local managed transactions."""
 
-    TLConnection = TLConnection
+    _tl_connection_cls = TLConnection
 
     def __init__(self, *args, **kwargs):
         super(TLEngine, self).__init__(*args, **kwargs)
@@ -52,7 +52,7 @@ class TLEngine(base.Engine):
         if connection is None or connection.closed:
             # guards against pool-level reapers, if desired.
             # or not connection.connection.is_valid:
-            connection = self.TLConnection(self, self.pool.connect(), **kw)
+            connection = self._tl_connection_cls(self, self.pool.connect(), **kw)
             self._connections.conn = conn = weakref.ref(connection)
 
         return connection._increment_connect()
diff --git a/lib/sqlalchemy/ext/declarative.py b/lib/sqlalchemy/ext/declarative.py
index e521ddbbf..8ea76d759 100755
--- a/lib/sqlalchemy/ext/declarative.py
+++ b/lib/sqlalchemy/ext/declarative.py
@@ -211,7 +211,7 @@ class declaration can be referenced directly::
             firstname + " " + lastname
         )
 
-Correlated subqueries reference the :class:`Column` objects they
+Correlated subqueries reference the :class:`.Column` objects they
 need either from the local class definition or from remote 
 classes::
 
@@ -483,7 +483,7 @@ a base class and have all the other classes subclass this class.
 
 When using :mod:`~sqlalchemy.ext.declarative`, this need is met by
 using a "mixin class". A mixin class is one that isn't mapped to a
-table and doesn't subclass the declarative :class:`Base`. For example::
+table and doesn't subclass the declarative :class:`.Base`. For example::
 
     class MyMixin(object):
 
@@ -529,14 +529,14 @@ and ``b.c.id`` are two distinct Python objects, referencing their
 parent tables ``a`` and ``b`` respectively.
 
 In the case of the mixin column, it seems that only one
-:class:`Column` object is explicitly created, yet the ultimate 
+:class:`.Column` object is explicitly created, yet the ultimate 
 ``created_at`` column above must exist as a distinct Python object
 for each separate destination class.  To accomplish this, the declarative
-extension creates a **copy** of each :class:`Column` object encountered on 
+extension creates a **copy** of each :class:`.Column` object encountered on 
 a class that is detected as a mixin.
 
 This copy mechanism is limited to simple columns that have no foreign
-keys, as a :class:`ForeignKey` itself contains references to columns
+keys, as a :class:`.ForeignKey` itself contains references to columns
 which can't be properly recreated at this level.  For columns that 
 have foreign keys, as well as for the variety of mapper-level constructs
 that require destination-explicit context, the
@@ -557,7 +557,7 @@ patterns common to many classes can be defined as callables::
 
 Where above, the ``address_id`` class-level callable is executed at the 
 point at which the ``User`` class is constructed, and the declarative
-extension can use the resulting :class:`Column` object as returned by
+extension can use the resulting :class:`.Column` object as returned by
 the method without the need to copy it.
 
 Columns generated by :func:`~.declared_attr` can also be
@@ -1406,7 +1406,7 @@ def declarative_base(bind=None, metadata=None, mapper=None, cls=object,
       cls.__init__ by way of the normal Python semantics.
 
     :param metaclass:
-      Defaults to :class:`DeclarativeMeta`.  A metaclass or __metaclass__
+      Defaults to :class:`.DeclarativeMeta`.  A metaclass or __metaclass__
       compatible callable to use as the meta type of the generated
       declarative base class.
 
diff --git a/lib/sqlalchemy/interfaces.py b/lib/sqlalchemy/interfaces.py
index 07e574ba5..d1e3fa6b2 100644
--- a/lib/sqlalchemy/interfaces.py
+++ b/lib/sqlalchemy/interfaces.py
@@ -15,9 +15,9 @@ event system.
 from sqlalchemy import event, util
 
 class PoolListener(object):
-    """Hooks into the lifecycle of connections in a :class:`Pool`.
+    """Hooks into the lifecycle of connections in a :class:`.Pool`.
 
-    .. note:: :class:`PoolListener` is deprecated.   Please
+    .. note:: :class:`.PoolListener` is deprecated.   Please
        refer to :class:`.PoolEvents`.
 
     Usage::
@@ -71,7 +71,7 @@ class PoolListener(object):
 
     @classmethod
     def _adapt_listener(cls, self, listener):
-        """Adapt a :class:`PoolListener` to individual
+        """Adapt a :class:`.PoolListener` to individual
         :class:`event.Dispatch` events.
 
         """
@@ -149,8 +149,8 @@ class PoolListener(object):
 class ConnectionProxy(object):
     """Allows interception of statement execution by Connections.
 
-    .. note:: :class:`ConnectionProxy` is deprecated.   Please
-       refer to :class:`.EngineEvents`.
+    .. note:: :class:`.ConnectionProxy` is deprecated.   Please
+       refer to :class:`.ConnectionEvents`.
 
     Either or both of the ``execute()`` and ``cursor_execute()``
     may be implemented to intercept compiled statement and
diff --git a/lib/sqlalchemy/log.py b/lib/sqlalchemy/log.py
index adfede75f..e77730a98 100644
--- a/lib/sqlalchemy/log.py
+++ b/lib/sqlalchemy/log.py
@@ -168,7 +168,7 @@ class InstanceLogger(object):
         return level
 
 def instance_logger(instance, echoflag=None):
-    """create a logger for an instance that implements :class:`Identified`."""
+    """create a logger for an instance that implements :class:`.Identified`."""
 
     if instance.logging_name:
         name = "%s.%s.%s" % (instance.__class__.__module__,
diff --git a/lib/sqlalchemy/orm/__init__.py b/lib/sqlalchemy/orm/__init__.py
index 4de507fa5..6e4a552c9 100644
--- a/lib/sqlalchemy/orm/__init__.py
+++ b/lib/sqlalchemy/orm/__init__.py
@@ -114,7 +114,7 @@ def scoped_session(session_factory, scopefunc=None):
     :class:`.ScopedSession`.
 
     :param session_factory: a callable function that produces
-      :class:`Session` instances, such as :func:`sessionmaker`.
+      :class:`.Session` instances, such as :func:`sessionmaker`.
 
     :param scopefunc: Optional "scope" function which would be
       passed to the :class:`.ScopedRegistry`.  If None, the
@@ -153,7 +153,7 @@ def create_session(bind=None, **kwargs):
       :class:`~sqlalchemy.orm.session.Session`.
 
     :param \*\*kwargs: optional, passed through to the
-      :class:`Session` constructor.
+      :class:`.Session` constructor.
 
     :returns: an :class:`~sqlalchemy.orm.session.Session` instance
 
@@ -183,7 +183,7 @@ def relationship(argument, secondary=None, **kwargs):
        :func:`relation` prior to version 0.6.
 
     This corresponds to a parent-child or associative table relationship.  The
-    constructed class is an instance of :class:`RelationshipProperty`.
+    constructed class is an instance of :class:`.RelationshipProperty`.
 
     A typical :func:`relationship`::
 
@@ -192,7 +192,7 @@ def relationship(argument, secondary=None, **kwargs):
        })
 
     :param argument:
-      a class or :class:`Mapper` instance, representing the target of
+      a class or :class:`.Mapper` instance, representing the target of
       the relationship.
 
     :param secondary:
@@ -283,7 +283,7 @@ def relationship(argument, secondary=None, **kwargs):
       :ref:`custom_collections`.
 
     :param comparator_factory:
-      a class which extends :class:`RelationshipProperty.Comparator` which
+      a class which extends :class:`.RelationshipProperty.Comparator` which
       provides custom SQL clause generation for comparison operations.
 
     :param doc:
@@ -539,7 +539,7 @@ def dynamic_loader(argument, secondary=None, primaryjoin=None,
     """Construct a dynamically-loading mapper property.
 
     This property is similar to :func:`relationship`, except read
-    operations return an active :class:`Query` object which reads from
+    operations return an active :class:`.Query` object which reads from
     the database when accessed.  Items may be appended to the
     attribute via ``append()``, or removed via ``remove()``; changes
     will be persisted to the database during a :meth:`Sesion.flush`.
@@ -550,7 +550,7 @@ def dynamic_loader(argument, secondary=None, primaryjoin=None,
     here.
 
     :param argument:
-      a class or :class:`Mapper` instance, representing the target of
+      a class or :class:`.Mapper` instance, representing the target of
       the relationship.
 
     :param secondary:
@@ -688,7 +688,7 @@ def backref(name, **kwargs):
     return (name, kwargs)
 
 def deferred(*columns, **kwargs):
-    """Return a :class:`DeferredColumnProperty`, which indicates this
+    """Return a :class:`.DeferredColumnProperty`, which indicates this
     object attributes should only be loaded from its corresponding
     table column when first accessed.
 
@@ -777,7 +777,7 @@ def mapper(class_, local_table=None, *args, **params):
            condition contains no ForeignKey columns, specify the "foreign"
            columns of the join condition in this list. else leave as None.
 
-        :param non_primary: Construct a :class:`Mapper` that will define only
+        :param non_primary: Construct a :class:`.Mapper` that will define only
            the selection of instances, not their persistence. Any number of
            non_primary mappers may be created for a particular class.
 
@@ -845,7 +845,7 @@ def mapper(class_, local_table=None, *args, **params):
            that will be used to keep a running version id of mapped entities
            in the database. this is used during save operations to ensure that
            no other thread or process has updated the instance during the
-           lifetime of the entity, else a :class:`StaleDataError` exception is
+           lifetime of the entity, else a :class:`.StaleDataError` exception is
            thrown.
 
         :param version_id_generator: A callable which defines the algorithm
diff --git a/lib/sqlalchemy/orm/attributes.py b/lib/sqlalchemy/orm/attributes.py
index 437de685c..ead62d1fe 100644
--- a/lib/sqlalchemy/orm/attributes.py
+++ b/lib/sqlalchemy/orm/attributes.py
@@ -1000,7 +1000,7 @@ class History(tuple):
         return self != HISTORY_BLANK
 
     def empty(self):
-        """Return True if this :class:`History` has no changes
+        """Return True if this :class:`.History` has no changes
         and no existing, unchanged state.
 
         """
@@ -1030,7 +1030,7 @@ class History(tuple):
                 (self.deleted or [])
 
     def has_changes(self):
-        """Return True if this :class:`History` has changes."""
+        """Return True if this :class:`.History` has changes."""
 
         return bool(self.added or self.deleted)
 
diff --git a/lib/sqlalchemy/orm/deprecated_interfaces.py b/lib/sqlalchemy/orm/deprecated_interfaces.py
index 9ebf9a57e..d5a9ab9c6 100644
--- a/lib/sqlalchemy/orm/deprecated_interfaces.py
+++ b/lib/sqlalchemy/orm/deprecated_interfaces.py
@@ -521,7 +521,7 @@ class AttributeExtension(object):
             'bar':relationship(Bar, extension=MyAttrExt())
         })
 
-    Note that the :class:`AttributeExtension` methods
+    Note that the :class:`.AttributeExtension` methods
     :meth:`~.AttributeExtension.append` and
     :meth:`~.AttributeExtension.set` need to return the
     ``value`` parameter. The returned value is used as the
diff --git a/lib/sqlalchemy/orm/descriptor_props.py b/lib/sqlalchemy/orm/descriptor_props.py
index 634da34f1..5ad148a7e 100644
--- a/lib/sqlalchemy/orm/descriptor_props.py
+++ b/lib/sqlalchemy/orm/descriptor_props.py
@@ -19,7 +19,7 @@ from sqlalchemy.sql import expression
 properties = util.importlater('sqlalchemy.orm', 'properties')
 
 class DescriptorProperty(MapperProperty):
-    """:class:`MapperProperty` which proxies access to a 
+    """:class:`.MapperProperty` which proxies access to a 
         user-defined descriptor."""
 
     doc = None
@@ -290,7 +290,7 @@ class CompositeProperty(DescriptorProperty):
         return str(self.parent.class_.__name__) + "." + self.key
 
 class ConcreteInheritedProperty(DescriptorProperty):
-    """A 'do nothing' :class:`MapperProperty` that disables 
+    """A 'do nothing' :class:`.MapperProperty` that disables 
     an attribute on a concrete subclass that is only present
     on the inherited mapper, not the concrete classes' mapper.
 
diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py
index fdbee98b3..8c12e72b1 100644
--- a/lib/sqlalchemy/orm/events.py
+++ b/lib/sqlalchemy/orm/events.py
@@ -919,7 +919,7 @@ class AttributeEvents(event.Events):
         listen(UserContact.phone, 'set', validate_phone, retval=True)
 
     A validation function like the above can also raise an exception
-    such as :class:`ValueError` to halt the operation.
+    such as :class:`.ValueError` to halt the operation.
 
     Several modifiers are available to the :func:`~.event.listen` function.
 
diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py
index 969905641..c73aaeb00 100644
--- a/lib/sqlalchemy/orm/properties.py
+++ b/lib/sqlalchemy/orm/properties.py
@@ -787,7 +787,7 @@ class RelationshipProperty(StrategizedProperty):
         Make several attempts to determine if cols are compared using 
         "=" or other comparators (in which case suggest viewonly), 
         columns are present but not part of the expected mappings, columns
-        don't have any :class:`ForeignKey` information on them, or 
+        don't have any :class:`.ForeignKey` information on them, or 
         the ``foreign_keys`` attribute is being used incorrectly.
 
         """
diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py
index 534985084..dcfbf3b32 100644
--- a/lib/sqlalchemy/orm/query.py
+++ b/lib/sqlalchemy/orm/query.py
@@ -696,7 +696,7 @@ class Query(object):
 
     @_generative()
     def populate_existing(self):
-        """Return a :class:`Query` that will expire and refresh all instances 
+        """Return a :class:`.Query` that will expire and refresh all instances 
         as they are loaded, or reused from the current :class:`.Session`.
 
         :meth:`.populate_existing` does not improve behavior when 
@@ -900,12 +900,12 @@ class Query(object):
     @_generative()
     def with_hint(self, selectable, text, dialect_name='*'):
         """Add an indexing hint for the given entity or selectable to 
-        this :class:`Query`.
+        this :class:`.Query`.
 
         Functionality is passed straight through to 
         :meth:`~sqlalchemy.sql.expression.Select.with_hint`, 
         with the addition that ``selectable`` can be a 
-        :class:`Table`, :class:`Alias`, or ORM entity / mapped class 
+        :class:`.Table`, :class:`.Alias`, or ORM entity / mapped class 
         /etc.
         """
         mapper, selectable, is_aliased_class = _entity_info(selectable)
@@ -1755,7 +1755,7 @@ class Query(object):
     @property
     def column_descriptions(self):
         """Return metadata about the columns which would be 
-        returned by this :class:`Query`.
+        returned by this :class:`.Query`.
 
         Format is a list of dictionaries::
 
diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py
index eb148bc78..baf3b6d42 100644
--- a/lib/sqlalchemy/orm/session.py
+++ b/lib/sqlalchemy/orm/session.py
@@ -961,7 +961,7 @@ class Session(object):
         To expire individual objects and individual attributes 
         on those objects, use :meth:`Session.expire`.
 
-        The :class:`Session` object's default behavior is to 
+        The :class:`.Session` object's default behavior is to 
         expire all state whenever the :meth:`Session.rollback`
         or :meth:`Session.commit` methods are called, so that new
         state can be loaded for the new transaction.   For this reason,
@@ -986,7 +986,7 @@ class Session(object):
         To expire all objects in the :class:`.Session` simultaneously,
         use :meth:`Session.expire_all`.
 
-        The :class:`Session` object's default behavior is to 
+        The :class:`.Session` object's default behavior is to 
         expire all state whenever the :meth:`Session.rollback`
         or :meth:`Session.commit` methods are called, so that new
         state can be loaded for the new transaction.   For this reason,
diff --git a/lib/sqlalchemy/pool.py b/lib/sqlalchemy/pool.py
index a45c2e80b..fa9582010 100644
--- a/lib/sqlalchemy/pool.py
+++ b/lib/sqlalchemy/pool.py
@@ -36,7 +36,7 @@ def manage(module, **params):
     :param module: a DB-API 2.0 database module
 
     :param poolclass: the class used by the pool module to provide
-      pooling.  Defaults to :class:`QueuePool`.
+      pooling.  Defaults to :class:`.QueuePool`.
 
     :param \*\*params: will be passed through to *poolclass*
 
@@ -491,7 +491,7 @@ class SingletonThreadPool(Pool):
     Maintains one connection per each thread, never moving a connection to a
     thread other than the one which it was created in.
 
-    Options are the same as those of :class:`Pool`, as well as:
+    Options are the same as those of :class:`.Pool`, as well as:
 
     :param pool_size: The number of threads in which to maintain connections 
         at once.  Defaults to five.
@@ -560,7 +560,7 @@ class SingletonThreadPool(Pool):
         return c
 
 class QueuePool(Pool):
-    """A :class:`Pool` that imposes a limit on the number of open connections.
+    """A :class:`.Pool` that imposes a limit on the number of open connections.
 
     :class:`.QueuePool` is the default pooling implementation used for 
     all :class:`.Engine` objects, unless the SQLite dialect is in use.
diff --git a/lib/sqlalchemy/schema.py b/lib/sqlalchemy/schema.py
index d1eb12f4f..70d9013d6 100644
--- a/lib/sqlalchemy/schema.py
+++ b/lib/sqlalchemy/schema.py
@@ -96,9 +96,9 @@ class Table(SchemaItem, expression.TableClause):
     :param name: The name of this table as represented in the database. 
 
         This property, along with the *schema*, indicates the *singleton
-        identity* of this table in relation to its parent :class:`MetaData`.
-        Additional calls to :class:`Table` with the same name, metadata,
-        and schema name will return the same :class:`Table` object.
+        identity* of this table in relation to its parent :class:`.MetaData`.
+        Additional calls to :class:`.Table` with the same name, metadata,
+        and schema name will return the same :class:`.Table` object.
 
         Names which contain no upper case characters
         will be treated as case insensitive names, and will not be quoted
@@ -107,17 +107,17 @@ class Table(SchemaItem, expression.TableClause):
         behavior applies even for databases which standardize upper 
         case names as case insensitive such as Oracle.
 
-    :param metadata: a :class:`MetaData` object which will contain this 
+    :param metadata: a :class:`.MetaData` object which will contain this 
         table.  The metadata is used as a point of association of this table
         with other tables which are referenced via foreign key.  It also
         may be used to associate this table with a particular 
         :class:`~sqlalchemy.engine.base.Connectable`.
 
     :param \*args: Additional positional arguments are used primarily
-        to add the list of :class:`Column` objects contained within this
+        to add the list of :class:`.Column` objects contained within this
         table. Similar to the style of a CREATE TABLE statement, other
         :class:`.SchemaItem` constructs may be added here, including
-        :class:`PrimaryKeyConstraint`, and :class:`ForeignKeyConstraint`.
+        :class:`.PrimaryKeyConstraint`, and :class:`.ForeignKeyConstraint`.
 
     :param autoload: Defaults to False: the Columns for this table should 
         be reflected from the database. Usually there will be no Column
@@ -159,7 +159,7 @@ class Table(SchemaItem, expression.TableClause):
                 ])
 
     :param mustexist: When ``True``, indicates that this Table must already 
-        be present in the given :class:`MetaData`` collection.
+        be present in the given :class:`.MetaData`` collection.
 
     :param prefixes:
         A list of strings to insert after CREATE in the CREATE TABLE
@@ -180,10 +180,10 @@ class Table(SchemaItem, expression.TableClause):
         for the engine's database connection. Defaults to ``None``.
 
     :param useexisting: When ``True``, indicates that if this Table is already
-        present in the given :class:`MetaData`, apply further arguments within
-        the constructor to the existing :class:`Table`. If this flag is not
+        present in the given :class:`.MetaData`, apply further arguments within
+        the constructor to the existing :class:`.Table`. If this flag is not
         set, an error is raised when the parameters of an existing
-        :class:`Table` are overwritten.
+        :class:`.Table` are overwritten.
 
     """
 
@@ -453,8 +453,8 @@ class Table(SchemaItem, expression.TableClause):
 
 
     def tometadata(self, metadata, schema=RETAIN_SCHEMA):
-        """Return a copy of this :class:`Table` associated with a different
-        :class:`MetaData`.
+        """Return a copy of this :class:`.Table` associated with a different
+        :class:`.MetaData`.
 
         E.g.::
 
@@ -522,7 +522,7 @@ class Column(SchemaItem, expression.ColumnClause):
 
           The name field may be omitted at construction time and applied
           later, at any time before the Column is associated with a 
-          :class:`Table`.  This is to support convenient
+          :class:`.Table`.  This is to support convenient
           usage within the :mod:`~sqlalchemy.ext.declarative` extension.
 
         :param type\_: The column's type, indicated using an instance which 
@@ -540,7 +540,7 @@ class Column(SchemaItem, expression.ColumnClause):
           or specified by keyword.
 
           There is partial support for automatic detection of the 
-          type based on that of a :class:`ForeignKey` associated 
+          type based on that of a :class:`.ForeignKey` associated 
           with this column, if the type is specified as ``None``. 
           However, this feature is not fully implemented and 
           may not function in all cases.
@@ -548,8 +548,8 @@ class Column(SchemaItem, expression.ColumnClause):
         :param \*args: Additional positional arguments include various 
           :class:`.SchemaItem` derived constructs which will be applied 
           as options to the column.  These include instances of 
-          :class:`Constraint`, :class:`ForeignKey`, :class:`ColumnDefault`, 
-          and :class:`Sequence`.  In some cases an equivalent keyword 
+          :class:`.Constraint`, :class:`.ForeignKey`, :class:`.ColumnDefault`, 
+          and :class:`.Sequence`.  In some cases an equivalent keyword 
           argument is available such as ``server_default``, ``default``
           and ``unique``.
 
@@ -600,7 +600,7 @@ class Column(SchemaItem, expression.ColumnClause):
             :class:`~sqlalchemy.sql.expression.ClauseElement` representing the
             *default value* for this column, which will be invoked upon insert
             if this column is otherwise not specified in the VALUES clause of
-            the insert. This is a shortcut to using :class:`ColumnDefault` as
+            the insert. This is a shortcut to using :class:`.ColumnDefault` as
             a positional argument.
 
             Contrast this argument to ``server_default`` which creates a 
@@ -611,15 +611,15 @@ class Column(SchemaItem, expression.ColumnClause):
             comments (a future attribute 'comment' will achieve that).
 
         :param key: An optional string identifier which will identify this
-            ``Column`` object on the :class:`Table`. When a key is provided,
+            ``Column`` object on the :class:`.Table`. When a key is provided,
             this is the only identifier referencing the ``Column`` within the
             application, including ORM attribute mapping; the ``name`` field
             is used only when rendering SQL.
 
         :param index: When ``True``, indicates that the column is indexed.
-            This is a shortcut for using a :class:`Index` construct on the
+            This is a shortcut for using a :class:`.Index` construct on the
             table. To specify indexes with explicit names or indexes that
-            contain multiple columns, use the :class:`Index` construct
+            contain multiple columns, use the :class:`.Index` construct
             instead.
 
         :param info: A dictionary which defaults to ``{}``. A space to store
@@ -635,16 +635,16 @@ class Column(SchemaItem, expression.ColumnClause):
             default value to be applied to the column within UPDATE
             statements, which wil be invoked upon update if this column is not
             present in the SET clause of the update. This is a shortcut to
-            using :class:`ColumnDefault` as a positional argument with
+            using :class:`.ColumnDefault` as a positional argument with
             ``for_update=True``.
 
         :param primary_key: If ``True``, marks this column as a primary key
             column. Multiple columns can have this flag set to specify
             composite primary keys. As an alternative, the primary key of a
-            :class:`Table` can be specified via an explicit
-            :class:`PrimaryKeyConstraint` object.
+            :class:`.Table` can be specified via an explicit
+            :class:`.PrimaryKeyConstraint` object.
 
-        :param server_default: A :class:`FetchedValue` instance, str, Unicode
+        :param server_default: A :class:`.FetchedValue` instance, str, Unicode
             or :func:`~sqlalchemy.sql.expression.text` construct representing
             the DDL DEFAULT value for the column.
 
@@ -661,16 +661,16 @@ class Column(SchemaItem, expression.ColumnClause):
 
                 y DATETIME DEFAULT NOW()
 
-            Strings and text() will be converted into a :class:`DefaultClause`
+            Strings and text() will be converted into a :class:`.DefaultClause`
             object upon initialization.
 
-            Use :class:`FetchedValue` to indicate that an already-existing
+            Use :class:`.FetchedValue` to indicate that an already-existing
             column will generate a default value on the database side which
             will be available to SQLAlchemy for post-fetch after inserts. This
             construct does not specify any DDL and the implementation is left
             to the database, such as via a trigger.
 
-        :param server_onupdate:   A :class:`FetchedValue` instance
+        :param server_onupdate:   A :class:`.FetchedValue` instance
              representing a database-side default generation function. This
              indicates to SQLAlchemy that a newly generated value will be
              available after updates. This construct does not specify any DDL
@@ -687,10 +687,10 @@ class Column(SchemaItem, expression.ColumnClause):
 
         :param unique: When ``True``, indicates that this column contains a
              unique constraint, or if ``index`` is ``True`` as well, indicates
-             that the :class:`Index` should be created with the unique flag.
+             that the :class:`.Index` should be created with the unique flag.
              To specify multiple columns in the constraint/index or to specify
-             an explicit name, use the :class:`UniqueConstraint` or
-             :class:`Index` constructs explicitly.
+             an explicit name, use the :class:`.UniqueConstraint` or
+             :class:`.Index` constructs explicitly.
 
         """
 
@@ -978,7 +978,7 @@ class Column(SchemaItem, expression.ColumnClause):
 class ForeignKey(SchemaItem):
     """Defines a dependency between two columns.
 
-    ``ForeignKey`` is specified as an argument to a :class:`Column` object,
+    ``ForeignKey`` is specified as an argument to a :class:`.Column` object,
     e.g.::
 
         t = Table("remote_table", metadata, 
@@ -987,24 +987,24 @@ class ForeignKey(SchemaItem):
 
     Note that ``ForeignKey`` is only a marker object that defines
     a dependency between two columns.   The actual constraint
-    is in all cases represented by the :class:`ForeignKeyConstraint`
+    is in all cases represented by the :class:`.ForeignKeyConstraint`
     object.   This object will be generated automatically when
-    a ``ForeignKey`` is associated with a :class:`Column` which 
-    in turn is associated with a :class:`Table`.   Conversely,
-    when :class:`ForeignKeyConstraint` is applied to a :class:`Table`,
+    a ``ForeignKey`` is associated with a :class:`.Column` which 
+    in turn is associated with a :class:`.Table`.   Conversely,
+    when :class:`.ForeignKeyConstraint` is applied to a :class:`.Table`,
     ``ForeignKey`` markers are automatically generated to be
-    present on each associated :class:`Column`, which are also
+    present on each associated :class:`.Column`, which are also
     associated with the constraint object.
 
     Note that you cannot define a "composite" foreign key constraint,
     that is a constraint between a grouping of multiple parent/child
     columns, using ``ForeignKey`` objects.   To define this grouping,
-    the :class:`ForeignKeyConstraint` object must be used, and applied
-    to the :class:`Table`.   The associated ``ForeignKey`` objects
+    the :class:`.ForeignKeyConstraint` object must be used, and applied
+    to the :class:`.Table`.   The associated ``ForeignKey`` objects
     are created automatically.
 
     The ``ForeignKey`` objects associated with an individual 
-    :class:`Column` object are available in the `foreign_keys` collection
+    :class:`.Column` object are available in the `foreign_keys` collection
     of that column.
 
     Further examples of foreign key configuration are in
@@ -1020,12 +1020,12 @@ class ForeignKey(SchemaItem):
         """
         Construct a column-level FOREIGN KEY.
 
-        The :class:`ForeignKey` object when constructed generates a
-        :class:`ForeignKeyConstraint` which is associated with the parent
-        :class:`Table` object's collection of constraints.
+        The :class:`.ForeignKey` object when constructed generates a
+        :class:`.ForeignKeyConstraint` which is associated with the parent
+        :class:`.Table` object's collection of constraints.
 
         :param column: A single target column for the key relationship. A
-            :class:`Column` object or a column name as a string:
+            :class:`.Column` object or a column name as a string:
             ``tablename.columnkey`` or ``schema.tablename.columnkey``.
             ``columnkey`` is the ``key`` which has been assigned to the column
             (defaults to the column name itself), unless ``link_to_name`` is
@@ -1053,7 +1053,7 @@ class ForeignKey(SchemaItem):
             assigned ``key``.
 
         :param use_alter: passed to the underlying
-            :class:`ForeignKeyConstraint` to indicate the constraint should be
+            :class:`.ForeignKeyConstraint` to indicate the constraint should be
             generated/dropped externally from the CREATE TABLE/ DROP TABLE
             statement. See that classes' constructor for details.
 
@@ -1081,16 +1081,16 @@ class ForeignKey(SchemaItem):
         return "ForeignKey(%r)" % self._get_colspec()
 
     def copy(self, schema=None):
-        """Produce a copy of this :class:`ForeignKey` object.
+        """Produce a copy of this :class:`.ForeignKey` object.
 
-        The new :class:`ForeignKey` will not be bound
-        to any :class:`Column`.
+        The new :class:`.ForeignKey` will not be bound
+        to any :class:`.Column`.
 
         This method is usually used by the internal
-        copy procedures of :class:`Column`, :class:`Table`,
-        and :class:`MetaData`.
+        copy procedures of :class:`.Column`, :class:`.Table`,
+        and :class:`.MetaData`.
 
-        :param schema: The returned :class:`ForeignKey` will
+        :param schema: The returned :class:`.ForeignKey` will
           reference the original table and column name, qualified
           by the given string schema name.
 
@@ -1110,7 +1110,7 @@ class ForeignKey(SchemaItem):
         return fk
 
     def _get_colspec(self, schema=None):
-        """Return a string based 'column specification' for this :class:`ForeignKey`.
+        """Return a string based 'column specification' for this :class:`.ForeignKey`.
 
         This is usually the equivalent of the string-based "tablename.colname"
         argument first passed to the object's constructor.
@@ -1131,16 +1131,16 @@ class ForeignKey(SchemaItem):
     target_fullname = property(_get_colspec)
 
     def references(self, table):
-        """Return True if the given :class:`Table` is referenced by this :class:`ForeignKey`."""
+        """Return True if the given :class:`.Table` is referenced by this :class:`.ForeignKey`."""
 
         return table.corresponding_column(self.column) is not None
 
     def get_referent(self, table):
         """Return the :class:`.Column` in the given :class:`.Table` 
-        referenced by this :class:`ForeignKey`.
+        referenced by this :class:`.ForeignKey`.
 
-        Returns None if this :class:`ForeignKey` does not reference the given
-        :class:`Table`.
+        Returns None if this :class:`.ForeignKey` does not reference the given
+        :class:`.Table`.
 
         """
 
@@ -1150,7 +1150,7 @@ class ForeignKey(SchemaItem):
     def column(self):
         """Return the target :class:`.Column` referenced by this :class:`.ForeignKey`.
 
-        If this :class:`ForeignKey` was created using a
+        If this :class:`.ForeignKey` was created using a
         string-based target column specification, this
         attribute will on first access initiate a resolution
         process to locate the referenced remote
@@ -1789,8 +1789,8 @@ class ForeignKeyConstraint(Constraint):
 
     Defines a single column or composite FOREIGN KEY ... REFERENCES
     constraint. For a no-frills, single column foreign key, adding a
-    :class:`ForeignKey` to the definition of a :class:`Column` is a shorthand
-    equivalent for an unnamed, single column :class:`ForeignKeyConstraint`.
+    :class:`.ForeignKey` to the definition of a :class:`.Column` is a shorthand
+    equivalent for an unnamed, single column :class:`.ForeignKeyConstraint`.
 
     Examples of foreign key configuration are in :ref:`metadata_foreignkeys`.
 
@@ -1835,7 +1835,7 @@ class ForeignKeyConstraint(Constraint):
           ALTER TABLE statement issued after the full collection of tables
           have been created, and drop it via an ALTER TABLE statement before
           the full collection of tables are dropped. This is shorthand for the
-          usage of :class:`AddConstraint` and :class:`DropConstraint` applied
+          usage of :class:`.AddConstraint` and :class:`.DropConstraint` applied
           as "after-create" and "before-drop" events on the MetaData object.
           This is normally used to generate/drop constraints on objects that
           are mutually dependent on each other.
@@ -2446,7 +2446,7 @@ class DDLElement(expression.Executable, expression.ClauseElement):
         A DDLElement instance can be linked to any number of schema items. 
 
         ``execute_at`` builds on the ``append_ddl_listener`` interface of
-        :class:`MetaData` and :class:`Table` objects.
+        :class:`.MetaData` and :class:`.Table` objects.
 
         Caveat: Creating or dropping a Table in isolation will also trigger
         any DDL set to ``execute_at`` that Table's MetaData.  This may change
diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py
index afae611a6..9aed957d2 100644
--- a/lib/sqlalchemy/sql/expression.py
+++ b/lib/sqlalchemy/sql/expression.py
@@ -7,12 +7,12 @@
 """Defines the base components of SQL expression trees.
 
 All components are derived from a common base class
-:class:`ClauseElement`.  Common behaviors are organized
+:class:`.ClauseElement`.  Common behaviors are organized
 based on class hierarchies, in some cases via mixins.
 
 All object construction from this package occurs via functions which
-in some cases will construct composite :class:`ClauseElement` structures
-together, and in other cases simply return a single :class:`ClauseElement`
+in some cases will construct composite :class:`.ClauseElement` structures
+together, and in other cases simply return a single :class:`.ClauseElement`
 constructed directly.  The function interface affords a more "DSL-ish"
 feel to constructing SQL expressions and also allows future class
 reorganizations.
@@ -95,10 +95,10 @@ def asc(column):
 def outerjoin(left, right, onclause=None):
     """Return an ``OUTER JOIN`` clause element.
 
-    The returned object is an instance of :class:`Join`.
+    The returned object is an instance of :class:`.Join`.
 
     Similar functionality is also available via the :func:`outerjoin()`
-    method on any :class:`FromClause`.
+    method on any :class:`.FromClause`.
 
     left
       The left side of the join.
@@ -112,7 +112,7 @@ def outerjoin(left, right, onclause=None):
       otherwise.
 
     To chain joins together, use the :func:`join()` or :func:`outerjoin()`
-    methods on the resulting :class:`Join` object.
+    methods on the resulting :class:`.Join` object.
 
     """
     return Join(left, right, onclause, isouter=True)
@@ -120,10 +120,10 @@ def outerjoin(left, right, onclause=None):
 def join(left, right, onclause=None, isouter=False):
     """Return a ``JOIN`` clause element (regular inner join).
 
-    The returned object is an instance of :class:`Join`.
+    The returned object is an instance of :class:`.Join`.
 
     Similar functionality is also available via the :func:`join()` method
-    on any :class:`FromClause`.
+    on any :class:`.FromClause`.
 
     left
       The left side of the join.
@@ -137,7 +137,7 @@ def join(left, right, onclause=None, isouter=False):
       otherwise.
 
     To chain joins together, use the :func:`join()` or :func:`outerjoin()`
-    methods on the resulting :class:`Join` object.
+    methods on the resulting :class:`.Join` object.
 
     """
     return Join(left, right, onclause, isouter)
@@ -146,20 +146,20 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
     """Returns a ``SELECT`` clause element.
 
     Similar functionality is also available via the :func:`select()`
-    method on any :class:`FromClause`.
+    method on any :class:`.FromClause`.
 
-    The returned object is an instance of :class:`Select`.
+    The returned object is an instance of :class:`.Select`.
 
-    All arguments which accept :class:`ClauseElement` arguments also accept
+    All arguments which accept :class:`.ClauseElement` arguments also accept
     string arguments, which will be converted as appropriate into
     either :func:`text()` or :func:`literal_column()` constructs.
 
     :param columns:
-      A list of :class:`ClauseElement` objects, typically
-      :class:`ColumnElement` objects or subclasses, which will form the
+      A list of :class:`.ClauseElement` objects, typically
+      :class:`.ColumnElement` objects or subclasses, which will form the
       columns clause of the resulting statement. For all members which are
-      instances of :class:`Selectable`, the individual :class:`ColumnElement`
-      members of the :class:`Selectable` will be added individually to the
+      instances of :class:`.Selectable`, the individual :class:`.ColumnElement`
+      members of the :class:`.Selectable` will be added individually to the
       columns clause. For example, specifying a
       :class:`~sqlalchemy.schema.Table` instance will result in all the
       contained :class:`~sqlalchemy.schema.Column` objects within to be added
@@ -169,17 +169,17 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
       available on :class:`~sqlalchemy.schema.Table`.
 
     :param whereclause:
-      A :class:`ClauseElement` expression which will be used to form the
+      A :class:`.ClauseElement` expression which will be used to form the
       ``WHERE`` clause.
 
     :param from_obj:
-      A list of :class:`ClauseElement` objects which will be added to the
+      A list of :class:`.ClauseElement` objects which will be added to the
       ``FROM`` clause of the resulting statement. Note that "from" objects are
       automatically located within the columns and whereclause ClauseElements.
       Use this parameter to explicitly specify "from" objects which are not
       automatically locatable. This could include
       :class:`~sqlalchemy.schema.Table` objects that aren't otherwise present,
-      or :class:`Join` objects whose presence will supercede that of the
+      or :class:`.Join` objects whose presence will supercede that of the
       :class:`~sqlalchemy.schema.Table` objects already located in the other
       clauses.
 
@@ -196,10 +196,10 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
       :class:`.ClauseElement` members.
 
     :param correlate=True:
-      indicates that this :class:`Select` object should have its
-      contained :class:`FromClause` elements "correlated" to an enclosing
-      :class:`Select` object.  This means that any :class:`ClauseElement`
-      instance within the "froms" collection of this :class:`Select`
+      indicates that this :class:`.Select` object should have its
+      contained :class:`.FromClause` elements "correlated" to an enclosing
+      :class:`.Select` object.  This means that any :class:`.ClauseElement`
+      instance within the "froms" collection of this :class:`.Select`
       which is also present in the "froms" collection of an
       enclosing select will not be rendered in the ``FROM`` clause
       of this select statement.
@@ -229,11 +229,11 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
       NOWAIT``.
 
     :param group_by:
-      a list of :class:`ClauseElement` objects which will comprise the
+      a list of :class:`.ClauseElement` objects which will comprise the
       ``GROUP BY`` clause of the resulting select.
 
     :param having:
-      a :class:`ClauseElement` that will comprise the ``HAVING`` clause
+      a :class:`.ClauseElement` that will comprise the ``HAVING`` clause
       of the resulting select when ``GROUP BY`` is used.
 
     :param limit=None:
@@ -249,11 +249,11 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
       functionality.
 
     :param order_by:
-      a scalar or list of :class:`ClauseElement` objects which will
+      a scalar or list of :class:`.ClauseElement` objects which will
       comprise the ``ORDER BY`` clause of the resulting select.
 
     :param prefixes:
-      a list of strings or :class:`ClauseElement` objects to include
+      a list of strings or :class:`.ClauseElement` objects to include
       directly after the SELECT keyword in the generated statement,
       for dialect-specific query features.  ``prefixes`` is
       also available via the :meth:`~.Select.prefix_with`
@@ -265,7 +265,7 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
       column with its parent table's (or aliases) name so that name
       conflicts between columns in different tables don't occur.
       The format of the label is <tablename>_<column>.  The "c"
-      collection of the resulting :class:`Select` object will use these
+      collection of the resulting :class:`.Select` object will use these
       names as well for targeting column members.
       
       use_labels is also available via the :meth:`~._SelectBase.apply_labels`
@@ -276,8 +276,8 @@ def select(columns=None, whereclause=None, from_obj=[], **kwargs):
                   **kwargs)
 
 def subquery(alias, *args, **kwargs):
-    """Return an :class:`Alias` object derived 
-    from a :class:`Select`.
+    """Return an :class:`.Alias` object derived 
+    from a :class:`.Select`.
 
     name
       alias name
@@ -291,7 +291,7 @@ def subquery(alias, *args, **kwargs):
     return Select(*args, **kwargs).alias(alias)
 
 def insert(table, values=None, inline=False, **kwargs):
-    """Return an :class:`Insert` clause element.
+    """Return an :class:`.Insert` clause element.
 
     Similar functionality is available via the :func:`insert()` method on
     :class:`~sqlalchemy.schema.Table`.
@@ -332,14 +332,14 @@ def insert(table, values=None, inline=False, **kwargs):
     return Insert(table, values, inline=inline, **kwargs)
 
 def update(table, whereclause=None, values=None, inline=False, **kwargs):
-    """Return an :class:`Update` clause element.
+    """Return an :class:`.Update` clause element.
 
     Similar functionality is available via the :func:`update()` method on
     :class:`~sqlalchemy.schema.Table`.
 
     :param table: The table to be updated.
 
-    :param whereclause: A :class:`ClauseElement` describing the ``WHERE``
+    :param whereclause: A :class:`.ClauseElement` describing the ``WHERE``
      condition of the ``UPDATE`` statement. Note that the
      :meth:`~Update.where()` generative method may also be used for this.
 
@@ -382,14 +382,14 @@ def update(table, whereclause=None, values=None, inline=False, **kwargs):
             **kwargs)
 
 def delete(table, whereclause = None, **kwargs):
-    """Return a :class:`Delete` clause element.
+    """Return a :class:`.Delete` clause element.
 
     Similar functionality is available via the :func:`delete()` method on
     :class:`~sqlalchemy.schema.Table`.
 
     :param table: The table to be updated.
 
-    :param whereclause: A :class:`ClauseElement` describing the ``WHERE``
+    :param whereclause: A :class:`.ClauseElement` describing the ``WHERE``
       condition of the ``UPDATE`` statement. Note that the
       :meth:`~Delete.where()` generative method may be used instead.
 
@@ -534,7 +534,7 @@ def collate(expression, collation):
         operators.collate, type_=expr.type)
 
 def exists(*args, **kwargs):
-    """Return an ``EXISTS`` clause as applied to a :class:`Select` object.
+    """Return an ``EXISTS`` clause as applied to a :class:`.Select` object.
 
     Calling styles are of the following forms::
 
@@ -556,13 +556,13 @@ def union(*selects, **kwargs):
     """Return a ``UNION`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     A similar :func:`union()` method is available on all
-    :class:`FromClause` subclasses.
+    :class:`.FromClause` subclasses.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
        available keyword arguments are the same as those of
@@ -575,13 +575,13 @@ def union_all(*selects, **kwargs):
     """Return a ``UNION ALL`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     A similar :func:`union_all()` method is available on all
-    :class:`FromClause` subclasses.
+    :class:`.FromClause` subclasses.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
       available keyword arguments are the same as those of
@@ -594,10 +594,10 @@ def except_(*selects, **kwargs):
     """Return an ``EXCEPT`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
       available keyword arguments are the same as those of
@@ -610,10 +610,10 @@ def except_all(*selects, **kwargs):
     """Return an ``EXCEPT ALL`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
       available keyword arguments are the same as those of
@@ -626,10 +626,10 @@ def intersect(*selects, **kwargs):
     """Return an ``INTERSECT`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
       available keyword arguments are the same as those of
@@ -642,10 +642,10 @@ def intersect_all(*selects, **kwargs):
     """Return an ``INTERSECT ALL`` of multiple selectables.
 
     The returned object is an instance of
-    :class:`CompoundSelect`.
+    :class:`.CompoundSelect`.
 
     \*selects
-      a list of :class:`Select` instances.
+      a list of :class:`.Select` instances.
 
     \**kwargs
       available keyword arguments are the same as those of
@@ -694,7 +694,7 @@ def alias(selectable, name=None):
 def literal(value, type_=None):
     """Return a literal clause, bound to a bind parameter.
 
-    Literal clauses are created automatically when non- :class:`ClauseElement`
+    Literal clauses are created automatically when non- :class:`.ClauseElement`
     objects (such as strings, ints, dates, etc.) are used in a comparison
     operation with a :class:`_CompareMixin`
     subclass, such as a :class:`~sqlalchemy.schema.Column` object. Use this function to force the
@@ -772,19 +772,19 @@ def type_coerce(expr, type_):
 
 def label(name, obj):
     """Return a :class:`_Label` object for the
-    given :class:`ColumnElement`.
+    given :class:`.ColumnElement`.
 
     A label changes the name of an element in the columns clause of a
     ``SELECT`` statement, typically via the ``AS`` SQL keyword.
 
     This functionality is more conveniently available via the
-    :func:`label()` method on :class:`ColumnElement`.
+    :func:`label()` method on :class:`.ColumnElement`.
 
     name
       label name
 
     obj
-      a :class:`ColumnElement`.
+      a :class:`.ColumnElement`.
 
     """
     return _Label(name, obj)
@@ -794,7 +794,7 @@ def column(text, type_=None):
     ``SELECT`` statement.
 
     The object returned is an instance of
-    :class:`ColumnClause`, which represents the
+    :class:`.ColumnClause`, which represents the
     "syntactical" portion of the schema-level
     :class:`~sqlalchemy.schema.Column` object.
 
@@ -836,7 +836,7 @@ def literal_column(text, type_=None):
     return ColumnClause(text, type_=type_, is_literal=True)
 
 def table(name, *columns):
-    """Return a :class:`TableClause` object.
+    """Return a :class:`.TableClause` object.
 
     This is a primitive version of the :class:`~sqlalchemy.schema.Table` object,
     which is a subclass of this object.
@@ -876,7 +876,7 @@ def bindparam(key, value=None, type_=None, unique=False, required=False, callabl
           if True, the key name of this BindParamClause will be
           modified if another :class:`_BindParamClause` of the same name
           already has been located within the containing
-          :class:`ClauseElement`.
+          :class:`.ClauseElement`.
 
         :param required:
           a value is required at execution time.
@@ -957,7 +957,7 @@ def text(text, bind=None, *args, **kwargs):
 
     Using :func:`text` explicitly usually implies the construction
     of a full, standalone statement.   As such, SQLAlchemy refers
-    to it as an :class:`Executable` object, and it supports
+    to it as an :class:`.Executable` object, and it supports
     the :meth:`Executable.execution_options` method.  For example,
     a :func:`text` construct that should be subject to "autocommit"
     can be set explicitly so using the ``autocommit`` option::
@@ -1038,7 +1038,7 @@ def null():
     return _Null()
 
 class _FunctionGenerator(object):
-    """Generate :class:`Function` objects based on getattr calls."""
+    """Generate :class:`.Function` objects based on getattr calls."""
 
     def __init__(self, **opts):
         self.__names = []
@@ -1262,7 +1262,7 @@ def _generative(fn, *args, **kw):
 
 
 def is_column(col):
-    """True if ``col`` is an instance of :class:`ColumnElement`."""
+    """True if ``col`` is an instance of :class:`.ColumnElement`."""
 
     return isinstance(col, ColumnElement)
 
@@ -1406,7 +1406,7 @@ class ClauseElement(Visitable):
 
         \**kw are arguments consumed by subclass compare() methods and
         may be used to modify the criteria for comparison.
-        (see :class:`ColumnElement`)
+        (see :class:`.ColumnElement`)
 
         """
         return self is other
@@ -1421,7 +1421,7 @@ class ClauseElement(Visitable):
         pass
 
     def get_children(self, **kwargs):
-        """Return immediate child elements of this :class:`ClauseElement`.
+        """Return immediate child elements of this :class:`.ClauseElement`.
 
         This is used for visit traversal.
 
@@ -1466,7 +1466,7 @@ class ClauseElement(Visitable):
                               ':class:`.Executable` may provide the '
                               ':func:`.execute` method.')
     def execute(self, *multiparams, **params):
-        """Compile and execute this :class:`ClauseElement`.
+        """Compile and execute this :class:`.ClauseElement`.
 
         """
         e = self.bind
@@ -1481,7 +1481,7 @@ class ClauseElement(Visitable):
                               ':class:`.Executable` may provide the '
                               ':func:`.scalar` method.')
     def scalar(self, *multiparams, **params):
-        """Compile and execute this :class:`ClauseElement`, returning
+        """Compile and execute this :class:`.ClauseElement`, returning
         the result's scalar representation.
 
         """
@@ -1499,7 +1499,7 @@ class ClauseElement(Visitable):
 
         :param bind: An ``Engine`` or ``Connection`` from which a
             ``Compiled`` will be acquired. This argument takes precedence over
-            this :class:`ClauseElement`'s bound engine, if any.
+            this :class:`.ClauseElement`'s bound engine, if any.
 
         :param column_keys: Used for INSERT and UPDATE statements, a list of
             column names which should be present in the VALUES clause of the
@@ -1508,7 +1508,7 @@ class ClauseElement(Visitable):
 
         :param dialect: A ``Dialect`` instance frmo which a ``Compiled``
             will be acquired. This argument takes precedence over the `bind`
-            argument as well as this :class:`ClauseElement`'s bound engine, if
+            argument as well as this :class:`.ClauseElement`'s bound engine, if
             any.
 
         :param inline: Used for INSERT statements, for a dialect which does
@@ -1715,7 +1715,7 @@ class ColumnOperators(Operators):
         return self.reverse_operate(operators.truediv, other)
 
 class _CompareMixin(ColumnOperators):
-    """Defines comparison and math operations for :class:`ClauseElement`
+    """Defines comparison and math operations for :class:`.ClauseElement`
     instances."""
 
     def __compare(self, op, obj, negate=None, reverse=False,
@@ -1961,7 +1961,7 @@ class _CompareMixin(ColumnOperators):
           somecolumn * 5
 
         :param operator: a string which will be output as the infix operator
-          between this :class:`ClauseElement` and the expression passed to the
+          between this :class:`.ClauseElement` and the expression passed to the
           generated function.
 
         This function can also be used to make bitwise operators explicit. For
@@ -2003,17 +2003,17 @@ class ColumnElement(ClauseElement, _CompareMixin):
 
     This includes columns associated with tables, aliases, and
     subqueries, expressions, function calls, SQL keywords such as
-    ``NULL``, literals, etc.  :class:`ColumnElement` is the ultimate base
+    ``NULL``, literals, etc.  :class:`.ColumnElement` is the ultimate base
     class for all such elements.
 
-    :class:`ColumnElement` supports the ability to be a *proxy* element,
-    which indicates that the :class:`ColumnElement` may be associated with
-    a :class:`Selectable` which was derived from another :class:`Selectable`.
-    An example of a "derived" :class:`Selectable` is an :class:`Alias` of a
+    :class:`.ColumnElement` supports the ability to be a *proxy* element,
+    which indicates that the :class:`.ColumnElement` may be associated with
+    a :class:`.Selectable` which was derived from another :class:`.Selectable`.
+    An example of a "derived" :class:`.Selectable` is an :class:`.Alias` of a
     :class:`~sqlalchemy.schema.Table`.
 
-    A :class:`ColumnElement`, by subclassing the :class:`_CompareMixin` mixin
-    class, provides the ability to generate new :class:`ClauseElement`
+    A :class:`.ColumnElement`, by subclassing the :class:`_CompareMixin` mixin
+    class, provides the ability to generate new :class:`.ClauseElement`
     objects using Python expressions.  See the :class:`_CompareMixin`
     docstring for more details.
 
@@ -2043,14 +2043,14 @@ class ColumnElement(ClauseElement, _CompareMixin):
         return s
 
     def shares_lineage(self, othercolumn):
-        """Return True if the given :class:`ColumnElement` 
-        has a common ancestor to this :class:`ColumnElement`."""
+        """Return True if the given :class:`.ColumnElement` 
+        has a common ancestor to this :class:`.ColumnElement`."""
 
         return bool(self.proxy_set.intersection(othercolumn.proxy_set))
 
     def _make_proxy(self, selectable, name=None):
-        """Create a new :class:`ColumnElement` representing this
-        :class:`ColumnElement` as it appears in the select list of a
+        """Create a new :class:`.ColumnElement` representing this
+        :class:`.ColumnElement` as it appears in the select list of a
         descending selectable.
 
         """
@@ -2278,7 +2278,7 @@ class FromClause(Selectable):
 
     def count(self, whereclause=None, **params):
         """return a SELECT COUNT generated against this
-        :class:`FromClause`."""
+        :class:`.FromClause`."""
 
         if self.primary_key:
             col = list(self.primary_key)[0]
@@ -2291,19 +2291,19 @@ class FromClause(Selectable):
                     **params)
 
     def select(self, whereclause=None, **params):
-        """return a SELECT of this :class:`FromClause`."""
+        """return a SELECT of this :class:`.FromClause`."""
 
         return select([self], whereclause, **params)
 
     def join(self, right, onclause=None, isouter=False):
-        """return a join of this :class:`FromClause` against another
-        :class:`FromClause`."""
+        """return a join of this :class:`.FromClause` against another
+        :class:`.FromClause`."""
 
         return Join(self, right, onclause, isouter)
 
     def outerjoin(self, right, onclause=None):
-        """return an outer join of this :class:`FromClause` against another
-        :class:`FromClause`."""
+        """return an outer join of this :class:`.FromClause` against another
+        :class:`.FromClause`."""
 
         return Join(self, right, onclause, True)
 
@@ -2332,7 +2332,7 @@ class FromClause(Selectable):
 
     def replace_selectable(self, old, alias):
         """replace all occurrences of FromClause 'old' with the given Alias 
-        object, returning a copy of this :class:`FromClause`.
+        object, returning a copy of this :class:`.FromClause`.
 
         """
 
@@ -2352,20 +2352,20 @@ class FromClause(Selectable):
         return col
 
     def corresponding_column(self, column, require_embedded=False):
-        """Given a :class:`ColumnElement`, return the exported
-        :class:`ColumnElement` object from this :class:`Selectable`
+        """Given a :class:`.ColumnElement`, return the exported
+        :class:`.ColumnElement` object from this :class:`.Selectable`
         which corresponds to that original
         :class:`~sqlalchemy.schema.Column` via a common anscestor
         column.
 
-        :param column: the target :class:`ColumnElement` to be matched
+        :param column: the target :class:`.ColumnElement` to be matched
 
         :param require_embedded: only return corresponding columns for
-        the given :class:`ColumnElement`, if the given
-        :class:`ColumnElement` is actually present within a sub-element
-        of this :class:`FromClause`.  Normally the column will match if
+        the given :class:`.ColumnElement`, if the given
+        :class:`.ColumnElement` is actually present within a sub-element
+        of this :class:`.FromClause`.  Normally the column will match if
         it merely shares a common anscestor with one of the exported
-        columns of this :class:`FromClause`.
+        columns of this :class:`.FromClause`.
 
         """
 
@@ -2521,7 +2521,7 @@ class _BindParamClause(ColumnElement):
           if True, the key name of this BindParamClause will be
           modified if another :class:`_BindParamClause` of the same name
           already has been located within the containing
-          :class:`ClauseElement`.
+          :class:`.ClauseElement`.
 
         :param required:
           a value is required at execution time.
@@ -2620,7 +2620,7 @@ class _Generative(object):
 class Executable(_Generative):
     """Mark a ClauseElement as supporting execution.
 
-    :class:`Executable` is a superclass for all "statement" types
+    :class:`.Executable` is a superclass for all "statement" types
     of objects, including :func:`select`, :func:`delete`, :func:`update`,
     :func:`insert`, :func:`text`.
 
@@ -2894,7 +2894,7 @@ class ClauseList(ClauseElement):
             return self
 
     def compare(self, other, **kw):
-        """Compare this :class:`ClauseList` to the given :class:`ClauseList`,
+        """Compare this :class:`.ClauseList` to the given :class:`.ClauseList`,
         including a comparison of all the clause items.
 
         """
@@ -3064,7 +3064,7 @@ class FunctionElement(Executable, ColumnElement, FromClause):
 
     def select(self):
         """Produce a :func:`~.expression.select` construct 
-        against this :class:`FunctionElement`.
+        against this :class:`.FunctionElement`.
         
         This is shorthand for::
         
@@ -3207,7 +3207,7 @@ class _UnaryExpression(ColumnElement):
 
     def compare(self, other, **kw):
         """Compare this :class:`_UnaryExpression` against the given
-        :class:`ClauseElement`."""
+        :class:`.ClauseElement`."""
 
         return (
             isinstance(other, _UnaryExpression) and
@@ -3347,12 +3347,12 @@ class _Exists(_UnaryExpression):
         return e
 
 class Join(FromClause):
-    """represent a ``JOIN`` construct between two :class:`FromClause`
+    """represent a ``JOIN`` construct between two :class:`.FromClause`
     elements.
 
-    The public constructor function for :class:`Join` is the module-level
+    The public constructor function for :class:`.Join` is the module-level
     :func:`join()` function, as well as the :func:`join()` method available
-    off all :class:`FromClause` subclasses.
+    off all :class:`.FromClause` subclasses.
 
     """
     __visit_name__ = 'join'
@@ -3420,7 +3420,7 @@ class Join(FromClause):
         return sqlutil.join_condition(left, right, a_subset=left_right)
 
     def select(self, whereclause=None, fold_equivalents=False, **kwargs):
-        """Create a :class:`Select` from this :class:`Join`.
+        """Create a :class:`.Select` from this :class:`.Join`.
         
         The equivalent long-hand form, given a :class:`.Join` object
         ``j``, is::
@@ -3437,7 +3437,7 @@ class Join(FromClause):
           :class:`.Join`, do not include
           repeat column names in the column list of the resulting
           select, for columns that are calculated to be "equivalent"
-          based on the join criterion of this :class:`Join`. This will
+          based on the join criterion of this :class:`.Join`. This will
           recursively apply to any joins directly nested by this one
           as well.
 
@@ -3714,7 +3714,7 @@ class _Label(ColumnElement):
 
     This object is constructed from the :func:`label()` module level
     function as well as the :func:`label()` method available on all
-    :class:`ColumnElement` subclasses.
+    :class:`.ColumnElement` subclasses.
 
     """
 
@@ -3782,7 +3782,7 @@ class ColumnClause(_Immutable, ColumnElement):
 
     This includes columns associated with tables, aliases and select
     statements, but also any arbitrary text.  May or may not be bound
-    to an underlying :class:`Selectable`.  :class:`ColumnClause` is usually
+    to an underlying :class:`.Selectable`.  :class:`.ColumnClause` is usually
     created publically via the :func:`column()` function or the
     :func:`literal_column()` function.
 
@@ -3793,15 +3793,15 @@ class ColumnClause(_Immutable, ColumnElement):
       parent selectable.
 
     type
-      ``TypeEngine`` object which can associate this :class:`ColumnClause`
+      ``TypeEngine`` object which can associate this :class:`.ColumnClause`
       with a type.
 
     is_literal
-      if True, the :class:`ColumnClause` is assumed to be an exact
+      if True, the :class:`.ColumnClause` is assumed to be an exact
       expression that will be delivered to the output with no quoting
       rules applied regardless of case sensitive settings.  the
       :func:`literal_column()` function is usually used to create such a
-      :class:`ColumnClause`.
+      :class:`.ColumnClause`.
 
     """
     __visit_name__ = 'column'
@@ -3931,7 +3931,7 @@ class TableClause(_Immutable, FromClause):
 
     def count(self, whereclause=None, **params):
         """return a SELECT COUNT generated against this
-        :class:`TableClause`."""
+        :class:`.TableClause`."""
 
         if self.primary_key:
             col = list(self.primary_key)[0]
@@ -3964,7 +3964,7 @@ class TableClause(_Immutable, FromClause):
         return [self]
 
 class _SelectBase(Executable, FromClause):
-    """Base class for :class:`Select` and ``CompoundSelects``."""
+    """Base class for :class:`.Select` and ``CompoundSelects``."""
 
     _order_by_clause = ClauseList()
     _group_by_clause = ClauseList()
@@ -4385,7 +4385,7 @@ class Select(_SelectBase):
     @_generative
     def with_hint(self, selectable, text, dialect_name='*'):
         """Add an indexing hint for the given selectable to this
-        :class:`Select`.
+        :class:`.Select`.
 
         The text of the hint is rendered in the appropriate
         location for the database backend in use, relative
@@ -4857,7 +4857,7 @@ class ValuesBase(UpdateBase):
 class Insert(ValuesBase):
     """Represent an INSERT construct.
 
-    The :class:`Insert` object is created using the :func:`insert()` function.
+    The :class:`.Insert` object is created using the :func:`insert()` function.
 
     """
     __visit_name__ = 'insert'
@@ -4907,7 +4907,7 @@ class Insert(ValuesBase):
 class Update(ValuesBase):
     """Represent an Update construct.
 
-    The :class:`Update` object is created using the :func:`update()` function.
+    The :class:`.Update` object is created using the :func:`update()` function.
 
     """
     __visit_name__ = 'update'
@@ -4959,7 +4959,7 @@ class Update(ValuesBase):
 class Delete(UpdateBase):
     """Represent a DELETE construct.
 
-    The :class:`Delete` object is created using the :func:`delete()` function.
+    The :class:`.Delete` object is created using the :func:`delete()` function.
 
     """
 
diff --git a/lib/sqlalchemy/types.py b/lib/sqlalchemy/types.py
index 69776b133..100a20c6e 100644
--- a/lib/sqlalchemy/types.py
+++ b/lib/sqlalchemy/types.py
@@ -257,7 +257,7 @@ class UserDefinedType(TypeEngine):
     """Base for user defined types.
 
     This should be the base of new types.  Note that
-    for most cases, :class:`TypeDecorator` is probably
+    for most cases, :class:`.TypeDecorator` is probably
     more appropriate::
 
       import sqlalchemy.types as types
@@ -549,7 +549,7 @@ class TypeDecorator(TypeEngine):
             return op, typ
 
 class MutableType(object):
-    """A mixin that marks a :class:`TypeEngine` as representing
+    """A mixin that marks a :class:`.TypeEngine` as representing
     a mutable Python object type.   This functionality is used
     only by the ORM.
 
@@ -568,10 +568,10 @@ class MutableType(object):
     that changes are detected.  These rules may have a significant 
     performance impact, described below.
 
-    A :class:`MutableType` usually allows a flag called
+    A :class:`.MutableType` usually allows a flag called
     ``mutable=False`` to enable/disable the "mutability" flag,
     represented on this class by :meth:`is_mutable`.  Examples 
-    include :class:`PickleType` and 
+    include :class:`.PickleType` and 
     :class:`~sqlalchemy.dialects.postgresql.base.ARRAY`.  Setting
     this flag to ``True`` enables mutability-specific behavior
     by the ORM.
@@ -592,7 +592,7 @@ class MutableType(object):
         one to its "clean"
         value. So for example, if the Session contains 6000 objects (a
         fairly large amount) and autoflush is enabled, every individual
-        execution of :class:`Query` will require a full scan of that subset of
+        execution of :class:`.Query` will require a full scan of that subset of
         the 6000 objects that have mutable attributes, possibly resulting
         in tens of thousands of additional method calls for every query.
 
@@ -875,7 +875,7 @@ class Text(String):
 class Unicode(String):
     """A variable length Unicode string.
 
-    The ``Unicode`` type is a :class:`String` which converts Python
+    The ``Unicode`` type is a :class:`.String` which converts Python
     ``unicode`` objects (i.e., strings that are defined as
     ``u'somevalue'``) into encoded bytestrings when passing the value
     to the database driver, and similarly decodes values from the
@@ -931,7 +931,7 @@ class Unicode(String):
 class UnicodeText(Text):
     """An unbounded-length Unicode string.
 
-    See :class:`Unicode` for details on the unicode
+    See :class:`.Unicode` for details on the unicode
     behavior of this object.
 
     Like ``Unicode``, usage the ``UnicodeText`` type implies a 
@@ -1001,7 +1001,7 @@ class SmallInteger(Integer):
     """A type for smaller ``int`` integers.
 
     Typically generates a ``SMALLINT`` in DDL, and otherwise acts like
-    a normal :class:`Integer` on the Python side.
+    a normal :class:`.Integer` on the Python side.
 
     """
 
@@ -1012,7 +1012,7 @@ class BigInteger(Integer):
     """A type for bigger ``int`` integers.
 
     Typically generates a ``BIGINT`` in DDL, and otherwise acts like
-    a normal :class:`Integer` on the Python side.
+    a normal :class:`.Integer` on the Python side.
 
     """
 
@@ -1181,7 +1181,7 @@ class Float(Numeric):
         :param precision: the numeric precision for use in DDL ``CREATE
            TABLE``.
 
-        :param asdecimal: the same flag as that of :class:`Numeric`, but
+        :param asdecimal: the same flag as that of :class:`.Numeric`, but
           defaults to ``False``.   Note that setting this flag to ``True``
           results in floating point conversion.