pydoc > pgdb

man perldoc info pydoc3 ri search

📛 NAME

pgdb – DB-API 2.0 compliant module for PyGreSQL.

🚀 Quick Reference

Use Case	Command	Description
🔌 Connect	pgdb.connect(dsn, user, password, host, database)	Open a database connection
🖊️ Cursor	connection.cursor()	Create a new cursor object
⚡ Execute	cursor.execute(query, params)	Execute a query with optional dictionary params
⚡ Execute Many	cursor.executemany(query, param_list)	Execute query with each param dict in list
⬇️ Fetch One	cursor.fetchone()	Fetch a single row as a list
⬇️ Fetch All	cursor.fetchall()	Fetch all remaining rows
⬇️ Fetch Many	cursor.fetchmany([size])	Fetch up to size rows (default arraysize=1)
📊 Row Count	cursor.rowcount	Number of rows in result set (after execute)
📋 Description	cursor.description	List of column info tuples
✅ Commit	connection.commit()	Commit pending transaction
↩️ Rollback	connection.rollback()	Roll back pending transaction
❌ Close Cursor	cursor.close()	Close the cursor
❌ Close Connection	connection.close()	Close the database connection

📖 DESCRIPTION

(c) 1999, Pascal Andre <andre AT via.fr>. See package documentation for further copyright information.

Inline documentation is sparse. See DB-API 2.0 specification: http://www.python.org/peps/pep-0249.html

Basic usage:

pgdb.connect(connect_string) # open a connection
# connect_string = 'host:database:user:password:opt'
# All parts are optional. You may also pass host through
# password as keyword arguments. To pass a port,
# pass it in the host keyword parameter:
connection = pgdb.connect(host='localhost:5432')

cursor = connection.cursor() # open a cursor

cursor.execute(query[, params])
# Execute a query, binding params (a dictionary) if they are
# passed. The binding syntax is the same as the % operator
# for dictionaries, and no quoting is done.

cursor.executemany(query, list of params)
# Execute a query many times, binding each param dictionary
# from the list.

cursor.fetchone() # fetch one row, [value, value, ...]

cursor.fetchall() # fetch all rows, [[value, value, ...], ...]

cursor.fetchmany([size])
# returns size or cursor.arraysize number of rows,
# [[value, value, ...], ...] from result set.
# Default cursor.arraysize is 1.

cursor.description # returns information about the columns
#   [(column_name, type_name, display_size,
#           internal_size, precision, scale, null_ok), ...]
# Note that display_size, precision, scale and null_ok
# are not implemented.

cursor.rowcount # number of rows available in the result set
# Available after a call to execute.

connection.commit() # commit transaction

connection.rollback() # or rollback transaction

cursor.close() # close the cursor

connection.close() # close the connection

📦 CLASSES

Exception hierarchy:

• builtins.Exception(builtins.BaseException)
• ↳ pg.Error
•   ↳ pg.DatabaseError
•     ↳ pg.DataError
•     ↳ pg.IntegrityError
•     ↳ pg.NotSupportedError
•     ↳ pg.OperationalError
•     ↳ pg.ProgrammingError
•   ↳ pg.InterfaceError
• ↳ pg.Warning
• builtins.bytes → Binary
• builtins.dict → Hstore
• builtins.frozenset → Type
• builtins.object → Connection, Cursor, Json, Literal
• uuid.UUID → Uuid

🔗 Connection

Connection(cnx) – Connection object.

• __enter__(self) – Enter runtime context for transactions (starts transaction in autocommit)
• __exit__(self, et, ev, tb) – Exit runtime context, ends transaction
• __init__(self, cnx) – Create a database connection object
• close(self) – Close the connection
• commit(self) – Commit pending transaction
• cursor(self) – Return a new cursor object
• execute(self, operation, params=None) – Shortcut to run an operation on an implicit cursor
• executemany(self, operation, param_seq) – Shortcut to run an operation against a sequence of parameters
• rollback(self) – Roll back pending transaction
• Readonly property: closed – Check if connection is closed or broken

Exception attributes available on the connection:

• DataError, DatabaseError, Error, IntegrityError, InterfaceError, InternalError, NotSupportedError, OperationalError, ProgrammingError, Warning

🎯 Cursor

Cursor(dbcnx) – Cursor object.

• __enter__(self) – Enter runtime context
• __exit__(self, et, ev, tb) – Exit runtime context
• __init__(self, dbcnx) – Create a cursor for the database connection
• __iter__(self) – Make cursor compatible with iteration protocol
• __next__(self) – Return next row (iteration protocol)
• build_row_factory(self) – Build a row factory for named tuples. Override to dynamically change row factories.
• callproc(self, procname, parameters=None) – Call a stored procedure. Output parameters currently not replaced.
• close(self) – Close the cursor
• copy_from(self, stream, table, format=None, sep=None, null=None, size=None, columns=None) – Copy data from an input stream (file-like or iterable) to the specified table.
• copy_to(self, stream, table, format=None, sep=None, null=None, decode=None, columns=None) – Copy data from the specified table to an output stream. If stream is None, returns a generator. Use a select query instead of table name.
• execute(self, operation, parameters=None) – Prepare and execute a database operation
• executemany(self, operation, seq_of_parameters) – Prepare and execute against a parameter sequence
• fetchall(self) – Fetch all remaining rows
• fetchmany(self, size=None, keep=False) – Fetch next set of rows. If keep=True, size becomes new arraysize.
• fetchone(self) – Fetch next row
• next = __next__
• Static methods: nextset() (not supported), setinputsizes(sizes) (not supported), setoutputsize(size, column=0) (not supported)
• row_factory(row) – Process rows before returning. Override statically or via build_row_factory.
• Readonly properties: colnames, coltypes, description

🗂️ Binary

Binary – Inherits from builtins.bytes. Construct an object capable of holding a binary (long) string value. Inherits all methods of bytes.

📋 Hstore

Hstore – Inherits from builtins.dict. Wrapper class for marking hstore values.

• __str__(self) – Return str(self)
• Inherits all dict methods.

📄 Json

Json(obj, encode=None) – Construct a wrapper for holding an object serializable to JSON.

• __init__(self, obj, encode=None)
• __str__(self)

💬 Literal

Literal(sql) – Construct a wrapper for holding a literal SQL string.

• __init__(self, sql)
• __pg_repr__ = __str__(self)
• __str__(self)

🧩 Type

Type(values) – Inherits from builtins.frozenset. Type class for PostgreSQL data types; types are dynamic so type names are used as internal codes.

• __eq__(self, other)
• __ne__(self, other)
• __new__(cls, values)
• __hash__ = None
• Inherits all frozenset methods.

🆔 Uuid

Uuid = uuid.UUID – Represents UUIDs per RFC 4122. Immutable, hashable, usable as dict keys.

Constructors: hex, bytes, bytes_le, fields, int. Read-only attributes: hex, int, bytes, bytes_le, fields, time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node, time, clock_seq, urn, variant, version, is_safe.

⚠️ Error

Base exception for all pgdb errors. Inherits from builtins.Exception.

• __weakref__ descriptor
• Inherits all Exception / BaseException methods.

🐞 DatabaseError

MRO: DatabaseError → Error → Exception. Inherits all methods.

🔢 DataError

MRO: DataError → DatabaseError → Error → Exception. Inherits all methods.

🔐 IntegrityError

MRO: IntegrityError → DatabaseError → Error → Exception. Inherits all methods.

🔌 InterfaceError

MRO: InterfaceError → Error → Exception. Inherits all methods.

🚫 NotSupportedError

MRO: NotSupportedError → DatabaseError → Error → Exception. Inherits all methods.

⚙️ OperationalError

MRO: OperationalError → DatabaseError → Error → Exception. Inherits all methods.

👨‍💻 ProgrammingError

MRO: ProgrammingError → DatabaseError → Error → Exception. Inherits all methods.

⚠️ Warning

MRO: Warning → Exception. Inherits all methods.

⚙️ FUNCTIONS

• connect(dsn=None, user=None, password=None, host=None, database=None, **kwargs) – Connect to a database.
• Date(year, month, day) – Construct an object holding a date value.
• DateFromTicks(ticks) – Construct a date object from the given ticks value.
• Interval(days, hours=0, minutes=0, seconds=0, microseconds=0) – Construct a time interval value.
• Time(hour, minute=0, second=0, microsecond=0, tzinfo=None) – Construct a time value.
• TimeFromTicks(ticks) – Construct a time value from ticks.
• Timestamp(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None) – Construct a timestamp value.
• TimestampFromTicks(ticks) – Construct a timestamp from ticks.
• get_typecast(typ) – Get the global typecast function for the given database type(s).
• reset_typecast(typ=None) – Reset global typecasts to defaults. Connections cache casts; use con.type_cache.reset_typecast() to pick up changes.
• set_typecast(typ, cast) – Set a global typecast function for the given database type(s).

📊 DATA

• ARRAY = <pgdb.ArrayType object>
• BINARY = Type({'bytea'})
• BOOL = Type({'bool'})
• DATE = Type({'date'})
• DATETIME = Type({'timestamptz', 'reltime', 'time', 'abstime', 'timesta...'})
• FLOAT = Type({'float8', 'float4'})
• HSTORE = Type({'hstore'})
• INTEGER = Type({'int2', 'int8', 'int4', 'serial'})
• INTERVAL = Type({'interval'})
• JSON = Type({'jsonb', 'json'})
• LONG = Type({'int8'})
• MONEY = Type({'money'})
• NUMBER = Type({'int4', 'float8', 'money', 'serial', 'int2', 'int8', 'n...'})
• NUMERIC = Type({'numeric'})
• RECORD = <pgdb.RecordType object>
• ROWID = Type({'oid'})
• SMALLINT = Type({'int2'})
• STRING = Type({'name', 'varchar', 'bpchar', 'text', 'char'})
• TIME = Type({'time', 'timetz'})
• TIMESTAMP = Type({'timestamptz', 'timestamp'})
• UUID = Type({'uuid'})
• __all__ = ['Connection', 'Cursor', 'Date', 'Time', 'Timestamp', 'DateF...']
• apilevel = '2.0'
• paramstyle = 'pyformat'
• threadsafety = 1
• version = '5.1.2'

🔢 VERSION

5.1.2

📁 FILE

/usr/lib/python3/dist-packages/pgdb.py

📛 NAME 🚀 Quick Reference 📖 DESCRIPTION 📦 CLASSES ⚙️ FUNCTIONS 📊 DATA 🔢 VERSION 📁 FILE