{ "content": [ { "type": "text", "text": "# pgdb (pydoc)\n\n**Summary:** pgdb - pgdb - DB-API 2.0 compliant module for PyGreSQL.\n\n## Section Outline\n\n- **NAME** (2 lines)\n- **DESCRIPTION** (53 lines)\n- **CLASSES** (23 lines) — 16 subsections\n - class Binary (397 lines)\n - class Connection (77 lines)\n - class Cursor (150 lines)\n - class DataError (69 lines)\n - class DatabaseError (68 lines)\n - class Error (67 lines)\n - class Hstore (145 lines)\n - class IntegrityError (69 lines)\n - class InterfaceError (68 lines)\n - class Json (21 lines)\n - class Literal (23 lines)\n - class NotSupportedError (69 lines)\n - class OperationalError (69 lines)\n - class ProgrammingError (69 lines)\n - class Type (295 lines)\n - class Warning (67 lines)\n- **FUNCTIONS** (21 lines) — 4 subsections\n - connect (2 lines)\n - get_typecast (2 lines)\n - reset_typecast (7 lines)\n - set_typecast (5 lines)\n- **DATA** (27 lines)\n- **VERSION** (2 lines)\n- **FILE** (3 lines)\n\n## Full Content\n\n### NAME\n\npgdb - pgdb - DB-API 2.0 compliant module for PyGreSQL.\n\n### DESCRIPTION\n\n(c) 1999, Pascal Andre .\nSee package documentation for further information on copyright.\n\nInline documentation is sparse.\nSee DB-API 2.0 specification for usage information:\nhttp://www.python.org/peps/pep-0249.html\n\nBasic usage:\n\npgdb.connect(connectstring) # open a connection\n# connectstring = 'host:database:user:password:opt'\n# All parts are optional. You may also pass host through\n# password as keyword arguments. To pass a port,\n# pass it in the host keyword parameter:\nconnection = pgdb.connect(host='localhost:5432')\n\ncursor = connection.cursor() # open a cursor\n\ncursor.execute(query[, params])\n# Execute a query, binding params (a dictionary) if they are\n# passed. The binding syntax is the same as the % operator\n# for dictionaries, and no quoting is done.\n\ncursor.executemany(query, list of params)\n# Execute a query many times, binding each param dictionary\n# from the list.\n\ncursor.fetchone() # fetch one row, [value, value, ...]\n\ncursor.fetchall() # fetch all rows, [[value, value, ...], ...]\n\ncursor.fetchmany([size])\n# returns size or cursor.arraysize number of rows,\n# [[value, value, ...], ...] from result set.\n# Default cursor.arraysize is 1.\n\ncursor.description # returns information about the columns\n# [(columnname, typename, displaysize,\n# internalsize, precision, scale, nullok), ...]\n# Note that displaysize, precision, scale and nullok\n# are not implemented.\n\ncursor.rowcount # number of rows available in the result set\n# Available after a call to execute.\n\nconnection.commit() # commit transaction\n\nconnection.rollback() # or rollback transaction\n\ncursor.close() # close the cursor\n\nconnection.close() # close the connection\n\n### CLASSES\n\nbuiltins.Exception(builtins.BaseException)\npg.Error\npg.DatabaseError\npg.DataError\npg.IntegrityError\npg.NotSupportedError\npg.OperationalError\npg.ProgrammingError\npg.InterfaceError\npg.Warning\nbuiltins.bytes(builtins.object)\nBinary\nbuiltins.dict(builtins.object)\nHstore\nbuiltins.frozenset(builtins.object)\nType\nbuiltins.object\nConnection\nCursor\nJson\nLiteral\nuuid.UUID\n\n#### class Binary\n\n| Construct an object capable of holding a binary (long) string value.\n|\n| Method resolution order:\n| Binary\n| builtins.bytes\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.bytes:\n|\n| add(self, value, /)\n| Return self+value.\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| getnewargs(...)\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self copy of B\n|\n| Return a copy of B with only its first character capitalized (ASCII)\n| and the rest lower-cased.\n|\n| center(self, width, fillchar=b' ', /)\n| Return a centered string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| count(...)\n| B.count(sub[, start[, end]]) -> int\n|\n| Return the number of non-overlapping occurrences of subsection sub in\n| bytes B[start:end]. Optional arguments start and end are interpreted\n| as in slice notation.\n|\n| decode(self, /, encoding='utf-8', errors='strict')\n| Decode the bytes using the codec registered for encoding.\n|\n| encoding\n| The encoding with which to decode the bytes.\n| errors\n| The error handling scheme to use for the handling of decoding errors.\n| The default is 'strict' meaning that decoding errors raise a\n| UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n| as well as any other name registered with codecs.registererror that\n| can handle UnicodeDecodeErrors.\n|\n| endswith(...)\n| B.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if B ends with the specified suffix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| suffix can also be a tuple of bytes to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| B.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| hex(...)\n| Create a string of hexadecimal numbers from a bytes object.\n|\n| sep\n| An optional single character or byte to separate hex bytes.\n| bytespersep\n| How many bytes between separators. Positive values count from the\n| right, negative values count from the left.\n|\n| Example:\n| >>> value = b'\\xb9\\x01\\xef'\n| >>> value.hex()\n| 'b901ef'\n| >>> value.hex(':')\n| 'b9:01:ef'\n| >>> value.hex(':', 2)\n| 'b9:01ef'\n| >>> value.hex(':', -2)\n| 'b901:ef'\n|\n| index(...)\n| B.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the subsection is not found.\n|\n| isalnum(...)\n| B.isalnum() -> bool\n|\n| Return True if all characters in B are alphanumeric\n| and there is at least one character in B, False otherwise.\n|\n| isalpha(...)\n| B.isalpha() -> bool\n|\n| Return True if all characters in B are alphabetic\n| and there is at least one character in B, False otherwise.\n|\n| isascii(...)\n| B.isascii() -> bool\n|\n| Return True if B is empty or all characters in B are ASCII,\n| False otherwise.\n|\n| isdigit(...)\n| B.isdigit() -> bool\n|\n| Return True if all characters in B are digits\n| and there is at least one character in B, False otherwise.\n|\n| islower(...)\n| B.islower() -> bool\n|\n| Return True if all cased characters in B are lowercase and there is\n| at least one cased character in B, False otherwise.\n|\n| isspace(...)\n| B.isspace() -> bool\n|\n| Return True if all characters in B are whitespace\n| and there is at least one character in B, False otherwise.\n|\n| istitle(...)\n| B.istitle() -> bool\n|\n| Return True if B is a titlecased string and there is at least one\n| character in B, i.e. uppercase characters may only follow uncased\n| characters and lowercase characters only cased ones. Return False\n| otherwise.\n|\n| isupper(...)\n| B.isupper() -> bool\n|\n| Return True if all cased characters in B are uppercase and there is\n| at least one cased character in B, False otherwise.\n|\n| join(self, iterableofbytes, /)\n| Concatenate any number of bytes objects.\n|\n| The bytes whose method is called is inserted in between each pair.\n|\n| The result is returned as a new bytes object.\n|\n| Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.\n|\n| ljust(self, width, fillchar=b' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| lower(...)\n| B.lower() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to lowercase.\n|\n| lstrip(self, bytes=None, /)\n| Strip leading bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading ASCII whitespace.\n|\n| partition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original bytes\n| object and two empty bytes objects.\n|\n| removeprefix(self, prefix, /)\n| Return a bytes object with the given prefix string removed if present.\n|\n| If the bytes starts with the prefix string, return bytes[len(prefix):].\n| Otherwise, return a copy of the original bytes.\n|\n| removesuffix(self, suffix, /)\n| Return a bytes object with the given suffix string removed if present.\n|\n| If the bytes ends with the suffix string and that suffix is not empty,\n| return bytes[:-len(prefix)]. Otherwise, return a copy of the original\n| bytes.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| B.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| B.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raise ValueError when the subsection is not found.\n|\n| rjust(self, width, fillchar=b' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| rpartition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty bytes\n| objects and the original bytes object.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| Splitting is done starting at the end of the bytes and working to the front.\n|\n| rstrip(self, bytes=None, /)\n| Strip trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip trailing ASCII whitespace.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the bytes, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| B.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if B starts with the specified prefix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| prefix can also be a tuple of bytes to try.\n|\n| strip(self, bytes=None, /)\n| Strip leading and trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading and trailing ASCII whitespace.\n|\n| swapcase(...)\n| B.swapcase() -> copy of B\n|\n| Return a copy of B with uppercase ASCII characters converted\n| to lowercase ASCII and vice versa.\n|\n| title(...)\n| B.title() -> copy of B\n|\n| Return a titlecased version of B, i.e. ASCII words start with uppercase\n| characters, all remaining cased characters have lowercase.\n|\n| translate(self, table, /, delete=b'')\n| Return a copy with each character mapped by the given translation table.\n|\n| table\n| Translation table, which must be a bytes object of length 256.\n|\n| All characters occurring in the optional argument delete are removed.\n| The remaining characters are mapped through the given translation table.\n|\n| upper(...)\n| B.upper() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The original string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.bytes:\n|\n| fromhex(string, /) from builtins.type\n| Create a bytes object from a string of hexadecimal numbers.\n|\n| Spaces between two numbers are accepted.\n| Example: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.bytes:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| maketrans(frm, to, /)\n| Return a translation table useable for the bytes or bytearray translate method.\n|\n| The returned table will be one where each byte in frm is mapped to the byte at\n| the same position in to.\n|\n| The bytes objects frm and to must be of the same length.\n\n#### class Connection\n\n| Connection(cnx)\n|\n| Connection object.\n|\n| Methods defined here:\n|\n| enter(self)\n| Enter the runtime context for the connection object.\n|\n| The runtime context can be used for running transactions.\n|\n| This also starts a transaction in autocommit mode.\n|\n| exit(self, et, ev, tb)\n| Exit the runtime context for the connection object.\n|\n| This does not close the connection, but it ends a transaction.\n|\n| init(self, cnx)\n| Create a database connection object.\n|\n| close(self)\n| Close the connection object.\n|\n| commit(self)\n| Commit any pending transaction to the database.\n|\n| cursor(self)\n| Return a new cursor object using the connection.\n|\n| execute(self, operation, params=None)\n| Shortcut method to run an operation on an implicit cursor.\n|\n| executemany(self, operation, paramseq)\n| Shortcut method to run an operation against a sequence.\n|\n| rollback(self)\n| Roll back to the start of any pending transaction.\n|\n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| closed\n| Check whether the connection has been closed or is broken.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| DataError = \n|\n| DatabaseError = \n|\n| Error = \n|\n| IntegrityError = \n|\n| InterfaceError = \n|\n| InternalError = \n|\n| NotSupportedError = \n|\n| OperationalError = \n|\n| ProgrammingError = \n|\n| Warning = \n\n#### class Cursor\n\n| Cursor(dbcnx)\n|\n| Cursor object.\n|\n| Methods defined here:\n|\n| enter(self)\n| Enter the runtime context for the cursor object.\n|\n| exit(self, et, ev, tb)\n| Exit the runtime context for the cursor object.\n|\n| init(self, dbcnx)\n| Create a cursor object for the database connection.\n|\n| iter(self)\n| Make cursor compatible to the iteration protocol.\n|\n| next(self)\n| Return the next row (support for the iteration protocol).\n|\n| buildrowfactory(self)\n| Build a row factory based on the current description.\n|\n| This implementation builds a row factory for creating named tuples.\n| You can overwrite this method if you want to dynamically create\n| different row factories whenever the column description changes.\n|\n| callproc(self, procname, parameters=None)\n| Call a stored database procedure with the given name.\n|\n| The sequence of parameters must contain one entry for each input\n| argument that the procedure expects. The result of the call is the\n| same as this input sequence; replacement of output and input/output\n| parameters in the return value is currently not supported.\n|\n| The procedure may also provide a result set as output. These can be\n| requested through the standard fetch methods of the cursor.\n|\n| close(self)\n| Close the cursor object.\n|\n| copyfrom(self, stream, table, format=None, sep=None, null=None, size=None, columns=None)\n| Copy data from an input stream to the specified table.\n|\n| The input stream can be a file-like object with a read() method or\n| it can also be an iterable returning a row or multiple rows of input\n| on each iteration.\n|\n| The format must be text, csv or binary. The sep option sets the\n| column separator (delimiter) used in the non binary formats.\n| The null option sets the textual representation of NULL in the input.\n|\n| The size option sets the size of the buffer used when reading data\n| from file-like objects.\n|\n| The copy operation can be restricted to a subset of columns. If no\n| columns are specified, all of them will be copied.\n|\n| copyto(self, stream, table, format=None, sep=None, null=None, decode=None, columns=None)\n| Copy data from the specified table to an output stream.\n|\n| The output stream can be a file-like object with a write() method or\n| it can also be None, in which case the method will return a generator\n| yielding a row on each iteration.\n|\n| Output will be returned as byte strings unless you set decode to true.\n|\n| Note that you can also use a select query instead of the table name.\n|\n| The format must be text, csv or binary. The sep option sets the\n| column separator (delimiter) used in the non binary formats.\n| The null option sets the textual representation of NULL in the output.\n|\n| The copy operation can be restricted to a subset of columns. If no\n| columns are specified, all of them will be copied.\n|\n| execute(self, operation, parameters=None)\n| Prepare and execute a database operation (query or command).\n|\n| executemany(self, operation, seqofparameters)\n| Prepare operation and execute it against a parameter sequence.\n|\n| fetchall(self)\n| Fetch all (remaining) rows of a query result.\n|\n| fetchmany(self, size=None, keep=False)\n| Fetch the next set of rows of a query result.\n|\n| The number of rows to fetch per call is specified by the\n| size parameter. If it is not given, the cursor's arraysize\n| determines the number of rows to be fetched. If you set\n| the keep parameter to true, this is kept as new arraysize.\n|\n| fetchone(self)\n| Fetch the next row of a query result set.\n|\n| next = next(self)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| nextset()\n| Not supported.\n|\n| rowfactory(row)\n| Process rows before they are returned.\n|\n| You can overwrite this statically with a custom row factory, or\n| you can build a row factory dynamically with buildrowfactory().\n|\n| For example, you can create a Cursor class that returns rows as\n| Python dictionaries like this:\n|\n| class DictCursor(pgdb.Cursor):\n|\n| def rowfactory(self, row):\n| return {desc[0]: value\n| for desc, value in zip(self.description, row)}\n|\n| cur = DictCursor(con) # get one DictCursor instance or\n| con.cursortype = DictCursor # always use DictCursor instances\n|\n| setinputsizes(sizes)\n| Not supported.\n|\n| setoutputsize(size, column=0)\n| Not supported.\n|\n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| colnames\n| Unofficial convenience method for getting the column names.\n|\n| coltypes\n| Unofficial convenience method for getting the column types.\n|\n| description\n| Read-only attribute describing the result columns.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n\n#### class DataError\n\n| Method resolution order:\n| DataError\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class DatabaseError\n\n| Method resolution order:\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class Error\n\n| Method resolution order:\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class Hstore\n\n| Wrapper class for marking hstore values.\n|\n| Method resolution order:\n| Hstore\n| builtins.dict\n| builtins.object\n|\n| Methods defined here:\n|\n| str(self)\n| Return str(self).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.dict:\n|\n| contains(self, key, /)\n| True if the dictionary has the specified key, else False.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(...)\n| x.getitem(y) <==> x[y]\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self size of D in memory, in bytes\n|\n| clear(...)\n| D.clear() -> None. Remove all items from D.\n|\n| copy(...)\n| D.copy() -> a shallow copy of D\n|\n| get(self, key, default=None, /)\n| Return the value for key if key is in the dictionary, else default.\n|\n| items(...)\n| D.items() -> a set-like object providing a view on D's items\n|\n| keys(...)\n| D.keys() -> a set-like object providing a view on D's keys\n|\n| pop(...)\n| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n|\n| If the key is not found, return the default if given; otherwise,\n| raise a KeyError.\n|\n| popitem(self, /)\n| Remove and return a (key, value) pair as a 2-tuple.\n|\n| Pairs are returned in LIFO (last-in, first-out) order.\n| Raises KeyError if the dict is empty.\n|\n| setdefault(self, key, default=None, /)\n| Insert key with a value of default if key is not in the dictionary.\n|\n| Return the value for key if key is in the dictionary, else default.\n|\n| update(...)\n| D.update([E, ]F) -> None. Update D from dict/iterable E and F.\n| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]\n| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v\n| In either case, this is followed by: for k in F: D[k] = F[k]\n|\n| values(...)\n| D.values() -> an object providing a view on D's values\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.dict:\n|\n| classgetitem(...) from builtins.type\n| See PEP 585\n|\n| fromkeys(iterable, value=None, /) from builtins.type\n| Create a new dictionary with keys from iterable and values set to value.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.dict:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from builtins.dict:\n|\n| hash = None\n\n#### class IntegrityError\n\n| Method resolution order:\n| IntegrityError\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class InterfaceError\n\n| Method resolution order:\n| InterfaceError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class Json\n\n| Json(obj, encode=None)\n|\n| Construct a wrapper for holding an object serializable to JSON.\n|\n| Methods defined here:\n|\n| init(self, obj, encode=None)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| str(self)\n| Return str(self).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n\n#### class Literal\n\n| Literal(sql)\n|\n| Construct a wrapper for holding a literal SQL string.\n|\n| Methods defined here:\n|\n| init(self, sql)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| pgrepr = str(self)\n|\n| str(self)\n| Return str(self).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n\n#### class NotSupportedError\n\n| Method resolution order:\n| NotSupportedError\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class OperationalError\n\n| Method resolution order:\n| OperationalError\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class ProgrammingError\n\n| Method resolution order:\n| ProgrammingError\n| DatabaseError\n| Error\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors inherited from Error:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.Exception:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.Exception:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\n#### class Type\n\n| Type(values)\n|\n| Type class for a couple of PostgreSQL data types.\n|\n| PostgreSQL is object-oriented: types are dynamic.\n| We must thus use type names as internal type codes.\n|\n| Method resolution order:\n| Type\n| builtins.frozenset\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, other)\n| Return self==value.\n|\n| ne(self, other)\n| Return self!=value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(cls, values)\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.frozenset:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| contains(...)\n| x.contains(y) <==> y in x.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self size of S in memory, in bytes\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| copy(...)\n| Return a shallow copy of a set.\n|\n| difference(...)\n| Return the difference of two or more sets as a new set.\n|\n| (i.e. all elements that are in this set but not the others.)\n|\n| intersection(...)\n| Return the intersection of two sets as a new set.\n|\n| (i.e. all elements that are in both sets.)\n|\n| isdisjoint(...)\n| Return True if two sets have a null intersection.\n|\n| issubset(...)\n| Report whether another set contains this set.\n|\n| issuperset(...)\n| Report whether this set contains another set.\n|\n| symmetricdifference(...)\n| Return the symmetric difference of two sets as a new set.\n|\n| (i.e. all elements that are in exactly one of the sets.)\n|\n| union(...)\n| Return the union of sets as a new set.\n|\n| (i.e. all elements that are in either set.)\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.frozenset:\n|\n| classgetitem(...) from builtins.type\n| See PEP 585\n\nUuid = class UUID(builtins.object)\n| Uuid(hex=None, bytes=None, bytesle=None, fields=None, int=None, version=None, *, issafe=)\n|\n| Instances of the UUID class represent UUIDs as specified in RFC 4122.\n| UUID objects are immutable, hashable, and usable as dictionary keys.\n| Converting a UUID to a string with str() yields something in the form\n| '12345678-1234-1234-1234-123456789abc'. The UUID constructor accepts\n| five possible forms: a similar string of hexadecimal digits, or a tuple\n| of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and\n| 48-bit values respectively) as an argument named 'fields', or a string\n| of 16 bytes (with all the integer fields in big-endian order) as an\n| argument named 'bytes', or a string of 16 bytes (with the first three\n| fields in little-endian order) as an argument named 'bytesle', or a\n| single 128-bit integer as an argument named 'int'.\n|\n| UUIDs have these read-only attributes:\n|\n| bytes the UUID as a 16-byte string (containing the six\n| integer fields in big-endian byte order)\n|\n| bytesle the UUID as a 16-byte string (with timelow, timemid,\n| and timehiversion in little-endian byte order)\n|\n| fields a tuple of the six integer fields of the UUID,\n| which are also available as six individual attributes\n| and two derived attributes:\n|\n| timelow the first 32 bits of the UUID\n| timemid the next 16 bits of the UUID\n| timehiversion the next 16 bits of the UUID\n| clockseqhivariant the next 8 bits of the UUID\n| clockseqlow the next 8 bits of the UUID\n| node the last 48 bits of the UUID\n|\n| time the 60-bit timestamp\n| clockseq the 14-bit sequence number\n|\n| hex the UUID as a 32-character hexadecimal string\n|\n| int the UUID as a 128-bit integer\n|\n| urn the UUID as a URN as specified in RFC 4122\n|\n| variant the UUID variant (one of the constants RESERVEDNCS,\n| RFC4122, RESERVEDMICROSOFT, or RESERVEDFUTURE)\n|\n| version the UUID version number (1 through 5, meaningful only\n| when the variant is RFC4122)\n|\n| issafe An enum indicating whether the UUID has been generated in\n| a way that is safe for multiprocessing applications, via\n| uuidgeneratetimesafe(3).\n|\n| Methods defined here:\n|\n| eq(self, other)\n| Return self==value.\n|\n| ge(self, other)\n| Return self>=value.\n|\n| getstate(self)\n|\n| gt(self, other)\n| Return self>value.\n|\n| hash(self)\n| Return hash(self).\n|\n| init(self, hex=None, bytes=None, bytesle=None, fields=None, int=None, version=None, *, issafe=)\n| Create a UUID from either a string of 32 hexadecimal digits,\n| a string of 16 bytes as the 'bytes' argument, a string of 16 bytes\n| in little-endian order as the 'bytesle' argument, a tuple of six\n| integers (32-bit timelow, 16-bit timemid, 16-bit timehiversion,\n| 8-bit clockseqhivariant, 8-bit clockseqlow, 48-bit node) as\n| the 'fields' argument, or a single 128-bit integer as the 'int'\n| argument. When a string of hex digits is given, curly braces,\n| hyphens, and a URN prefix are all optional. For example, these\n| expressions all yield the same UUID:\n|\n| UUID('{12345678-1234-5678-1234-567812345678}')\n| UUID('12345678123456781234567812345678')\n| UUID('urn:uuid:12345678-1234-5678-1234-567812345678')\n| UUID(bytes='\\x12\\x34\\x56\\x78'*4)\n| UUID(bytesle='\\x78\\x56\\x34\\x12\\x34\\x12\\x78\\x56' +\n| '\\x12\\x34\\x56\\x78\\x12\\x34\\x56\\x78')\n| UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))\n| UUID(int=0x12345678123456781234567812345678)\n|\n| Exactly one of 'hex', 'bytes', 'bytesle', 'fields', or 'int' must\n| be given. The 'version' argument is optional; if given, the resulting\n| UUID will have its variant and version set according to RFC 4122,\n| overriding the given 'hex', 'bytes', 'bytesle', 'fields', or 'int'.\n|\n| issafe is an enum exposed as an attribute on the instance. It\n| indicates whether the UUID has been generated in a way that is safe\n| for multiprocessing applications, via uuidgeneratetimesafe(3).\n|\n| int(self)\n|\n| le(self, other)\n| Return self<=value.\n|\n| lt(self, other)\n| Return self\nBINARY = Type({'bytea'})\nBOOL = Type({'bool'})\nDATE = Type({'date'})\nDATETIME = Type({'time', 'timestamp', 'timetz', 'timestamptz', 'date',...\nFLOAT = Type({'float8', 'float4'})\nHSTORE = Type({'hstore'})\nINTEGER = Type({'int4', 'serial', 'int2', 'int8'})\nINTERVAL = Type({'interval'})\nJSON = Type({'jsonb', 'json'})\nLONG = Type({'int8'})\nMONEY = Type({'money'})\nNUMBER = Type({'float4', 'serial', 'int4', 'float8', 'numeric', 'money...\nNUMERIC = Type({'numeric'})\nRECORD = \nROWID = Type({'oid'})\nSMALLINT = Type({'int2'})\nSTRING = Type({'char', 'name', 'varchar', 'text', 'bpchar'})\nTIME = Type({'time', 'timetz'})\nTIMESTAMP = Type({'timestamp', 'timestamptz'})\nUUID = Type({'uuid'})\nall = ['Connection', 'Cursor', 'Date', 'Time', 'Timestamp', 'DateF...\napilevel = '2.0'\nparamstyle = 'pyformat'\nthreadsafety = 1\nversion = '5.1.2'\n\n### VERSION\n\n5.1.2\n\n### FILE\n\n/usr/lib/python3/dist-packages/pgdb.py\n\n" } ], "structuredContent": { "command": "pgdb", "section": "", "mode": "pydoc", "summary": "pgdb - pgdb - DB-API 2.0 compliant module for PyGreSQL.", "synopsis": null, "tldr_summary": null, "tldr_examples": [], "tldr_source": null, "flags": [], "examples": [], "see_also": [], "section_outline": [ { "name": "NAME", "lines": 2, "subsections": [] }, { "name": "DESCRIPTION", "lines": 53, "subsections": [] }, { "name": "CLASSES", "lines": 23, "subsections": [ { "name": "class Binary", "lines": 397 }, { "name": "class Connection", "lines": 77 }, { "name": "class Cursor", "lines": 150 }, { "name": "class DataError", "lines": 69 }, { "name": "class DatabaseError", "lines": 68 }, { "name": "class Error", "lines": 67 }, { "name": "class Hstore", "lines": 145 }, { "name": "class IntegrityError", "lines": 69 }, { "name": "class InterfaceError", "lines": 68 }, { "name": "class Json", "lines": 21 }, { "name": "class Literal", "lines": 23 }, { "name": "class NotSupportedError", "lines": 69 }, { "name": "class OperationalError", "lines": 69 }, { "name": "class ProgrammingError", "lines": 69 }, { "name": "class Type", "lines": 295 }, { "name": "class Warning", "lines": 67 } ] }, { "name": "FUNCTIONS", "lines": 21, "subsections": [ { "name": "connect", "lines": 2 }, { "name": "get_typecast", "lines": 2 }, { "name": "reset_typecast", "lines": 7 }, { "name": "set_typecast", "lines": 5 } ] }, { "name": "DATA", "lines": 27, "subsections": [] }, { "name": "VERSION", "lines": 2, "subsections": [] }, { "name": "FILE", "lines": 3, "subsections": [] } ] } }