def METHOD_NAME():
    """Persistent weak references
    Persistent weak references are used much like Python weak
    references.  The major difference is that you can't specify an
    object to be called when the object is removed from the database.
    Here's an example. We'll start by creating a persistent object and
    a reference to it:
    >>> import transaction
    >>> from persistent.wref import WeakRef
    >>> import ZODB.tests.MinPO
    >>> import ZODB.tests.util
    >>> ob = ZODB.tests.MinPO.MinPO()
    >>> ref = WeakRef(ob)
    >>> ref() is ob
    True
    The hash of the ref is the same as the hash of the referenced object:
    >>> hash(ref) == hash(ob)
    True
    Two refs to the same object are equal:
    >>> WeakRef(ob) == ref
    True
    >>> ob2 = ZODB.tests.MinPO.MinPO(1)
    >>> WeakRef(ob2) == ref
    False
    Lets save the reference and the referenced object in a database:
    >>> db = ZODB.tests.util.DB()
    >>> conn1 = db.open()
    >>> conn1.root()['ob'] = ob
    >>> conn1.root()['ref'] = ref
    >>> transaction.commit()
    If we open a new connection, we can use the reference:
    >>> conn2 = db.open()
    >>> conn2.root()['ref']() is conn2.root()['ob']
    True
    >>> hash(conn2.root()['ref']) == hash(conn2.root()['ob'])
    True
    But if we delete the referenced object and pack:
    >>> del conn2.root()['ob']
    >>> transaction.commit()
    >>> ZODB.tests.util.pack(db)
    And then look in a new connection:
    >>> conn3 = db.open()
    >>> conn3.root()['ob']
    Traceback (most recent call last):
    ...
    KeyError: 'ob'
    Trying to dereference the reference returns None:
    >>> conn3.root()['ref']()
    Trying to get a hash, raises a type error:
    >>> hash(conn3.root()['ref'])
    Traceback (most recent call last):
    ...
    TypeError: Weakly-referenced object has gone away
    Always explicitly close databases: :)
    >>> db.close()
    >>> del ob, ref, db, conn1, conn2, conn3
    When multiple databases are in use, a weakref in one database may
    point to an object in a different database.  Let's create two new
    databases to demonstrate this.
    >>> dbA = ZODB.tests.util.DB(
    ...     database_name = 'dbA',
    ...     )
    >>> dbB = ZODB.tests.util.DB(
    ...     database_name = 'dbB',
    ...     databases = dbA.databases,
    ...     )
    >>> connA1 = dbA.open()
    >>> connB1 = connA1.get_connection('dbB')
    Now create and add a new object and a weak reference, and add them
    to different databases.
    >>> ob = ZODB.tests.MinPO.MinPO()
    >>> ref = WeakRef(ob)
    >>> connA1.root()['ob'] = ob
    >>> connA1.add(ob)
    >>> connB1.root()['ref'] = ref
    >>> transaction.commit()
    After a succesful commit, the reference should know the oid,
    database name and connection of the object.
    >>> ref.oid == ob._p_oid
    True
    >>> ref.database_name == 'dbA'
    True
    >>> ref.dm is ob._p_jar is connA1
    True
    If we open new connections, we should be able to use the reference.
    >>> connA2 = dbA.open()
    >>> connB2 = connA2.get_connection('dbB')
    >>> ref2 = connB2.root()['ref']
    >>> ob2 = connA2.root()['ob']
    >>> ref2() is ob2
    True
    >>> ref2.oid == ob2._p_oid
    True
    >>> ref2.database_name == 'dbA'
    True
    >>> ref2.dm is ob2._p_jar is connA2
    True
    Always explicitly close databases: :)
    >>> dbA.close()
    >>> dbB.close()
    """