Changeset 673 for trunk/docs


Ignore:
Timestamp:
Dec 30, 2015, 11:41:21 AM (4 years ago)
Author:
cito
Message:

Adapt docs to new class names in version 5

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/docs/pg.txt

    r671 r673  
    1818The :mod:`pg` module handles three types of objects,
    1919
    20 - the :class:`pgobject`, which handles the connection
     20- the :class:`Connection` instances, which handle the connection
    2121  and all the requests to the database,
    22 - the :class:`pglarge` object, which handles
     22- the :class:`LargeObject` instances, which handle
    2323  all the accesses to PostgreSQL large objects,
    24 - the :class:`pgqueryobject` that handles query results
     24- the :class:`Query` instances that handle query results
    2525
    2626and it provides a convenient wrapper class :class:`DB`
    27 for the :class:`pgobject`.
     27for the basic :class:`Connection` class.
    2828
    2929If you want to see a simple example of the use of some of these functions,
    30 see the :doc:`examples` page.
     30please have a look at the :doc:`examples`.
    3131
    3232
     
    6969    :param passwd: password for user (*None* = :data:`defpasswd`)
    7070    :type passwd: str or None
    71     :returns: If successful, the :class:`pgobject` handling the connection
    72     :rtype: :class:`pgobject`
     71    :returns: If successful, the :class:`Connection` handling the connection
     72    :rtype: :class:`Connection`
    7373    :raises TypeError: bad argument type, or too many arguments
    7474    :raises SyntaxError: duplicate argument definition
     
    309309must be escaped to prevent them from being interpreted specially
    310310by the SQL parser. :func:`escape_string` performs this operation.
    311 Note that there is also a :class:`pgobject` method with the same name
     311Note that there is also a :class:`Connection` method with the same name
    312312which takes connection properties into account.
    313313
     
    340340As with :func:`escape_string`, this is only used when inserting data directly
    341341into an SQL command string.
    342 Note that there is also a :class:`pgobject` method with the same name
     342Note that there is also a :class:`Connection` method with the same name
    343343which takes connection properties into account.
    344344
     
    363363Converts an escaped string representation of binary data into binary
    364364data -- the reverse of :func:`escape_bytea`. This is needed when retrieving
    365 ``bytea`` data with one of the :meth:`pgqueryobject.getresult`,
    366 :meth:`pgqueryobject.dictresult` or :meth:`pgqueryobject.namedresult` methods.
     365``bytea`` data with one of the :meth:`Query.getresult`,
     366:meth:`Query.dictresult` or :meth:`Query.namedresult` methods.
    367367
    368368Example::
     
    468468
    469469This function returns the function used by PyGreSQL to construct the
    470 result of the :meth:`pgqueryobject.namedresult` method.
     470result of the :meth:`Query.namedresult` method.
    471471
    472472.. function:: set_namedresult(func)
     
    477477
    478478You can use this if you want to create different kinds of named tuples
    479 returned by the :meth:`pgqueryobject.namedresult` method.
     479returned by the :meth:`Query.namedresult` method.
    480480
    481481
     
    489489.. data:: version, __version__
    490490
    491    constants that give the current version
     491    constants that give the current version
    492492
    493493.. data:: INV_READ, INV_WRITE
    494494
    495    large objects access modes,
    496    used by :meth:`pgobject.locreate` and :meth:`pglarge.open`
     495    large objects access modes,
     496    used by :meth:`Connection.locreate` and :meth:`LargeObject.open`
    497497
    498498.. data:: SEEK_SET, SEEK_CUR, SEEK_END:
    499499
    500    positional flags, used by :meth:`pglarge.seek`
    501 
    502 
    503 pgobject -- The connection object
     500    positional flags, used by :meth:`LargeObject.seek`
     501
     502
     503Connection -- The connection object
    504504=================================
    505505
    506 .. class:: pgobject
     506.. class:: Connection
    507507
    508508This object handles a connection to a PostgreSQL database. It embeds and
     
    512512.. note::
    513513
    514    Some methods give direct access to the connection socket.
    515    *Do not use them unless you really know what you are doing.*
    516    If you prefer disabling them,
    517    set the ``-DNO_DIRECT`` option in the Python setup file.
    518    These methods are specified by the tag [DA].
     514    Some methods give direct access to the connection socket.
     515    *Do not use them unless you really know what you are doing.*
     516    If you prefer disabling them,
     517    set the ``-DNO_DIRECT`` option in the Python setup file.
     518    These methods are specified by the tag [DA].
    519519
    520520.. note::
    521521
    522    Some other methods give access to large objects
    523    (refer to PostgreSQL user manual for more information about these).
    524    If you want to forbid access to these from the module,
    525    set the ``-DNO_LARGE`` option in the Python setup file.
    526    These methods are specified by the tag [LO].
     522    Some other methods give access to large objects
     523    (refer to PostgreSQL user manual for more information about these).
     524    If you want to forbid access to these from the module,
     525    set the ``-DNO_LARGE`` option in the Python setup file.
     526    These methods are specified by the tag [LO].
    527527
    528528query -- execute a SQL command string
    529529-------------------------------------
    530530
    531 .. method:: pgobject.query(command, [args])
     531.. method:: Connection.query(command, [args])
    532532
    533533    Execute a SQL command string
     
    536536    :param args: optional positional arguments
    537537    :returns: result values
    538     :rtype: :class:`pgqueryobject`, None
     538    :rtype: :class:`Query`, None
    539539    :raises TypeError: bad argument type, or too many arguments
    540540    :raises TypeError: invalid connection
     
    550550string. If it is a statement that returns rows as a result (usually a select
    551551statement, but maybe also an ``"insert/update ... returning"`` statement),
    552 this method returns a :class:`pgqueryobject` that can be accessed via the
    553 :meth:`pgqueryobject.getresult`, :meth:`pgqueryobject.dictresult` or
    554 :meth:`pgqueryobject.namedresult` methods or simply printed.
     552this method returns a :class:`Query` that can be accessed via the
     553:meth:`Query.getresult`, :meth:`Query.dictresult` or
     554:meth:`Query.namedresult` methods or simply printed.
    555555Otherwise, it returns ``None``.
    556556
     
    574574-----------------------------
    575575
    576 .. method:: pgobject.reset()
    577 
    578    Reset the :mod:`pg` connection
    579 
    580    :rtype: None
    581    :raises TypeError: too many (any) arguments
    582    :raises TypeError: invalid connection
     576.. method:: Connection.reset()
     577
     578    Reset the :mod:`pg` connection
     579   
     580    :rtype: None
     581    :raises TypeError: too many (any) arguments
     582    :raises TypeError: invalid connection
    583583
    584584This method resets the current database connection.
     
    587587---------------------------------------------------
    588588
    589 .. method:: pgobject.cancel()
    590 
    591    :rtype: None
    592    :raises TypeError: too many (any) arguments
    593    :raises TypeError: invalid connection
     589.. method:: Connection.cancel()
     590
     591    :rtype: None
     592    :raises TypeError: too many (any) arguments
     593    :raises TypeError: invalid connection
    594594
    595595This method requests that the server abandon processing
     
    599599--------------------------------------
    600600
    601 .. method:: pgobject.close()
    602 
    603    Close the :mod:`pg` connection
    604 
    605    :rtype: None
    606    :raises TypeError: too many (any) arguments
     601.. method:: Connection.close()
     602
     603    Close the :mod:`pg` connection
     604   
     605    :rtype: None
     606    :raises TypeError: too many (any) arguments
    607607
    608608This method closes the database connection. The connection will
     
    614614------------------------------------------------------------
    615615
    616 .. method:: pgobject.fileno()
     616.. method:: Connection.fileno()
    617617
    618618   Return the socket used to connect to the database
     
    629629------------------------------------------------
    630630
    631 .. method:: pgobject.getnotify()
    632 
    633    Get the last notify from the server
    634 
    635    :returns: last notify from server
    636    :rtype: tuple, None
    637    :raises TypeError: too many parameters
    638    :raises TypeError: invalid connection
     631.. method:: Connection.getnotify()
     632
     633    Get the last notify from the server
     634
     635    :returns: last notify from server
     636    :rtype: tuple, None
     637    :raises TypeError: too many parameters
     638    :raises TypeError: invalid connection
    639639
    640640This method tries to get a notify from the server (from the SQL statement
     
    644644connection that triggered the notify, and *extra* is a payload string
    645645that has been sent with the notification. Remember to do a listen query
    646 first, otherwise :meth:`pgobject.getnotify` will always return ``None``.
     646first, otherwise :meth:`Connection.getnotify` will always return ``None``.
    647647
    648648inserttable -- insert a list into a table
    649649-----------------------------------------
    650650
    651 .. method:: pgobject.inserttable(table, values)
    652 
    653    Insert a Python list into a database table
    654 
    655    :param str table: the table name
    656    :param list values: list of rows values
    657    :rtype: None
    658    :raises TypeError: invalid connection, bad argument type, or too many arguments
    659    :raises MemoryError: insert buffer could not be allocated
    660    :raises ValueError: unsupported values
     651.. method:: Connection.inserttable(table, values)
     652
     653    Insert a Python list into a database table
     654
     655    :param str table: the table name
     656    :param list values: list of rows values
     657    :rtype: None
     658    :raises TypeError: invalid connection, bad argument type, or too many arguments
     659    :raises MemoryError: insert buffer could not be allocated
     660    :raises ValueError: unsupported values
    661661
    662662This method allows to *quickly* insert large blocks of data in a table:
     
    668668.. note::
    669669
    670    **Be very careful**:
    671    This method doesn't type check the fields according to the table definition;
    672    it just look whether or not it knows how to handle such types.
     670    **Be very careful**:
     671    This method doesn't type check the fields according to the table definition;
     672    it just look whether or not it knows how to handle such types.
    673673
    674674get/set_notice_receiver -- custom notice receiver
    675675-------------------------------------------------
    676676
    677 .. method:: pgobject.get_notice_receiver()
    678 
    679    Get the current notice receiver
    680 
    681    :returns: the current notice receiver callable
    682    :rtype: callable, None
    683    :raises TypeError: too many (any) arguments
     677.. method:: Connection.get_notice_receiver()
     678
     679    Get the current notice receiver
     680
     681    :returns: the current notice receiver callable
     682    :rtype: callable, None
     683    :raises TypeError: too many (any) arguments
    684684
    685685This method gets the custom notice receiver callback function that has
    686 been set with :meth:`pgobject.set_notice_receiver`, or ``None`` if no
     686been set with :meth:`Connection.set_notice_receiver`, or ``None`` if no
    687687custom notice receiver has ever been set on the connection.
    688688
    689 .. method:: pgobject.set_notice_receiver(proc)
    690 
    691    Set a custom notice receiver
    692 
    693    :param proc: the custom notice receiver callback function
    694    :rtype: None
    695    :raises TypeError: the specified notice receiver is not callable
     689.. method:: Connection.set_notice_receiver(proc)
     690
     691    Set a custom notice receiver
     692
     693    :param proc: the custom notice receiver callback function
     694    :rtype: None
     695    :raises TypeError: the specified notice receiver is not callable
    696696
    697697This method allows setting a custom notice receiver callback function.
     
    700700the one set with ``client_min_messages``, the specified notice receiver
    701701function will be called. This function must take one parameter,
    702 the :class:`pgnotice` object, which provides the following read-only
     702the :class:`Notice` object, which provides the following read-only
    703703attributes:
    704704
    705     .. attribute:: pgnotice.pgcnx
     705    .. attribute:: Notice.pgcnx
    706706
    707707        the connection
    708708
    709     .. attribute:: pgnotice.message
     709    .. attribute:: Notice.message
    710710
    711711        the full message with a trailing newline
    712712
    713     .. attribute:: pgnotice.severity
     713    .. attribute:: Notice.severity
    714714
    715715        the level of the message, e.g. 'NOTICE' or 'WARNING'
    716716
    717     .. attribute:: pgnotice.primary
     717    .. attribute:: Notice.primary
    718718
    719719        the primary human-readable error message
    720720
    721     .. attribute:: pgnotice.detail
     721    .. attribute:: Notice.detail
    722722
    723723        an optional secondary error message
    724724
    725     .. attribute:: pgnotice.hint
     725    .. attribute:: Notice.hint
    726726
    727727        an optional suggestion what to do about the problem
     
    730730-------------------------------------------------
    731731
    732 .. method:: pgobject.putline(line)
     732.. method:: Connection.putline(line)
    733733
    734734    Write a line to the server socket
     
    743743---------------------------------------------
    744744
    745 .. method:: pgobject.getline()
     745.. method:: Connection.getline()
    746746
    747747    Get a line from server socket
     
    758758---------------------------------------------
    759759
    760 .. method:: pgobject.endcopy()
     760.. method:: Connection.endcopy()
    761761
    762762    Synchronize client and server
     
    772772------------------------------------------------------
    773773
    774 .. method:: pgobject.locreate(mode)
     774.. method:: Connection.locreate(mode)
    775775
    776776    Create a large object in the database
     
    778778    :param int mode: large object create mode
    779779    :returns: object handling the PostGreSQL large object
    780     :rtype: :class:`pglarge`
     780    :rtype: :class:`LargeObject`
    781781    :raises TypeError: invalid connection, bad parameter type, or too many parameters
    782782    :raises pg.OperationalError: creation error
     
    790790-------------------------------------------------
    791791
    792 .. method:: pgobject.getlo(oid)
     792.. method:: Connection.getlo(oid)
    793793
    794794    Create a large object in the database
     
    796796    :param int oid: OID of the existing large object
    797797    :returns: object handling the PostGreSQL large object
    798     :rtype: :class:`pglarge`
     798    :rtype: :class:`LargeObject`
    799799    :raises TypeError:  invalid connection, bad parameter type, or too many parameters
    800800    :raises ValueError: bad OID value (0 is invalid_oid)
    801801
    802802This method allows to reuse a formerly created large object through the
    803 :class:`pglarge` interface, providing the user have its OID.
     803:class:`LargeObject` interface, providing the user have its OID.
    804804
    805805loimport -- import a file to a large object [LO]
    806806------------------------------------------------
    807807
    808 .. method:: pgobject.loimport(name)
     808.. method:: Connection.loimport(name)
    809809
    810810    Import a file to a large object
     
    812812    :param str name: the name of the file to be imported
    813813    :returns: object handling the PostGreSQL large object
    814     :rtype: :class:`pglarge`
     814    :rtype: :class:`LargeObject`
    815815    :raises TypeError: invalid connection, bad argument type, or too many arguments
    816816    :raises pg.OperationalError: error during file import
     
    821821Object attributes
    822822-----------------
    823 Every :class:`pgobject` defines a set of read-only attributes that describe
     823Every :class:`Connection` defines a set of read-only attributes that describe
    824824the connection and its status. These attributes are:
    825825
    826 .. attribute:: pgobject.host
     826.. attribute:: Connection.host
    827827
    828828   the host name of the server (str)
    829829
    830 .. attribute:: pgobject.port
     830.. attribute:: Connection.port
    831831
    832832   the port of the server (int)
    833833
    834 .. attribute:: pgobject.db
     834.. attribute:: Connection.db
    835835
    836836   the selected database (str)
    837837
    838 .. attribute:: pgobject.options
     838.. attribute:: Connection.options
    839839
    840840   the connection options (str)
    841841
    842 .. attribute:: pgobject.tty
     842.. attribute:: Connection.tty
    843843
    844844   the connection debug terminal (str)
    845845
    846 .. attribute:: pgobject.user
     846.. attribute:: Connection.user
    847847
    848848    user name on the database system (str)
    849849
    850 .. attribute:: pgobject.protocol_version
     850.. attribute:: Connection.protocol_version
    851851
    852852   the frontend/backend protocol being used (int)
    853853
    854 .. attribute:: pgobject.server_version
     854.. attribute:: Connection.server_version
    855855
    856856   the backend version (int, e.g. 80305 for 8.3.5)
    857857
    858 .. attribute:: pgobject.status
     858.. attribute:: Connection.status
    859859
    860860   the status of the connection (int: 1 = OK, 0 = bad)
    861861
    862 .. attribute:: pgobject.error
     862.. attribute:: Connection.error
    863863
    864864   the last warning/error message from the server (str)
     
    870870.. class:: DB
    871871
    872 The :class:`pgobject` methods are wrapped in the class :class:`DB`.
     872The :class:`Connection` methods are wrapped in the class :class:`DB`.
    873873The preferred way to use this module is as follows::
    874874
     
    915915single parameter named ``db``. This allows you to use all of the methods
    916916of the DB class with a DB-API 2 compliant connection. Note that the
    917 :meth:`pgobject.close` and :meth:`pgobject.reopen` methods are inoperative
     917:meth:`Connection.close` and :meth:`Connection.reopen` methods are inoperative
    918918in this case.
    919919
     
    10811081    :param arg*: optional positional arguments
    10821082    :returns: result values
    1083     :rtype: :class:`pgqueryobject`, None
     1083    :rtype: :class:`Query`, None
    10841084    :raises TypeError: bad argument type, or too many arguments
    10851085    :raises TypeError: invalid connection
     
    10881088    :raises pg.InternalError: error during query processing
    10891089
    1090 Similar to the :class:`pgobject` function with the same name, except that
     1090Similar to the :class:`Connection` function with the same name, except that
    10911091positional arguments can be passed either as a single list or tuple, or as
    10921092individual positional arguments.
     
    11821182
    11831183
    1184 pgqueryobject methods
     1184Query methods
    11851185=====================
    11861186
    1187 .. class:: pgqueryobject
    1188 
    1189 The :class:`pgqueryobject` returned by :meth:`pgobject.query` and
     1187.. class:: Query
     1188
     1189The :class:`Query` object returned by :meth:`Connection.query` and
    11901190:meth:`DB.query` provides the following methods for accessing
    11911191the results of the query:
     
    11941194-----------------------------------------------
    11951195
    1196 .. method:: pgqueryobject.getresult()
     1196.. method:: Query.getresult()
    11971197
    11981198    Get query values as list of tuples
     
    12051205This method returns the list of the values returned by the query.
    12061206More information about this result may be accessed using
    1207 :meth:`pgqueryobject.listfields`, :meth:`pgqueryobject.fieldname`
    1208 and :meth:`pgqueryobject.fieldnum` methods.
     1207:meth:`Query.listfields`, :meth:`Query.fieldname`
     1208and :meth:`Query.fieldnum` methods.
    12091209
    12101210dictresult -- get query values as list of dictionaries
    12111211------------------------------------------------------
    12121212
    1213 .. method:: pgqueryobject.dictresult()
     1213.. method:: Query.dictresult()
    12141214
    12151215    Get query values as list of dictionaries
     
    12271227-------------------------------------------------------
    12281228
    1229 .. method:: pgqueryobject.namedresult()
     1229.. method:: Query.namedresult()
    12301230
    12311231    Get query values as list of named tuples
     
    12431243--------------------------------------------------------
    12441244
    1245 .. method:: pgqueryobject.listfields()
     1245.. method:: Query.listfields()
    12461246
    12471247    List fields names of previous query result
     
    12571257---------------------------------------------------
    12581258
    1259 .. method:: pgqueryobject.fieldname(num)
     1259.. method:: Query.fieldname(num)
    12601260
    12611261    Get field name from its number
     
    12711271result values.
    12721272
    1273 .. method:: pgqueryobject.fieldnum(name)
     1273.. method:: Query.fieldnum(name)
    12741274
    12751275    Get field number from its name
     
    12891289--------------------------------------------------
    12901290
    1291 .. method:: pgqueryobject.ntuples()
     1291.. method:: Query.ntuples()
    12921292
    12931293    Return number of tuples in query object
    12941294
    1295     :returns: number of tuples in :class:`pgqueryobject`
     1295    :returns: number of tuples in :class:`Query`
    12961296    :rtype: int
    12971297    :raises TypeError: Too many arguments.
     
    13001300
    13011301
    1302 pglarge -- Large Objects
    1303 ========================
    1304 
    1305 .. class:: pglarge
    1306 
    1307 Objects that are instances of the class :class:`pglarge` are used to handle
     1302LargeObject -- Large Objects
     1303============================
     1304
     1305.. class:: LargeObject
     1306
     1307Objects that are instances of the class :class:`LargeObject` are used to handle
    13081308all the requests concerning a PostgreSQL large object. These objects embed
    13091309and hide all the "recurrent" variables (object OID and connection), exactly
    1310 in the same way :class:`pgobject` instances do, thus only keeping significant
    1311 parameters in function calls. The class:`pglarge` object keeps a reference
    1312 to the :class:`pgobject` used for its creation, sending requests though with
    1313 its parameters. Any modification but dereferencing the :class:`pgobject`
    1314 will thus affect the :class:`pglarge` object. Dereferencing the initial
    1315 :class:`pgobject` is not a problem since Python won't deallocate it before
    1316 the :class:`pglarge` object dereferences it. All functions return a generic
    1317 error message on call error, whatever the exact error was. The :attr:`error`
    1318 attribute of the object allows to get the exact error message.
     1310in the same way :class:`Connection` instances do, thus only keeping significant
     1311parameters in function calls. The class:`LargeObject` instance keeps a
     1312reference to the :class:`Connection` object used for its creation, sending
     1313requests though with its parameters. Any modification but dereferencing the
     1314:class:`Connection` object will thus affect the :class:`LargeObject` instance.
     1315Dereferencing the initial :class:`Connection` object is not a problem since
     1316Python won't deallocate it before the :class:`LargeObject` instance
     1317dereferences it. All functions return a generic error message on call error,
     1318whatever the exact error was. The :attr:`error` attribute of the object allows
     1319to get the exact error message.
    13191320
    13201321See also the PostgreSQL programmer's guide for more information about the
     
    13241325---------------------------
    13251326
    1326 .. method:: pglarge.open(mode)
     1327.. method:: LargeObject.open(mode)
    13271328
    13281329    Open a large object
     
    13401341-----------------------------
    13411342
    1342 .. method:: pglarge.close()
     1343.. method:: LargeObject.close()
    13431344
    13441345    Close a large object
     
    13551356------------------------------------------------------------------
    13561357
    1357 .. method:: pglarge.read(size)
     1358.. method:: LargeObject.read(size)
    13581359
    13591360    Read data from large object
     
    13701371position.
    13711372
    1372 .. method:: pglarge.write(string)
     1373.. method:: LargeObject.write(string)
    13731374
    13741375    Read data to large object
     
    13821383position.
    13831384
    1384 .. method:: pglarge.seek(offset, whence)
     1385.. method:: LargeObject.seek(offset, whence)
    13851386
    13861387    Change current position in large object
     
    13981399:mod:`pg` module (:const:`SEEK_SET`, :const:`SEEK_CUR`, :const:`SEEK_END`).
    13991400
    1400 .. method:: pglarge.tell()
     1401.. method:: LargeObject.tell()
    14011402
    14021403    Return current position in large object
     
    14101411This method allows to get the current position in the large object.
    14111412
    1412 .. method:: pglarge.unlink()
     1413.. method:: LargeObject.unlink()
    14131414
    14141415    Delete large object
     
    14241425---------------------------------
    14251426
    1426 .. method:: pglarge.size()
     1427.. method:: LargeObject.size()
    14271428
    14281429    Return the large object size
     
    14411442---------------------------------------
    14421443
    1443 .. method:: pglarge.export(name)
     1444.. method:: LargeObject.export(name)
    14441445
    14451446    Export a large object to a file
     
    14571458Object attributes
    14581459-----------------
    1459 :class:`pglarge` objects define a read-only set of attributes that allow
     1460:class:`LargeObject` objects define a read-only set of attributes that allow
    14601461to get some information about it. These attributes are:
    14611462
    1462 .. attribute:: pglarge.oid
    1463 
    1464    the OID associated with the object (int)
    1465 
    1466 .. attribute:: pglarge.pgcnx
    1467 
    1468    the :class:`pgobject` associated with the object
    1469 
    1470 .. attribute:: pglarge.error
    1471 
    1472    the last warning/error message of the connection
     1463.. attribute:: LargeObject.oid
     1464
     1465   the OID associated with the large object (int)
     1466
     1467.. attribute:: LargeObject.pgcnx
     1468
     1469   the :class:`Connection` object associated with the large object
     1470
     1471.. attribute:: LargeObject.error
     1472
     1473   the last warning/error message of the connection (str)
    14731474
    14741475.. note::
    14751476
    14761477    **Be careful**:
    1477     In multithreaded environments, :attr:`pglarge.error` may be modified by
    1478     another thread using the same :class:`pgobject`. Remember these object
     1478    In multithreaded environments, :attr:`LargeObject.error` may be modified by
     1479    another thread using the same :class:`Connection`. Remember these object
    14791480    are shared, not duplicated. You should provide some locking to be able
    1480     if you want to check this. The :attr:`pglarge.oid` attribute is very
     1481    if you want to check this. The :attr:`LargeObject.oid` attribute is very
    14811482    interesting, because it allows you to reuse the OID later, creating the
    1482     :class:`pglarge` object with a :meth:`pgobject.getlo` method call.
     1483    :class:`LargeObject` object with a :meth:`Connection.getlo` method call.
Note: See TracChangeset for help on using the changeset viewer.