Ejemplo n.º 1
0
    def _finish_tpc(self, command, fallback, xid):
        if xid:
            # committing/aborting a received transaction.
            if self.status != consts.STATUS_READY:
                raise exceptions.ProgrammingError(
                    "tpc_commit/tpc_rollback with a xid "
                    "must be called outside a transaction")

            self._execute_tpc_command(command, xid)

        else:
            # committing/aborting our own transaction.
            if not self._tpc_xid:
                raise exceptions.ProgrammingError(
                    "tpc_commit/tpc_rollback with no parameter "
                    "must be called in a two-phase transaction")

            if self.status == consts.STATUS_BEGIN:
                fallback()
            elif self.status == consts.STATUS_PREPARED:
                self._execute_tpc_command(command, self._tpc_xid)
            else:
                raise exceptions.InterfaceError(
                    'unexpected state in tpc_commit/tpc_rollback')

            self.status = consts.STATUS_READY
            self._tpc_xid = None
Ejemplo n.º 2
0
    def tpc_begin(self, xid):
        if not isinstance(xid, Xid):
            xid = Xid.from_string(xid)

        if self.status != consts.STATUS_READY:
            raise exceptions.ProgrammingError(
                'tpc_begin must be called outside a transaction')

        if self._autocommit:
            raise exceptions.ProgrammingError(
                "tpc_begin can't be called in autocommit mode")

        self._begin_transaction()
        self._tpc_xid = xid
Ejemplo n.º 3
0
    def tpc_prepare(self):
        if not self._tpc_xid:
            raise exceptions.ProgrammingError(
                'prepare must be called inside a two-phase transaction')

        self._execute_tpc_command('PREPARE TRANSACTION', self._tpc_xid)
        self.status = consts.STATUS_PREPARED
Ejemplo n.º 4
0
    def cursor(self, name=None, cursor_factory=Cursor, withhold=False):
        cur = cursor_factory(self, name)

        if not isinstance(cur, Cursor):
            raise TypeError("cursor factory must be subclass of %s" %
                            '.'.join([Cursor.__module__, Cursor.__name__]))

        if withhold:
            if name:
                cur.withhold = True
            else:
                raise exceptions.ProgrammingError(
                    "withhold=True can be specified only for named cursors")

        if name and self._async:
            raise exceptions.ProgrammingError(
                "asynchronous connections cannot produce named cursors")

        cur._mark = self._mark
        return cur
Ejemplo n.º 5
0
    def __init__(self, conn=None, oid=0, mode='', new_oid=0, new_file=None):
        self._conn = conn
        self._oid = oid
        self._mode = self._parse_mode(mode)
        self._smode = mode
        self._new_oid = new_oid
        self._new_file = new_file
        self._fd = -1
        self._mark = conn._mark

        if conn.autocommit:
            raise exceptions.ProgrammingError(
                "can't use a lobject outside of transactions")
        self._open()
Ejemplo n.º 6
0
    def _execute_green(self, query):
        """Execute version for green threads"""
        if self._async_cursor:
            raise exceptions.ProgrammingError(
                "a single async query can be executed on the same connection")

        self._async_cursor = True

        if not libpq.PQsendQuery(self._pgconn, query):
            self._async_cursor = None
            return

        self._async_status = consts.ASYNC_WRITE

        try:
            _green_callback(self)
            return util.pq_get_last_result(self._pgconn)
        except:
            util.pq_clear_async(self._pgconn)
            raise
        finally:
            self._async_cursor = None
            self._async_status = consts.ASYNC_DONE
Ejemplo n.º 7
0
 def check_async_(self, *args, **kwargs):
     if self._async:
         raise exceptions.ProgrammingError(
             '%s cannot be used in asynchronous mode' % func.__name__)
     return func(self, *args, **kwargs)
Ejemplo n.º 8
0
 def check_tpc_(self, *args, **kwargs):
     if self._tpc_xid:
         raise exceptions.ProgrammingError(
             '%s cannot be used during a two-phase transaction' %
             func.__name__)
     return func(self, *args, **kwargs)
Ejemplo n.º 9
0
 def check_notrans_(self, *args, **kwargs):
     if self.status != consts.STATUS_READY:
         raise exceptions.ProgrammingError('not valid in transaction')
     return func(self, *args, **kwargs)
Ejemplo n.º 10
0
 def check_unmarked_(self, *args, **kwargs):
     if self._mark != self._conn._mark:
         raise exceptions.ProgrammingError("lobject isn't valid anymore")
     return func(self, *args, **kwargs)